初级排序算法总结

目录:

选择排序

选择排序的原理：

 一种最简单的排序算法是这样的：首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置（如果第一个元素就是最小元素那么它就和自己交换）。再次，在剩下的元素中找到最小的元素（其实是第二小的元素了，因为第一次已经把最小的元素找到），将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。这种方法叫选择排序，因为它在不断地选择剩余元素之中的最小者。

选择排序算法的代码：

public class Selection {
    public static void sort(int[] a) 
    {    //将a[]按升序排列
        int N = a.length;  //数组的长度
        for(int i = 0; i < N; i++)
        {  //从第一个位置开始，一次将一个数放在数组里面，最小的放在a[0],第二小的放在a[1],以此类推。
            int min = i;  //存放每次循环最小数的索引
            for(int j = i+1; j < N; j++)  //找到后面数中最小元素的索引
                if(a[j] < a[i]) min = j;
            //找到最小元素后，将最小元素和存放位置相互交换。
            int temp = a[i];
            a[i] = a[min];
            a[min] = temp;
        }
    }
}

选择排序分析：

 交换元素的代码写在内循环之外，每次交换都能排定一个元素，因此总的交换次数是N。所以算法的时间效率取决于比较次数。
 对于长度为N的数组，选择排序大约需要$N^2/2$ 次比较和 N 次比较。0到N-1的任意 i 都会进行一次比较和N-1-i次比较，因此总有N次比较和（N-1)+(N-2)+···+2+1 = N(N-1)/2 ~ $N^2/2$ 次比较。
特点：
- 运行时间和输入无关， 为了找到最小元素而扫描一遍数组并不能为下一次扫描提供什么帮助，在一个数组已经是有序的情况下，还是需要运行同样长的时间。
- 数据移动是最少的， N次交换数据和数组的大小是线性关系。

---

插入排序

插入排序的原理：

  通常人们整理桥牌的方法是一张一张的来，将每一张牌插入到其他已经有序的牌中的适当位置。在计算机的实现中，为了给要插入元素腾出新的空间，我们需要将其余所有元素在插入之前都向右移动一位，这种算法叫插入排序。
  与选择排序一样，当前索引左边的所有元素都是有序的，但是它们的最终位置是不确定的，为了给最小元素腾出空间，它们可能会被移动。当前索引达到最右端时，排序也就完成了。这里当前元素依次和前面的元素比较，若是小于前面的元素，就立即交换，如果不小于前面的元素，说明当前元素比前面的元素都要大，不需要交换。

插入排序的代码：

public class Insertion {
    public static void sort(int[] a) 
    {  //将a[]按升序排列
        int N = a.length;  //数组的长度
        for(int i = 1; i < N; i++)
        {  //一次从第二个元素开始，相当于依次抓牌，一个元素的时候其自成有序
            for(int j = i; j > 0 && a[j] > a[j-1]; j--)
            {  //a[j]>a[j-1]代表新抓的一张牌比前面一张牌大，需要交换位置即将新抓到的牌插到前面一张牌的前一个位置
                int temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    }
}

插入排序分析：

  对于随机排列长度为N且不重复的数组，平均情况下插入排序所~$N^2/4$ 次比较以及~$N^2/4$ 次交换。最坏情况下需要~$N^2/2$ 次比较和~$N^2/2$ 次交换，即全部逆序排列。最好情况需要N-1次比较和0次交换，即全部顺序序列。
 插入排序对于某些顺序混乱不多的非随机数列很有效。能够立即发现每个元素都在正确的位置上，运行时间达到线性。

插入排序的变换（不需要交换的插入排序）：

  在插入排序的每一次比较中，将较大的元素向后移动一位，为每一次循环选中的元素申请一个内存存储元素，防止元素被较大元素移动而覆盖。

代码

public static void insertSortX(Comparable[] a) {
            int n = a.length;  //数组长度
            // put smallest element in position to serve as sentinel
            //使用一遍冒泡排序将最小值放在第一个位置，防止后面的比较溢出
            int exchanges = 0;
            for (int i = n-1; i > 0; i--) {
                if (less(a[i], a[i-1])) {
                    exch(a, i, i-1);//交换数组a[]中两个元素
                    exchanges++;
                }
            }
            if (exchanges == 0) return; //如果没有发生交换，说明这是有序数组，不用再排序


            // insertion sort with half-exchanges,每一次移动所消耗时间是每一次交换时间的一半。
            for (int i = 2; i < n; i++) {
                int v = a[i]; //申请一个额外内容存放当前元素，防止被覆盖
                int j = i;
                while (v < a[j-1]) {
                    a[j] = a[j-1]; //如果当前元素比前面的元素小，则将前面的元素向后移动，以便为当前元素腾出插入的位置
                    j--;
                }
                a[j] = v; //将当前元素插入适合它顺序的位置
            }
    }

---

希尔排序

希尔排序的原理：

  对于大规模乱序问题插入排序很慢，因为它只会交换相邻的两个元素，元素只能一点点从一端移动到另一端。希尔排序为了加快速度简单的改进了插入排序，交换互不相邻的两个元素，并最终用插入排序将局部有序的数组排序。
  希尔排序的思想是使数组中间隔为h的元素是有序的。这样的数组被称为h有序数组。换句话说一个h有序数组就是h个互相独立的数组编织在一起组成的一个数组。在进行排序时，h很大，我们就能将元素移动到很远的地方去，为实现更小的h有序创造方便。

希尔排序的代码：

public class Shell {
    public static void sort(int[] a)
    {  //将a[]按升序排列
        int N = a.length;  //数组的长度
        int h = 1; //比较交换的间隔，这里是为了保证最后一遍循环希尔排序能够相邻元素之间挨个比较
        while(h < N/3) h = 3*h + 1;  //在每一遍循环都需要不断减小间隔h,使得最后一遍循环h能够刚好等于1。h = 1, 4, 13, 40, ...
        while(h >= 1)
        {
            for(int i = h; i < N; i++)
            {  //对于每一个小h数组进行排列
                for(int j = h; j > 0 && a[j] > a[j-h]; j -= h)
                {  //跟插入排序一样，只是间隔变成h
                    int temp = a[j];
                    a[j] = a[j-1];
                    a[j-1] = temp;
                }
                h = h/3; //不断减小h，当h等于1的时候，就是一般的插入排序，但是这时候数组里面乱序的比较少了，比较和交换都是线性的。
            }
        }
    }
}

希尔排序分析：

  对于增长序列h的选择，要保证h从大到小，并且能取到h = 1的值。当h>1的时候，都是在调整数组中逆序的数量，每一次交换都减少了数组中的逆序对，到最后一次插入排序，数组中存在的逆序对比较少了，当h=1时程序实际就是线性的插入排序。