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

常见排序算法实现

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

文章目录

冒泡排序

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

publicclassBubbleSort{publicstaticvoidmain(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]+" ");}}publicstaticvoidbubbleSort(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²)，在数据量较小的情况下性能较为优秀。最终，排序后的数组会被打印输出。

publicclassSelectionSort{publicstaticvoidmain(String[] args){int[] arr ={5,2,8,3,9,1};selectionSort(arr);// sorting the array in ascending orderfor(int i =0; i < arr.length; i++){System.out.print(arr[i]+" ");}}publicstaticvoidselectionSort(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 是最大元素的值，适合用于处理大量重复值的数据集。

publicclassCountingSort{publicstaticvoidmain(String[] args){int[] arr ={3,1,4,1,5,9,2,6,5,3,5};int max =9;int[] count =newint[max +1];int[] output =newint[arr.length];// Step 1: Count the frequency of each elementfor(int i =0; i < arr.length; i++){
            count[arr[i]]++;}// Step 2: Calculate the cumulative sum of the frequencyfor(int i =1; i <= max; i++){
            count[i]+= count[i -1];}// Step 3: Place each element in its correct position in the output arrayfor(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 arrayfor(int i =0; i < arr.length; i++){
            arr[i]= output[i];}// Print the sorted arrayfor(int i =0; i < arr.length; i++){System.out.print(arr[i]+" ");}}}

插入排序

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

publicclassInsertionSort{publicstaticvoidmain(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]+" ");}}publicstaticvoidinsertionSort(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)。该代码通过选择支点（通常是数组的最后一个元素），然后将数组分为两个子数组，递归地对这两个子数组进行排序，最终得到一个有序的数组。打印输出展示了排序结果。

publicclassQuickSort{publicstaticvoidmain(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 +" ");}}publicstaticvoidquickSort(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);}}publicstaticintpartition(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)。堆排序是一种不稳定的排序算法。

publicclassHeapSort{publicstaticvoidsort(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);}}privatestaticvoidheapify(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) 

使其在处理大型数据集时十分高效。

publicclassMergeSort{publicstaticvoidmain(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]+" ");}}publicstaticvoidmergeSort(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);}}publicstaticvoidmerge(int[] arr,int left,int mid,int right){int[] temp =newint[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];}}}