排序算法 自己能看懂

1、选择排序：

1、从数组的第一个元素开始，默认第一个元素是最小的，从后面的元素中选择最小值，与第一个元素比较，如果第一个元素小，不变动，如果第一个元素大，与最小值对换。

2、从数组的第二个元素起作为一个新数组，数据的第二个元素作为新数据的第一个元素，重重1操作

3、依次循环2、1

 

2、冒泡排序：

1、先比较数组的第一个元素和第二个元素，如果第一个元素比第二个元素大，交换数值；接着比较第二个元素和第三个元素，如果第二个元素大，交换数据；依次类推，第一次循环完成后，最大的数据在最后面

2、数据除最后一个元素外，作为新数组，按1执行

3、重复2、1

 

3、插入排序：

1、假设数据的第一个元素是已经排好顺序的，从第二个元素开始，与前面排开顺序的比较找到盖元素应该放的位置，从该位置开始的元素都后移一位，把该元素插入到该位置

2从第三个元素开始重重复1

 

4、希尔排序：

1、先将数据按间隔分组，gap=len/2 或 gap = 3*b+1

2、每个分组按“插入排序”进行排序

3、更改gap的大小，继续“插入排序”

 

5、归并排序：

1、利用递归的方式，将数组分组，一直分到只有一个元素，要标记小数组的开始和结束位置

2、从递归的最下层合并数组，新建一个可以合并两个数组数据的新数据，从哪个数组中最小的数据放入新数组中，依次处理，将新数组复制到原数据开始结束的位置上

 

6、快速排序：

1、以数据组第一个元素作个对比数值提出；从后向前移，找到比对比数值小的元素（位置假定为J），将找到的小元素放入第一个元素；再从前向后移，找到比对比数据大的元素（位置假定为I），将找大的大元素放入J位置，依次类推

2、将提出的值放在这I中

3、将I左边的值按1进行处理，将I右边的值按1进行处理

 

7、计数排序

1、先找到数组中的最大值

2、新建一个长度为最大值的数组，数组初始值为0

3、循环原数组，原数组中数值对应新数组的下标，如果有批配，值累加1

4、循环新数据，按数组值不为0的下标来回填原数组

 

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

    //选择排序
    static void selectSort(int[] array) {
        printArray(array);

        for(int i=0; i<array.length - 1; i++) {
            int minPos = i;
            for(int j=i+1; j<array.length; j++) {
                if(array[minPos] > array[j] ) {
                    minPos = j;
                }
            }

            swap(array, i, minPos);
        }

        printArray(array);
    }

    //冒泡排序
    static void bubbleSort(int[] array) {
        printArray(array);

        for (int i=array.length-1; i>0; i--) {
            for(int j=0; j<i; j++) {
                if(array[j] > array[j+1]) {
                    swap(array, j, j+1);
                }
            }
        }

        printArray(array);
    }

    //插入排序
    static void insertSort(int[] array){
        printArray(array);

        for(int i=1; i<array.length; i++) {
            for (int j=i; j>0; j--) {
                if(array[j] < array[j-1]) {
                    swap(array, j, j-1);
                }
            }
        }

        printArray(array);
    }

    //希尔排序
    static void shellSort(int[] array) {
        printArray(array);

        for(int gap=array.length/2; gap>0; gap/=2) {
            for (int i=gap; i<array.length; i++) {
                for(int j=i; j>gap-1; j-=gap) {
                    if(array[j] < array[j-gap]) {
                        swap(array, j, j-gap);
                        printArray(array);
                    }
                }
            }
        }

        printArray(array);
    }

    //归并排序
    static void mergeSort(int[] array) {
        printArray(array);

        sortMerge(array, 0, array.length-1);

        printArray(array);
    }

    static void sortMerge(int[] array, int left, int right) {
        if(left >= right)
            return;

        int mid = (left + right) / 2;
        sortMerge(array, left, mid);
        sortMerge(array, mid+1, right);
        merge(array, left, right, mid);
    }

    static void merge(int[] array, int left, int right, int mid) {
        int[] temp = new int[right-left + 1];
        int i=left, j=mid+1, k=0;
        while (i<=mid && j<= right) {
            if(array[i] > array[j]) {
                temp[k++] = array[j++];
            } else {
                temp[k++] = array[i++];
            }
        }

        while (i <= mid) temp[k++] = array[i++];
        while (j<=right) temp[k++] = array[j++];

        int pos = 0;
        while (pos < k) {
            array[left+pos] = temp[pos++];
        }

    }

    //快速排序
    static void quickSort(int[] array) {
        printArray(array);

        sortQuick(array, 0, array.length -1);

        printArray(array);
    }

    static void sortQuick(int[] array, int left, int right) {
        if (left >= right) return;

        int i=left, j=right;
        int key = array[left];
        while (i < j) {
            while (i<j && key <= array[j]) {
                j--;
            }

            array[i] = array[j];

            while (i < j && key >= array[i]) {
                i++;
            }

            array[j] = array[i];
        }

        array[i] = key;
        sortQuick(array, left, i-1);
        sortQuick(array, i+1, right);
    }

    static void countSort(int[] array) {
        printArray(array);

        int max = array[0];
        for (int i=1; i<array.length; i++) {
            if(max < array[i]) {
                max = array[i];
            }
        }

        int[] temp = new int[max+1];
        int idx = 0;
        while (idx<= max) {
            temp[idx] = 0;
            idx++;
        }

        for (int j=0; j<array.length; j++) {
            int val = array[j];
            temp[val]++;
        }

        for (int m = 0, n=0; m < max+1; m++) {
            for(int l=0; temp[m] > 0 && l<temp[m]; l++) {
                array[n++] = m;
            }
        }
        printArray(array);
    }



    //打印数组
    static void printArray(int[] array) {
        for(int i=0; i<array.length; i++) {
            System.out.print(array[i] + ", ");
        }
        System.out.println();
    }

    //交换元素
    static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}