Java排序算法总结

本文中所有代码均可在码云中下载
notion国内替代品，wolai笔记，大家可以看一下，别忘了码：UWZD8MI

---

插入排序

时间复杂度: O(N^2)

插入排序:是将未排序的一组数中的一个数插入已排序的数中的合适位置。最开始，将最前端的一个数看成已排序。

算法思路：对数组遍历，内置循环，选取当前位置为临时值，往前遍历，找到合适插入位置

public class SimpleInsertSort {
    
    public  static void sort(int[] array){
        int length = array.length;
        int temp;
        for(int i=1;i<length;i++){
            temp = array[i];
            int j =i-1;
            while(j>=0 && array[j]>temp){
                array[j+1]=array[j];
                j--;
            }
            array[j+1]=temp;
    }
    }
    public static void main(String[] args) {
        int[] array={3,9,6,4,2,1,7,0,5,8};
        sort(array);
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }
}

---

冒泡排序

Created: Jul 14, 2020 6:51 PM

Tags: 比较类排序 比较排序

时间复杂度: O( n^2 )

冒泡排序，依次将相邻的两个数比较，若前面的数比后面的数大，则将其位置调换，每一趟下来，都会将最大的数移至最后，再对其它数重复该操作，直至只剩一个数时排序完毕。

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class BubbleSort{
    public void bubbleSort(int []nums){
        int length = nums.length;
        if(length<=1){
            System.out.println(nums[0]);
        }
        else{
            for(int i=0;i<length;i++){
                for(int j=0;j<length-i-1;j++){
                    if (nums[j]>nums[j+1]){
                        int temp = nums[j];
                        nums[j]=nums[j+1];
                        nums[j+1]=temp;
                    }
                }
            }
            for(int i=0;i<length;i++){
                System.out.print(nums[i]);
                System.out.print(" ");
            }
            
        }
    }
    public static void main(String[] args) {
        System.out.println("Please input arry with splited by ,");
        Scanner scanner=new Scanner(System.in);
        String str=scanner.nextLine();
        String[] Arrays=str.split(",");  
        int[] nums =new int[Arrays.length];
        for(int i=0;i<nums.length;i++){
            nums[i]=Integer.parseInt(Arrays[i]); 
            }
        
        
        BubbleSort bubble=new BubbleSort();
        bubble.bubbleSort(nums);
    }
}

---

快速排序

时间复杂度: O(nlogn)

排序算法：以一个数为基准，对所有数分类，将所有小于基准数的数放在左边，大于基准数的数放在右边。再对左右两边以此排序。

算法思路：采用双指针，先从右向左遍历，找到比基准数小的数，再从左往右遍历，找到比基准数大的数，将这两个数交换位置，再继续遍历，知道两个指针在同一位置。将这个位置的数与基准数交换位置。这样基准数左边都是比基准数小的数，右边都是比基准数大的数。再对左右两边排序，直到所有数都已排序。

插入排序在小规模数据或数据基本有序时高效。

public class QuickSort{
    public static void sort(int[] array, int left, int right) {
        if(left>right){
            return ;
        }
        int i = left;
        int j = right;
        int temp = array[left];
        while (i!=j) {
            while (array[j] >=temp && i<j) {
                j--;
            }
            while (array[i] <= temp && i < j) {
                i++;
            }
            if (i < j) {
                int temp_arry = array[i];
                array[i] = array[j];
                array[j] = temp_arry;
            }
        }
        array[left] = array[i];
        array[i] = temp;
       
        sort(array, left, i-1);
        sort(array, i+1, right);
    }
    public static void main(String[] args) {
        int[] array = {3,6,7,2,8,1,9,0,5,4};
        sort(array, 0, 9);
        
        for(int i = 0;i<array.length;i++){
            System.out.print(array[i]);
        }
    }
}

---

简单选择排序

算法原理：首先选择最小的数放在首位，再从剩下的数中选取最小的数放在已排好序的末尾，直至只剩最后一个数，至此所有数已完成排序

算法思路：选取未排序的数中最小的数，与未排序数的首位交换位置

时间复杂度：O(n)

/**
 * @param :index 获取最小数在数组中位置
 * @param :min 未排序数中最小的数
 */
public class SimpleSelectSort{
    public static int findMin(int start,int[]array){
        int min = array[start];
        int index =start;
        for(int i =start;i<array.length;i++){

            if(array[i]<=min){
                min=array[i];
                index = i;

            }

        }

        return index;
    }
    public static void sort(int[] array){
        int i=0;
        while(i<array.length){
            int min = findMin(i, array);
            System.out.println(array[min]);
            if(min!=i){

                int temp = array[i];
                array[i]= array[min];
                array[min] = temp;
            }
            i++;
        }
    }

    public static void main(String[] args) {
        int[] array={3,6,8,9,0,1,7,2,4,5};
         sort(array);
        for(int i =0;i<array.length;i++){
            System.out.print(array[i]);
        }
    }
}

##希尔排序
Created: Jul 14, 2020 8:02 PM

Tags: 比较类排序 插入排序

时间复杂度: T(n) = O(nlogn)

希尔排序：将数据分组，每组采用直接插入排序算法排序，不断减小分组间隔，直到间隔为1.

算法思路：对分组数目循环遍历，再对每一组采用直接插入排序。

