排序算法总结篇（Java版）

学习来源：https://blog.csdn.net/meibenxiang/article/details/92796909

稳定：冒泡、插入、归并、计数、基数、桶
不稳定：选择、希尔、快速、堆

1.冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 重复步骤1~3，直到排序完成。
   

public class bubblesort {
    public static void main(String[] args) {
        int[] arr= {1,2,5,4,6,9,7,8,1,1};

        for (int i = 0; i <arr.length-1 ; i++) {
            for (int j = 0; j <arr.length-1-i; j++) {
                if(arr[j+1]<arr[j]){
                    int temp =arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for (int i : arr) {
            System.out.print(i);
        }
    }
}

最佳情况：T(n) = O(n)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(n2)

2.选择排序

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

public class searchsort {
    public static void main(String[] args) {
        int[] arr = {1, 2, 5, 4, 6, 9, 7, 8, 1, 1};

        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;
                }
            }
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }

        for (int i : arr) {
            System.out.print(i);
        }
    }
}

最佳情况：T(n) = O(n2)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(n2)

3.插入排序

通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

public class insertsort {
    public static void main(String[] args) {
        int[] arr = {1, 2, 5, 4, 6, 1, 2, 2,6};

        for (int i = 1; i < arr.length; i++) {
            int num = arr[i];
            if (num > arr[i - 1]) continue;

            for (int j = i - 1; j >= 0; j--) {
                if (arr[j] > num) {
                    arr[j + 1] = arr[j];
                } else {
                    arr[j + 1] = num;
                    break;
                }
            }
        }
        for (int i : arr) {
            System.out.print(i);
        }
    }
}

最佳情况：T(n) = O(n)
最坏情况：T(n) = O(n2)
平均情况：T(n) = O(n2)

4.快速排序

public class quicksort {
    public static void main(String[] args) {
        int[] arr = {1, 2, 5, 4, 6, 1, 2, 2, 6};
        quick(arr, 0, arr.length - 1);

        for (int i1 : arr) {
            System.out.print(i1);
        }
    }

    public static void quick(int[] arr, int left, int right) {
        if (left >= right) return;
        
        int L = left;
        int R = right;
        int jizhun = arr[left];
        
        while (left < right) {
            while (left < right && arr[right] >= jizhun) {
                right--;
            }
            while (left < right && arr[left] <= jizhun) {
                left++;
            }
            if (left < right) {
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
            }

        }
        arr[L] = arr[left];
        arr[left] = jizhun;

        quick(arr, L, left - 1);
        quick(arr, left + 1, R);
    }
}

最佳情况：T(n) = O(nlogn)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(nlogn)

5.希尔排序

希尔排序也是一种插入排序，它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

最佳情况：T(n) = O(nlog2 n)
最坏情况：T(n) = O(nlog2 n)
平均情况：T(n) =O(nlog2n)

6.归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。