一天一个Java基础——排序

插入排序

---

直接插入排序：

　　　　当插入第i个数据元素k时，由前i-1个数据元素组成已排序的数据序列，将k与数据序列中各数据元素依次进行比较后，插入到数据序列的适当位置，使得插入后的数据序列仍是排序的。

　　　　直接插入排序算法是稳定的，时间复杂度为O(n^2)。

 /*
  * 插入排序
  *     1.外层循环（循环控制变量i）的迭代是为了获取已排好序的子数列
  *     2.内层循环（循环控制变量k）将list[i]插入到从list[0]到list[i-1]的子数列中
  */
 public static void insertionSort(int[] array) {
     for (int i = 1; i < array.length; i++) {
         int minValue = array[i];
         int k;
         for (k = i - 1;k >= 0 && minValue < array[k]; k--) {
             array[k + 1] = array[k];
         }
         array[k + 1] = minValue;
     }
 }

希尔排序：

　　　　排序之初，允许数据元素做较大的移动，而当数据元素接近目的地时，再做较小的移动。这样做可使排序过程加快。希尔排序的算法思想非常简单，但如何选择增量以产生最好的排序效果，至今仍没定论。

　　　　希尔排序算法是不稳定的，所需的时间取决于每次排序时增量的个数和增量的取值，若增量的取值比较合理，希尔排序算法的时间复杂度约为O(n(log_2n)^2)。

交换排序

---

冒泡排序：

　　　　将相邻的两个数据元素按关键字进行比较，如果反序，则交换。对于一个待排序的数据序列，经一趟排序后，最大值数据元素移到最后位置，其它值较大的数据元素也向最终位置移动，此过程称为一趟起泡。

　　　　冒泡排序算法是稳定的，时间复杂度为O(n^2)。

快速排序：

　　　　快速排序是目前平均性能较好的一种排序算法。

　　　　在待排序的数据序列中任意选择一个值作为基准值，由序列的两端交替地向中间进行比较、交换，使得所有比基准值晓得元素都处于序列的左端，比基准值大的元素都处于序列的右端，这样序列就被划分成两个子序列。再对两个子序列分别进行同样的操作，直到子序列的长度为1时，则已排好序。每趟排序完，作为基准值的数据元素需要找到它在排好序的序列中的最终位置。

选择排序：

　　设待排序的数据序列有n个元素，第1趟排序，比较n个元素，选择关键字最小的元素，将其交换到序列的第1个位置上；第2趟排序，在余下的n-1个元素中，再选取关键字最小的元素，交换到序列的第2个位置上.....经过n-1趟排序，n个元素的数据序列则按递增次序排序完成。

　　直接选择排序算法是不稳定的

 /*
  * 选择排序
  *     1.选择排序法先找到数列中最小的数
  *     2.然后将它放在数列的最前面
  *     3.在剩下的数中，循环1、2操作
  */
 public static void selectionSort(int[] array) {
     for (int i = 0; i < array.length - 1; i++) {
         int minValue = array[i];
         int minIndex = i;
         for (int j = i + 1;j < array.length;j++) {
             if (array[j] < minValue) {
                 minValue = array[j];
                 minIndex = j;
             }
         }
         if (minIndex != i) {
             array[minIndex] = array[i];
             array[i] = minValue;
         }
     }
 }

归并排序： 

　　归并排序算法可以递归地描述为：算法将数组分为两半，对每部分递归地应用归并排序。在两部分都排好序后，对它们进行归并。

　　递归调用持续将数组划分为子数组，直到每个子数组只包含一个元素。然后，该算法将这些小的子数组归并为稍大的有序子数组，直到最后形成一个有序的数组。

 /**
  * @author zhengbinMac
  */
 public class mergeSort {

     public static void main(String[] args) {
         int[] list = {2, 3, 2, 5, 6, 1, -2, 3, 14, 12};
         mergeSort(list);
         for (int i = 0; i < list.length; i++) {
             System.out.print(list[i]+" ");
         }
     }

     public static void mergeSort(int[] list) {
         if(list.length > 1) {
             // 拆分过程
             // 第一半儿
             int[] firstHalf = new int[list.length / 2];
             System.arraycopy(list, 0, firstHalf, 0, list.length / 2);
             // 将这一半儿再拆成两半儿
             mergeSort(firstHalf);

             // 第二半儿
             int secondHalfLength = list.length - list.length / 2;
             int[] secondHalf = new int[secondHalfLength];
             System.arraycopy(list, list.length / 2, secondHalf, 0, secondHalfLength);
             // 将这一半儿再拆成两半儿
             mergeSort(secondHalf);

             // 将两半儿数组归并成一个新的有序数组temp
             int[] temp = merge(firstHalf, secondHalf);
             // 将temp赋给原始数组list
             System.arraycopy(temp, 0, list, 0, temp.length);
         }
     }

     private static int[] merge(int[] list1, int[] list2) {
         // 将拆分出来的两个数组归并为排好序的一个数组
         int[] temp = new int[list1.length + list2.length];
         int current1 = 0; // 指向list1当前考虑的元素
         int current2 = 0; // 指向list2当前考虑的元素
         int current3 = 0; // 指向temp当前考虑的元素

         while(current1 < list1.length && current2 < list2.length) {
             if(list1[current1] < list2[current2]) {
                 // 如果较小的元素在list1中，current1增加1
                 temp[current3++] = list1[current1++];
             }else {
                 // 如果较小的元素在list2中，current2增加1
                 temp[current3++] = list2[current2++];
             }
         }
         // 如果list1和list2中仍有未移动的元素，就将它们复制到temp中
         while(current1 < list1.length) {
             temp[current3++] = list1[current1++];
         }
         while(current2 < list2.length) {
             temp[current3++] = list2[current2++];
         }
         // 将temp作为一个新的有序数组返回
         return temp;
     }
 }

 package One;

 public class Test_sort {

     public static void main(String[] args) {
         int[] a = { 2, 9, 5, 4, 8, 1 };
         // sort(bubble_sort);
         quick_sort(a, 0, a.length - 1);
         for (int i = 0; i < a.length; i++) {
             System.out.print(a[i] + " ");
         }
     }

     // 冒泡排序
     public static int[] bubble_sort(int[] a) {
         // 设置判断，进行优化
         // 如果某次遍历中没有发生交换，那么就不用再进行下去，因为排序已完成
         boolean ac = true;
         for (int k = 1; k < a.length & ac; k++) {
             ac = false;
             for (int i = 0; i < a.length - 1; i++) {
                 if (a[i] > a[i + 1]) {
                     int temp = a[i];
                     a[i] = a[i + 1];
                     a[i + 1] = temp;
                     ac = true;
                 }
             }
         }
         return a;
     }

     // 快速排序
     public static int[] quick_sort(int s[], int l, int r) {
         if (l < r) {
             // Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
             int i = l, j = r, x = s[l];
             while (i < j) {
                 // 从右向左找第一个小于x的数
                 while (i < j && s[j] >= x)
                     j--;
                 if (i < j)
                     s[i++] = s[j];

                 // 从左向右找第一个大于等于x的数
                 while (i < j && s[i] < x)
                     i++;
                 if (i < j)
                     s[j--] = s[i];
             }
             s[i] = x;
             quick_sort(s, l, i - 1); // 递归调用 从右至左
             quick_sort(s, i + 1, r); // 从左至右
         }
         return s;
     }
 }