排序算法

冒泡排序

public static void maopao(int[] ranList) {
    for(int i=1;i<ranList.length;i++){
        for (int j=0;j<ranList.length - 1;j++){
            if(ranList[j] > ranList[j+1]){
                int temp = ranList[j];
                ranList[j] = ranList[j+1];
                ranList[j+1] = temp;
            }
        }
    }
}

排序流程

(1)对数组中的各数据，依次比较相邻的两个元素的大小。
(2)如果前面的数据大于后面的数据，就交换这两个数据。经过第一轮的多次比较排序后，便可把最小的数据排好。
(3)再用同样的方法把剩下的数据逐个进行比较，最后便可按照从小到大的顺序排好数组各数据的顺序

自我理解
冒泡排序就是将相邻两个元素进行比较，如果前面大于后面的就进行交换（升序排序，降序排序则相反）。

例如：对数组{0，8，2，1}
第1轮
0 2 1 8
第2轮
0 1 2 8
第3轮
0 1 2 8

选择排序

public static void select_sort(int[] ranList) {
    for (int i=0;i<ranList.length-1;i++){
        int index = i;
        for (int j=i+1;j<ranList.length;j++){
            if (ranList[j]<ranList[index]){
                index = j;
            }
        }
        if (index != i){
            int temp = ranList[i];
            ranList[i] = ranList[index];
            ranList[index] = temp;
        }
    }
}

排序流程
(1)首先从原始数组中选择最小的1个数据，将其和位于第I个位置的数据交换。
(2)接着从剩下的n-1个数据中选择次小的1个元素，将其和第2个位置的数据交换。
(3)然后，这样不断重复，直到最后两个数据完成交换。至此，便完成了对原始数组的从小到大的排序。

实例理解
寻找未排好序的元素里面的最小值，已经排好序的不再参与排序

数组{0，8，2，1，6}进行选择排序
第1轮
0 8 2 1 6
第2轮
0 1 2 8 6
第3轮
0 1 2 8 6
第4轮
0 1 2 6 8

插入排序

public static void select_sort(int[] ranList) {
    for (int i=0;i<ranList.length-1;i++){
        int index = i;
        for (int j=i+1;j<ranList.length;j++){
            if (ranList[j]<ranList[index]){
                index = j;
            }
        }
        if (index != i){
            int temp = ranList[i];
            ranList[i] = ranList[index];
            ranList[index] = temp;
        }

    }
}

排序流程

(1)首先对数组的前两个数据进行从小到大的排序。
(2)接着将第3个数据与排好序的两个数据比较，将第3个数据插入到合适的位置。
(3)然后，将第4个数据插入到已排好序的前3个数据中。
(4)不断重复上述过程，直到把最后一个数据插入合适的位置。最后，便完成了对原始小到大的排序。

希尔排序（shell sort)

public static void shell_sort(int[] ranList) {
    int k = 0;
    for (int r = ranList.length/2;r>=1;r/=2){
        for (int i = r;i<ranList.length;i++){
            int temp = ranList[i];
            int j = i - r;
            while (j>=0&&temp<ranList[j]){
                ranList[j+r] = ranList[j];
                j-=r;
            }
            ranList[j+r] = temp;
        }
        k++;
        System.out.println();
        System.out.println("第"+k+"次排序");
        for (int a : ranList){
            System.out.print(a+"\t");
        }
    }
}

排序流程

1. 将有n个元素的数组分成n/2个数字序列，第1个数据和第n/2+1个数据为一对，…
2. 循环使每一个序列对排好顺序。
3. 然后，再变为n/4个序列，再次排序。循环使每一个序列对排好顺序。
4. 不断重复上述过程，随着序列减少最后变为-一个，也就完成了整个排序。

图示

个人理解
希尔排序的过程是插入排序的一般情况，插入排序只是希尔排序的一种特殊情况（步长为1的希尔排序）。希尔排序的每一轮排序，都是一次插入排序。

快速排序

    public static void myQuick(int[] a,int left,int right) {
        int ltemp = left;
        int rtemp = right;
//        选取中间一个作为关键数字
        int key = a[(left+right)/2];
//        将大于关键数字的元素放在右边，小于关键字的放在左边
        while (ltemp<rtemp){
            while (a[ltemp]<key){
                ltemp++;
            }
            while (a[rtemp]>key){
                rtemp--;
            }
            if (ltemp<=rtemp){

                int temp = a[ltemp];
                a[ltemp] = a[rtemp];
                a[rtemp] = temp;
//                退出循环
                ++ltemp;
                --rtemp;
            }
        }
//        对最后两个元素进行排序
        if (ltemp == rtemp){
            ltemp++;
        }
//        对左边进行排序
        if (left<rtemp){
            myQuick(a,left,ltemp-1);
        }
//        对右边进行排序
        if (right>ltemp){
            myQuick(a,rtemp+1,right);
        }
    }

排序流程

1. 首先设定一个分界值，通过该分界值将数组分成左右两部分。
2. 将大于等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于等于分界值,而右边部分中各元素都大于等于分界值。
3. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样将左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4. 重复上述步骤

视频演示
https://www.bilibili.com/video/av10076626?from=search&seid=1195437046345651529

个人理解
折半与冒泡的综合