排序

一、冒泡排序

序列：{33, 38, 54, 18, 17, 9, 29, 62}
第一遍：第一个和第二个比，将大的放在后面。第二个和第三个比，将大的放在后面。
第二遍：同上，但相对循环次数减少一次。
特点：稳定；
38 49 65 76 13 27 49 55 4 6 97   后一位有序
38 49 65 13 27 49 55 4 6 76 97   后两位有序
38 49 13 27 49 55 4 6 65 76 97   后三位有序

protected static void maoPaoSort(int args[]) {
        for (int i = 0; i < args.length - 1; i++) {
            for (int j = 0; j < args.length - i - 1; j++) {
                if (args[j] > args[j + 1]) {
                    int temp = args[j + 1];
                    args[j + 1] = args[j];
                    args[j] = temp;
                }
            }
            for (int anA : args) {
                System.out.print(anA + " ");
            }
            System.out.println();
        }
    }

二、快速排序算法：

序列：{33, 38, 54, 18, 17, 9, 29, 62}
1.基于一个基准进行排序，一轮排序后，基准前的所有数比基准小，基准后的所有数比基准大。
2.故数列分成了两部分，剩下两部分按1所述的方法进行排序。
特点：具有分治法的思想，减少了比较的部分。不稳定。

33 38 54 18 17 9 29 62  基准为33
29 9 17 18 33 54 38 62  基准为29
18 9 17 29 33 54 38 62  基准为18
17 9 18 29 33 54 38 62
9 17 18 29 33 54 38 62
9 17 18 29 33 38 54 62

protected static void quickSort(int[] array, int low, int high) {
        int k = array[low];
        int left = low, right = high;
        while (left < right) {
            while (low < right) {
                if (array[right] < k) {
                    array[left] = array[right];
                    break;
                } else {
                    right--;
                }
            }

            while (left < right) {
                if (array[left] > k) {
                    array[right] = array[left];
                    break;
                } else {
                    left++;
                }
            }
          /*  for (int anA : array) {
                System.out.print(anA + " ");
            }
            System.out.println();*/
        }
        // 填坑
        array[left] = k;
        for (int anA : array) {
            System.out.print(anA + " ");
        }
        System.out.println();
        if (low < left - 1) {
            quickSort(array, low, left - 1);
        }
        if (left + 1 < high) {
            quickSort(array, left + 1, high);
        }
    }

三、插入排序算法

序列：{33, 38, 54, 18, 17, 9, 29, 62}
1.把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。
特点：稳定。
33 38 54 18 17 9 29 62  前2位有序
33 38 54 18 17 9 29 62   3
18 33 38 54 17 9 29 62   4
17 18 33 38 54 9 29 62   5
9 17 18 33 38 54 29 62   6
9 17 18 29 33 38 54 62   7
9 17 18 29 33 38 54 62   8

 protected static void inserSort(int[] array) {
        if (array == null || array.length < 2) {
            return;
        }
        for (int i = 1; i < array.length; i++) {
            for (int j = i; j > 0; j--) {
                if (array[j] < array[j - 1]) {
                    int temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                } else {
                    break;
                }
            }
            for (int anA : array) {
                System.out.print(anA + " ");
            }
            System.out.println();
        }
    }

四、归并排序

归并排序是使用归并的思想将两个有序的数据归并成一个数组，分而治之。
特点：分治法，稳定；

protected static int[] mergeSort(int args[], int low, int high) {
       if (low == high) {
           return new int[]{args[low]};
       }
       int mid = (low + high) / 2;
       int[] leftArray = mergeSort(args, low, mid);
       int[] rightArray = mergeSort(args, mid + 1, high);
       return mergeSort(leftArray, rightArray);
   }

   private static int[] mergeSort(int[] leftArray, int[] rightArray) {
       int left = 0, right = 0, x = 0;
       int[] arrays = new int[leftArray.length + rightArray.length];
       for (; x < arrays.length; x++) {
           if (leftArray[left] < rightArray[right]) {
               arrays[x] = leftArray[left];
               left++;
               if (left == leftArray.length) {
                   break;
               }
           } else {
               arrays[x] = rightArray[right];
               right++;
               if (right == rightArray.length) {
                   break;
               }
           }
       }
       while (left < leftArray.length) {
           arrays[++x] = leftArray[left++];

       }
       while (right < rightArray.length) {
           arrays[++x] = rightArray[right++];
       }
       for (int anA : arrays) {
           System.out.print(anA + " ");
       }
       System.out.println();
       return arrays;
   }

五、希尔排序

{49,38,65,97,76,13,27,49,55,4,6}
将序列通过缩小增量法进行排序。
假设一个数量为n的数组，通过把数组分成n/2;n/4,n/8…份，分别进行插入排序。
特点：不稳定。

13 27 49 55 4 6 38 65 97 76 49  d = length/2，   0+i位 与 i+d位比较结果
4 6 13 27 38 55 49 65 97 76 49  d = lenght/2/2
4 6 13 27 38 49 49 55 65 76 97  d = lenght/2/2 = 1;

六、时间复杂度和空间复杂度