数组的排序方式（冒泡，选择，直接插入，希尔）

1.冒泡排序

思想：

n个数据，进行n-1趟排序。
如下例进行分析：

4，12，5，11，9

• 第一趟排序：4和12比较，有序，则不改变顺序（4，12，5，11，9），12和5比较，交换（4，5，12，11，9），12和11比较，交换（4，5，11，12，9），12和9比较，交换（4，5，11，9，12）。
  第一趟排序结束可以看出，最大的数被排到最后一个位置。
• 第二趟排序：4和5比较，有序，5和11比较，有序，11和9比较，交换（4，5，9，11，12），因为第一趟已经将整个数组中的最大数排到了最后一位，所以本次只需要排到倒数第二位。

 public static void bubbleSort(int[] arr) {
        boolean swap = false;
        for (int i = 0; i < arr.length - 1; i++) { //控制趟数
            for (int j = 0; j < arr.length - 1 - i; j++) {  // j的值也在改变
                while (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                    swap = true;
                }
            }
            if (!swap) {
              return;
            }
            }
        }     
    public static void main(String[] args) {
        int[] arr = {4,12,5,11,9};
        System.out.println(Arrays.toString(arr));
         bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

执行结果：

2.选择排序

思想：

从当前待排序序列的后面找到比当前待排序序列小的数字，进行交换

如下例进行分析：

1，12，3，6，4，7

• for循环定义两个变量i和j，i为第一个数的下标0，j的值为i+1，将第i个数和第j个数进行比较，i值大于j值时，进行交换，j++到数组遍历完毕。然后i再从第二个数开始和j的值进行比较。直到整个数组中的元素有序则结束循环。
• 第一次：1，12，3，6，4，7
• 第二次：1（最小），12，3，6，4，7→1，3，12，6，4，7
• 第三次：1，3（前两个数已有序），12，6，4，7→1，3，6，12，4，7→1，3，4，12，6，7
• 第四次：1，3，4（前三个数已经有序），12，6，7→1，3，4，6，12，7
• 第五次：1，3，4，6（前四个数已有序），12，7→1，3，4，6，7，12
  结束循环

import java.util.Arrays;
public class SelectSort {

    public static void selectSort(int[] array) {
        int tmp = 0;
        for (int i = 0; i < array.length ; i++) {
           for (int j = i+1 ; j < array.length;j++) {
               if (array[i] > array[j]) {
                   tmp = array[i];
                   array[i] = array[j];
                   array[j] = tmp;
                }
               }
           }
        }
    public static void main(String[] args) {
         int[] array = {1,12,3,6,4,7};
         System.out.println(Arrays.toString(array));
         selectSort(array);
          System.out.println(Arrays.toString(array));
    }
}

执行结果：

3.直接插入排序

思想：

用for循环，默认第一个数字是有序的，从第二个下标[i]的数据开始，把此数据放入tmp，与第一个下标[j]的数据比较,如果比第一个数小，则交换

如下例进行分析：

4，5，1，6，3

• 4，5，1，6，3→（4，5有序）4，5，1，6，3→（5和1比较，交换）4，1，5，6，3→（4和1比较，交换）1，4，5，6，3→（6和之前的数比较，有序）1，4，5，6，3→（3和6比较，交换）1，4，5，3，6→（3和5比较，交换）1，4，3，5，6→（3和4比较，交换）1，3，4，5，6（有序，结束循环）

import java.util.Arrays;
public class InsertSort {
    public static void insert(int[] array) {
        int tmp = 0;
        for (int i = 1; i < array.length; i++) {
            tmp = array[i];
            int j=0;
            for (j = i - 1; j >= 0; j--) {
                if (array[j] > tmp) {
                    array[j + 1] = array[j];
                } else {
                    break;
                }
            }array[j + 1] = tmp;
        }
    }
    public static void main(String[] args) {
         int[] array = {4,5,1,6,3};
        System.out.println(Arrays.toString(array));
         insert(array);
        System.out.println(Arrays.toString(array));
    }
}

执行结果：

4.希尔（shell）排序

思想：

采用分组的思想，组进行有序的插入排序

如下例进行分析：

12,5,9,34,6,8,33,56,89,0,7,4,22,55,77

• 先将待排序数组分成五组:12,8,7——5,33,4——9,56,22——34,89,55——6,0,77,组进行排序：7,4,9——34,0,8——5,22,55——6,12,33——56,89,77
  
• 再将待排序数组分成三组：7,4,9——34,0,8——5,22,55——6,12,33——56,89,77,组进行排列：5,0,8——6,4,9——7,12,33——34,22,55——56,89,77,==从这组的数据就能看出来，基本上大数字都排到了后面。
  
• 最后整体排列：5,0,8,6,4,9,7,12,33,34,22,55,56,89,77→0,4,5,6,7,8,9,12,22,33,34,55,56,77,89
  结束循环

import java.util.Arrays;

 
public class ShellSort {

    public static void shellSort(int[] array) {
   int drr[] = {5,3,1};   //分的组数，组数必须都为素数。5组3组1组都为素数
        for (int i = 0; i < drr.length; i++) {
            shell(array,drr[i]);
            }
    }
    public static void shell(int[] array,int gap) {
        int tmp = 0;
        for (int i = gap; i < array.length; i++) {
            tmp = array[i];
            int k = 0;
            for (k = i - gap; k >= 0; k -= gap) {
                if (array[k] > tmp) {
                    array[k + gap] = array[k];
                } else {
                    break;
                }
            }
            array[k + gap] = tmp;
        }
    }

    public static void main(String[] args) {
        int[] array = {12,5,9,34,6,8,33,56,89,0,7,4,22,55,77};
        System.out.println(Arrays.toString(array));
        shellSort(array);
        System.out.println(Arrays.toString(array));
    }
}

执行结果：

*常用的排序总结：

• 时间复杂度：就是函数（指数学中的函数），具体执行的操作次数。通常用渐进表达式O()来表示
• 空间复杂度：对象的个数，占用的空间。

总结：

每种排序方式都有它存在的意义，而且有时候也很容易混淆，所以搞清楚每个排序的思想很重要。