数据结构之排序

排序算法总结：

逐个分析排序算法：
1.插入类排序：像打扑克一样，第一张牌不用整理，从第二张开始将牌和之前的所有牌比较并插入到正确位置上。算法为：
★查找待插入元素的插入位置
★此位置之后的所有元素后移一位
★插入即可
(1)直接插入排序:
设一个监视哨r[0],用来存放待插记录，从第二个元素开始，和已经排好序的数列从后向前比较，直到找到大于待插记录停止，将比较过的数列整体后移，然后插入。
//此方法最坏时间复杂度为o(n*n),因为比较一趟，移动一趟;空间复杂度为o(1)，因为只占用了一个监视哨;此方法是稳定的

public class test1 {
 public static void main(String[] args) {
  int i, j;
  int r[] = { 0, 0, 1, 9, 5, 15, 3, -5 };// 注意，第一个0是监视哨，占位置而已
  for (i = 2; i < r.length; i++) {//不是<=，因为0号位置没有用到
   r[0] = r[i];
   if (r[i] < r[i - 1]) {//当待排元素小于前一个元素时，才比较，否则不用比较。
    for (j = i - 1; r[j] > r[0]; j--) {//注意判断条件是大于
     r[j + 1] = r[j];//后移序列
     r[j] = r[0];//插入操作
    }
   } else {
    continue;
   }}
  for (i = 1; i < r.length; i++) {
   System.out.println(r[i]);
  }}}

(2)折半插入排序
同样设一个监视哨来存放当前待排元素，设置两个指针low和high,用中间值mid来和待排元素比较
//时间复杂度：移动加比较，仍为o(n*n)，空间复杂度仍为O(1).且是稳定的。

public class test1 {
    public static void main(String[] args) {
        int i, j;
        int low, high, mid;
        int a[] = { 0, 0, -4, 25, 17, 1, -1, 5, 80 };
        for (i = 2; i < a.length; i++) {
            a[0] = a[i];
            if (a[i] < a[i - 1]) {
                low = 1;
                high = i - 1;
                while (low <= high) {
                    mid = (low + high) / 2;
                    if (a[mid] < a[0]) {
                        low = mid + 1;
                    } else {
                        high = mid - 1;
                    }}
                for (j = i - 1; j >= low; j--) {
                    a[j + 1] = a[j];
                    a[j] = a[0];
                }} else {
                continue;}}
        for (i = 1; i < a.length; i++) {
            System.out.print(a[i]);
            System.out.print("  ");
        }}}

(3)希尔排序：
2.交换类排序：对待排序的关键字两两进行比较，只要发现为逆序就进行交换，知道没有逆序的记录为止。
(1)冒泡排序：依次比较相邻两个关键字的大小，逆序则交换，最终每比较一趟，最大或者最小的数字沉到底。可以设置一个标志位flag，用来跟踪判断序列是否已完成排序。
时间复杂度：最优情况下，序列已有序，时间复杂度为o(n),最坏情况下，序列完全是乱的，则需要o(n*n)的时间复杂度。
是一种稳定的算法且空间复杂度为o(1).
//注意设置标志位a[0]，用来实现交换过程。

public class test1 {
    public static void main(String[] args) {
        int i, j;
        int a[] = {0, 46, 25, 68, 33, 33, 19, 12, 80};
        System.out.println(a.length)
        for(j=1; j < a.length-1 ;j++) {//外层循环，循环次数不变
            for(i=1; i < a.length-j; i++) {//内层循环比较然后交换，循环次数依次减少
            if(a[i] > a[i+1]) {
                a[0] = a[i];
                a[i] = a[i+1];
                a[i+1] = a[0];
            }}}
        for(i=1; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }}}

(2)快速排序:几乎是最快的排序方法，采用分治的思想。
分治思想：将原问题分解为若干个规模更小但结构和原问题相似的子问题，递归的解这些子问题，然后将这些子问题的解组合为原问题的解
快排的思想：选择一个枢轴，设置high和low.两头同步开始交替比较，关键字小于枢轴的均移到枢轴之前，关键字大于枢轴的均移到枢轴之后。

public class test2 {
    static void quicksort(int n[], int low, int high) {
        if (low < high) {
            int dp = partition(n, low, high);
            quicksort(n, low, dp - 1);
            quicksort(n, dp + 1, high);}}//递归的过程
    static int partition(int n[], int low, int high) {//一趟比较的过程
        int pivot = n[low];
        while (low < high) {
            while (low < high && n[high] >= pivot)  high--;
            if (low < high)                      n[low++] = n[high];
            while (low < high && n[low] <= pivot)    low++;
            if (low < high)                        n[high--] = n[low];
        }
        n[low] = pivot；         return low;
    }
    public static void main(String[] str) {//主函数负责初始化和显示
    int n[] = { 0, -1, 53, 1, 36, 84, 19, 93, 113, 45, 23 }; 
            quicksort(n, 1, 10);
        for (int i = 1; i < 10; i++)
            System.out.print(n[i] + " ");}}

3.选择类排序：基本思想：k初始值为i=1的值，从所有剩下的记录中按顺序寻找小于关键字的记录，找到后将其位置赋给k,比较i和k的值是否相等，不相等则交换即可。
(1)简单选择：时间复杂度为o(n*n)，空间复杂度为o(1),排序方式不稳定

public class test1 {
    static void sort(int a[]) {
        for (int i = 0; i <= a.length - 1; i++) {
            int k = i;
            for (int j = i + 1; j <= a.length - 1; j++) {
                if (a[j] < a[k])
                    k = j;}
            if (k != i) {
                int t = a[i];
                a[i] = a[k];
                a[k] = t;
            }}}
    public static void main(String[] args) {
        int a[] = { 1, -1, 3, 14, 0 };
        sort(a);
        for (int i = 0; i <= a.length - 1; i++) {
            System.out.println(a[i] + " ");
        }}}