冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现

常见排序算法实现

冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现

文章目录

冒泡排序

冒泡排序算法,对给定的整数数组进行升序排序。冒泡排序是一种简单的排序算法,通过多次遍历数组并相邻元素比较与交换来排列数组。代码最后将排序后的数组打印到控制台上,输出结果为:1 2 3 5 8 9。

java 复制代码
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 3, 9, 1};
        bubbleSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // swap arr[j] and arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

选择排序

选择排序算法,其主要功能是对一个整数数组进行升序排序。选择排序的基本思想是每次从未排序部分中选择最小元素,将其放在已排好序的部分的末尾。该算法的时间复杂度为 O(n²),在数据量较小的情况下性能较为优秀。最终,排序后的数组会被打印输出。

java 复制代码
public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 3, 9, 1};
        selectionSort(arr); // sorting the array in ascending order
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex!= i) {
                int temp = arr[i];   // swapping the elements
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }
}

计数排序

计数排序是一种非比较排序算法,主要用于对范围较小的整数集合进行排序。其主要功能是对给定的整数数组 arr 进行从小到大的排序。该算法的时间复杂度为 O(n + k),其中 n 是数组元素的个数,k 是最大元素的值,适合用于处理大量重复值的数据集。

java 复制代码
public class CountingSort {
    public static void main(String[] args) {
        int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
        int max = 9;
        int[] count = new int[max + 1];
        int[] output = new int[arr.length];

        // Step 1: Count the frequency of each element
        for (int i = 0; i < arr.length; i++) {
            count[arr[i]]++;
        }

        // Step 2: Calculate the cumulative sum of the frequency
        for (int i = 1; i <= max; i++) {
            count[i] += count[i - 1];
        }

        // Step 3: Place each element in its correct position in the output array
        for (int i = arr.length - 1; i >= 0; i--) {
            output[count[arr[i]] - 1] = arr[i];
            count[arr[i]]--;
        }

        // Step 4: Copy the output array to the original array
        for (int i = 0; i < arr.length; i++) {
            arr[i] = output[i];
        }

        // Print the sorted array
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

插入排序

插入排序算法,其主要功能是对一个随机生成的整数数组进行排序。插入排序是一种简单直观的排序算法,适合于小规模的数组,时间复杂度为 O(n^2)。通过不断将未排序的元素插入到已排序部分的合适位置,最终得到一个升序排列的数组。代码中的 main 方法演示了如何使用这个方法并输出排序结果。

java 复制代码
public class InsertionSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 4, 6, 1, 3};
        insertionSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }
}

快速排序

快速排序算法,其主要功能是对一个整数数组进行排序。快速排序是一种高效的排序算法,其平均时间复杂度为 O(n log n)。该代码通过选择支点(通常是数组的最后一个元素),然后将数组分为两个子数组,递归地对这两个子数组进行排序,最终得到一个有序的数组。打印输出展示了排序结果。

java 复制代码
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 3, 9, 1, 7, 4, 6};
        quickSort(arr, 0, arr.length - 1);
        for (int i : arr) { System.out.print(i + " "); }
    }

    public static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int pivotIndex = partition(arr, left, right);
            quickSort(arr, left, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, right);
        }
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int i = left - 1;
        for (int j = left; j < right; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[right];
        arr[right] = temp;
        return i + 1;
    }
}

堆排序

堆排序的主要功能:将一个整数数组排序。堆排序的过程包括建立最大堆并逐步将最大元素移动到数组的末尾,最终得到升序排列的数组。整个算法的时间复杂度为 O(n log n),空间复杂度为 O(1)。堆排序是一种不稳定的排序算法。

java 复制代码
public class HeapSort {
    public static void sort(int[] arr) {
        int n = arr.length;
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(arr, n, i);
        for (int i = n - 1; i >= 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            heapify(arr, i, 0);
        }
    }

    private static void heapify(int[] arr, int n, int i) {
        int largest = i;
        int l = 2 * i + 1;
        int r = 2 * i + 2;
        if (l < n && arr[l] > arr[largest])
            largest = l;
        if (r < n && arr[r] > arr[largest])
            largest = r;
        if (largest!= i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;
            heapify(arr, n, largest);
        }
    }
}

归并排序

归并排序是一种有效的排序算法,采用分治法的思想,将待排序的数组递归地分成两半,直至每个子数组只有一个元素,然后再将这些子数组合并为一个有序的整体。最终该程序能够将输入的数组 {5, 2, 8, 3, 9, 1, 7, 4, 6} 排序并打印输出。归并排序的时间复杂度为O(nlogn) 使其在处理大型数据集时十分高效。

java 复制代码
public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 3, 9, 1, 7, 4, 6};
        mergeSort(arr, 0, arr.length - 1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }

    public static void merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int i = left;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= right) {
            temp[k++] = arr[j++];
        }
        for (i = left; i <= right; i++) {
            arr[i] = temp[i - left];
        }
    }
}
相关推荐
转世成为计算机大神30 分钟前
易考八股文之Java中的设计模式?
java·开发语言·设计模式
qq_327342731 小时前
Java实现离线身份证号码OCR识别
java·开发语言
Swift社区1 小时前
LeetCode - #139 单词拆分
算法·leetcode·职场和发展
Kent_J_Truman2 小时前
greater<>() 、less<>()及运算符 < 重载在排序和堆中的使用
算法
阿龟在奔跑2 小时前
引用类型的局部变量线程安全问题分析——以多线程对方法局部变量List类型对象实例的add、remove操作为例
java·jvm·安全·list
飞滕人生TYF2 小时前
m个数 生成n个数的所有组合 详解
java·递归
代码小鑫2 小时前
A043-基于Spring Boot的秒杀系统设计与实现
java·开发语言·数据库·spring boot·后端·spring·毕业设计
真心喜欢你吖2 小时前
SpringBoot与MongoDB深度整合及应用案例
java·spring boot·后端·mongodb·spring
激流丶2 小时前
【Kafka 实战】Kafka 如何保证消息的顺序性?
java·后端·kafka
IT 青年3 小时前
数据结构 (1)基本概念和术语
数据结构·算法