Java数组08：经典排序算法

参考博文

冒泡排序（必须熟练）

参考博文
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

• 算法步骤
  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 每一次比较，都会产生一个最大，或者最小的数字。
  3. 下一轮则可以少一次排序。
  4. 依次循环，直到结束。

//冒泡排序
    public static double[] bubbleSort(double[] array){
        double temp;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length; i++) {
        	//内层循环，比较判断两个数，如果第一个数比第二数大，则交换它们的位置
            for (int j = 0; j < array.length-1-i; j++) {//关键
                if (array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }

冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。

    //冒泡排序
    public static double[] bubbleSort(double[] array){
        double temp;
        for (int i = 0; i < array.length; i++) {
            
            boolean flag = true;//通过flag标识位减少没有意义的比较
            
            for (int j = 0; j < array.length-1-i; j++) {//关键
                if (array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    
                    flag = false;
                }
            }
            if (flag){
                break;
            }
        }
        return array;
    }

选择排序

参考博文

• 算法步骤
  1. 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
  2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
  3. 重复第二步，直到所有元素均排序完毕。

//选择排序
    public static double[] selectionSort(double[] array){

        for (int i = 0; i < array.length; i++) {
            double min = array[i];
            int minindex = i;//记录最小值的下标
            for (int j = i; j < array.length; j++) {
                if (min>array[j]){
                    min = array[j];
                    minindex = j;
                }
            }
            array[minindex] = array[i];
            array[i] = min;
        }
        return array;
    }

插入排序

参考博文
插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

• 算法步骤
  1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
  2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

//插入排序
    public static double[] insertSort(double[] array){
        //从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
        for (int i = 1; i < array.length; i++) {
            double temp = array[i];//记录要插入的数据

            //从已经排序的序列右边的开始比较，找到比其小的数
            int j = i;
            while (j>0 && temp < array[j-1]){
                array[j]=array[j-1];
                j--;
            }
            //存在比其小的数，插入
            if(j!=i){
                array[j]=temp;
            }

        }
        return array;
    }

插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

希尔排序

参考博文
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

• 算法步骤
  1. 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1。
  2. 按增量序列个数 k，对序列进行 k 趟排序；
  3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

public static void shellSort(int[] arr) {
    int length = arr.length;
    int temp;
    for (int step = length / 2; step >= 1; step /= 2) {
        for (int i = step; i < length; i++) {
            temp = arr[i];
            int j = i - step;
            while (j >= 0 && arr[j] > temp) {
                arr[j + step] = arr[j];
                j -= step;
            }
            arr[j + step] = temp;
        }
    }
}

归并排序

参考博文

快速排序

参考博文

堆排序

参考博文

计数排序

参考博文

桶排序

参考博文

基数排序

参考博文