public class ShellSort {
    public static void sort(int[] array){
        int length = array.length;
        for(int gap=length/2;gap>0;gap=gap/2){
            for(int i=0;i<gap;i++){
                for(int j=i+gap;j<length;j=j+gap){{
                    if(array[j]<array[j-gap]){
                        int temp =array[j];
                        int k = j-gap;
                        while(k>=0 && array[k]>temp){
                            array[k+gap]=array[k];
                            k-=gap;
                        }
                        array[k+gap]=temp;
                    }
                }}
            }
        }
        }
        public static void main(String[] args) {
            int[] array={3,6,9,5,2,1,8,7,4,0};
            sort(array);
            for(int i =0;i<array.length;i++){
                System.out.println(array[i]);
            }
        }
    }

---

计数排序

算法原理：计数排序是将按待排的数为数组下标生成一个新数组，遍历数组，数据每出现一次，相应下标所对应的值加一

算法思路：计算待排序数据的范围，即最大值与最小值之和，生成新数组，初始值为0，其大小为待排序数据的最大值与最小值之和加1，遍历待排序数组，若其值减去最小值与新生成数组下标一致，将新生成数组下标对应值加1

public class CountSort {
    public static void sort(int[] array) {
        int length = array.length;
        int min = 0, max = 0;
        for (int i = 0; i < length; i++) {
            if (min >= array[i]) {
                min = array[i];
            }
            if (max <= array[i]) {
                max = array[i];
            }
        }
        int d = max - min + 1;
        int[] tem_array = new int[d];
        for (int j : array) {
            tem_array[j - min]++;
        }
        for (int h = 0; h < length; h++) {
            for (int k = 0; k < tem_array[h]; k++) {
                System.out.print(h+min);
            }
        }
    }

    public static void main(String[] args) {
        int[] array={9,8,6,3,2,1,7,4,0,5};
        sort(array);

    }
}

---

##二路归并排序
算法原理：二路归并排序是将一个待排序数组分为两个子序列，再将两个子序列分割，按此分割下去直至不可再分。让后再将数据排序合并。

算法思路：在合并两个子序列时，创建一个新数组用来接收已排序的数据，两个指针指向两个子序列首端，比较两序列指针所指两个数大小。将较小的数放入新数组中，并将该序列指针和新数组指针向前移一位，继续比较两序列大小，直至所有数都放入新数组中。在使用二路归并时，先将左右两个子序列分割，最后归并

时间复杂度：O(nlogn)

public class TwoWayMergeSort {
    
    public static void merge(int[] array,int left,int mid,int right){
        int[] temp_array=new int[array.length];
        int leftStart = left;
        int rightStart = mid+1;
        int tempIndex = left;
        while (leftStart<=mid && rightStart<=right ){
            if (array[leftStart]<array[rightStart]){
                temp_array[tempIndex++]=array[leftStart++];
            }
            else{
                temp_array[tempIndex++]=array[rightStart++];
            }
        }
        while(leftStart <= mid) {
            temp_array[tempIndex++] = array[leftStart++];
        }

        while(rightStart <= right) {
            temp_array[tempIndex++] = array[rightStart++];
        }

        while(left <= right) {
            array[left] = temp_array[left++];
        }

    }

    public static void mergesort(int[] array,int left,int right){
        if (array==null){
            return;
        }
        if (left<right){
            int mid = (left+right)/2;
            mergesort(array,left,mid);
            mergesort(array,mid+1,right);
            merge(array,left,mid,right);

        }
    }

    public static void main(String[] args) {
        int[] array={3,1,8,9,6,5,2,4,7,0};
        mergesort(array,0,9);
        for (int i=0;i<array.length;i++){
            System.out.print(array[i]);
        }
    }
}

---

桶排序

算法原理：桶排序是将待排序数组分为若干组，即“桶”，将数据装入这些桶中，将每个桶内数据先排序，最后将所有桶排序合并。

算法思路：数组分桶 的依据为：

int num =(array[i]-min)/((max-min)/(length-1));

创建ArrayList类型桶，桶中元素为LinkerList类，将数据按照分组依据添加至桶中。再将桶中元素排序，最后按照顺序将同种元素合并。

时间复杂度:O(n)

import java.util.*;

public class BucketSort {
    public static void sort(int[]array){
        int length=array.length;
        int min=0;
        int max=0;
        for (int i=0;i<length;i++){
            if(min>=array[i]){
                min=array[i];
            }
            if (max<=array[i]){
                max=array[i];
            }
        }
        List<LinkedList<Integer>> bucketList = new ArrayList<>(length);
        for (int i = 0;i<length;i++){
            bucketList.add(new LinkedList<>());
        }
        for (int i=0;i<length;i++){
            int num =(array[i]-min)/((max-min)/(length-1));
            bucketList.get(num).add(array[i]);
        }
        for (int i =0;i<length;i++){
            Collections.sort(bucketList.get(i));
        }

        int k =0;
        for (LinkedList<Integer> bucket:bucketList) {
            for (int bucketIndex:bucket) {
                array[k++]=bucketIndex;
            }
        }

        for (int i=0;i<length;i++){
            System.out.print(array[i]);
        }
    }

    public static void main(String[] args) {
        int[] array={3,8,9,1,2,4,5,7,0,6};
        sort(array);
    }
}