排序

排序

一、选择排序

---

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

• 请参考下面的例子

package com.calculation;

public class Example {

    public static void sort(Comparable[] a){}


    /**
     * 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
     * 如果v < w 返回true
     * 否则返回false
     * @param v
     * @param w
     * @return
     */
    public static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    /**
     * 交换数组中两个值
     * @param a 数组对象
     * @param i 数组下标
     * @param j 数组下标
     */
    public static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    /**
     * 在单行中打印数组
     * @param a
     */
    public static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++)
           System.out.print(a[i]+",");
        System.out.println();
    }

    /**
     * 测试数组元素是否有序
     * 循环遍历 升序
     * @param a
     * @return
     */
    public static boolean isSortedEsc(Comparable[] a){
        for( int i = 1, j = a.length; i < j; i++)
            if (less(a[i], a[i - 1])){
                return false;
            }
        return true;
    }

    /**
     * 测试数组元素是否有序
     * 循环遍历 降序
     *
     * @param a
     * @return
     */
    public static boolean isSortedDesc(Comparable[] a) {
        for (int i = 1, j = a.length; i < j; i++)
            if (less(a[i], a[i - 1])) {
                return true;
            }
        return false;
    }

}

• 选择排序算法实现

public class Sort{

    /**
     * 选择排序
     * 首先，找到数组中最小的那个元素，其次，将它和数组的第
     * 一个元素交换位置（如果第一个元素就是最小元素那么它就和自己交换）。 再次，在剩下的元素中
     * 找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。这种方法
     * 叫做选择排序，因为它在不断地选择剩余元素之中的最小者。
     * @param a
     */
    public static void selectSort(Comparable[] a){
        int size = a.length;
        for(int i = 0; i < size; i++){
            int min = i;
            for(int j = i+1; j < size; j++){
                if(less(a[j], a[min])){ // 假如 a[j] < a[min]
                    min = j;
                }
            }
            exch(a, i, min); // 交换a[i]和a[min]的值
        }
    }



}

• 选择排序算法时间复杂度为

n*(n-1)+(n-1)*(n-2)+...

T(n)=O(n^2)

---

二、插入排序

• 定义
  为了给要插入的元素腾出空间，我们需要将其余所有元素在插入之前都向右移动一位。 这种算法叫做插入排序。 与选择排序一样，当前索引左边的所有元素都是有序的，但它们的最终位置还不确定，为了给更小的元素腾出空间，它们可能会被移动。 但是当索引到达数组的右端时， 数组排序就完成了。和选择排序不同的是，插入排序所需的时间取决于输入中元素的初始顺序。 例如，对一个很大且其中的元素已经有序（或接近有序） 的数组进行排序将会比对随机顺序的数组或是逆序数组进行排序要快得多。

/**
     * 插入排序
     * 在计算机的实现中， 为了给要插入的元素腾出空间,我们需要将其余所有元素在插入之前都向右移动一位。 这种算法叫做插入排序
     * @param a
     */
    public static void insertSort(Comparable[] a){
        int size = a.length;
        for (int i = 1; i < size; i++){
            for(int j = i; j > 0 && less(a[j], a[j-1]); j--){
                exch(a, j, j-1);
            }
        }
    }