基本排序算法

　　该部分是对算法（四）简单排序的总结。

算法1、简单选择排序

基本思想：

　　是一种最简单的排序算法，首先，找到数组中最小的那个元素，然后，将它和数组中的第一个元素交换位置。再次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。

算法特点：

1. 对于长度为N的数组，选择排序需要大约N²/2次比较和N次交换。
2. 运行时间和输入无关，这也导致了无论输入的数据是有序还是无序，执行的时间将是一样长。　　　
3. 数据移动是最少的。
4. 时间复杂度O(N²),空间复杂度O(1),不稳定。如：（5，4，5，2）排序后两个5的相对位置发生的变化。

package basic.sort;
/**
 * 选择排序
 * 
 * Created by Evan on 2016-8-18.
 */
public class SelectionSort {
    public static void selectSort(int[] a) {
        int i;
        int j;
        int temp = 0;
        int flag = 0;
        int n = a.length;
        for (i = 0; i < n; i++) {
            temp = a[i];
            flag = i;
            for (j = i + 1; j < n; j++) {
                if (a[j] < temp) {
                    temp = a[j];
                    flag = j;
                }
                
            }
            System.out.println(j);
            if (flag != i) {
                a[flag] = a[i];
                a[i] = temp;
            }
        }

    }
    public static void main(String[] args) {
        int i = 0;
        int a[] = {5,4,7,8,9,9,10,2,3,1};
        selectSort(a);
        for(i = 0; i< a.length;i++){
            System.out.print(a[i] + " ");
        }
    }
}

算法2、插入排序

基本思想：

将每一张牌插入到其他已经有序的牌中的适当位置。将其余元素在插入前都向右移动一位。

算法特点：

　　平均插入排序需要N²/4比较和N²/4交换，最坏情况下N²/2比较和N²/2交换，最好情况下需要N-1次比较和0次交换。适合对部分有序的数组排序。

　　时间复杂度最好为O(N),平均和最坏为O(N²),空间复杂度为O(1),稳定排序

package basic.sort;

import java.util.Arrays;

/**
 * 插入排序
 * 
 * Created by Evan on 2016-8-18.
 */
public class InsertSort {
    public static void insertSort(int[] a) {
        if (a != null) {
            for (int i = 1; i < a.length; i++) {
                int temp = a[i];
                int j = i;
                
                    while (j >= 1&&a[j - 1] > temp) {
                        a[j] = a[j - 1];
                        j--;
                    }
                
                a[j] = temp;
            }
        }
    }
    public static void main(String []args){
        int a[] = {5,4,7,8,9,10,9,2,3,1};
        insertSort(a);
        System.out.println(Arrays.toString(a));
    }
}

两者比较：对于随机排序的无重复主键的数组，插入排序和选择排序的运行时间是平方级别的，两者之比应该是一个较小的常数。

算法3、希尔排序

基本思想：

　　使数组中任意间隔为h的元素都是有序的。

算法特点：

　　在插入排序的基础上，将移动元素的距离有1改为h，希尔排序高效的原因是它权衡了子数组的规模和有序性。排序之初，各个子数组都很短，排序之后，子数组都是部分有序的。子数组部分有序的程度取决于递增序列的选择。时间复杂度达不到平方级。空间复杂度为O(1),不稳定。

package basic.sort;

import java.util.Arrays;
/**
 * 希尔排序
 * 按升序排列
 * Created by Evan on 2016-8-18.
 */
public class ShellSort {
    public static void sort(int a[]){
        int N = a.length;
        int h = 1;
        while(h < N/3)
            h = h * 3 + 1; //1，4，13，40，121，....
        while(h >= 1){
            for(int i = h; i < N; i++){
                //将a[i]插入到a[i-h],a[i-2*h],a[i-3*h].....之中
                for(int j = i;j >= h && a[j] < a[j - h]; j -= h){
                    int temp = a[j];
                    a[j] = a[j - h];
                    a[j - h] = temp;
                }
            }
            h = h / 3;
        }
    }
    public static void main(String []args) {
        int[] nums = {2, 7, 8, 3, 1, 6, 9, 4, 5, 4};  
            ShellSort.sort(nums);  
            System.out.println(Arrays.toString(nums));  
    }
}

算法4、归并排序

基本思想：

　　先递归的将它分成两半分别排序，然后将结果归并起来。

算法特点：

　　时间复杂度最好、最坏和平均复杂度为O(nlogn)，空间复杂度为O(n)，稳定排序。没有任何基于比较的算法能够保证使用少于lg(N!) ~ NlgN次比较将长度为N的数组排序。

package basic.sort;
/**
 * 归并排序
 * 
 * Created by Evan on 2016-8-19.
 */
public class MergeSort {
    public static void Merge(int nums[], int low, int mid, int high) {
        int[] temp = new int[high - low + 1];  
        int i = low;// 左指针  
        int j = mid + 1;// 右指针  
        int k = 0;  
  
        // 把较小的数先移到新数组中  
        while (i <= mid && j <= high) {  
            if (nums[i] < nums[j]) {  
                temp[k++] = nums[i++];  
            } else {  
                temp[k++] = nums[j++];  
            }  
        }  
  
        // 把左边剩余的数移入数组  
        while (i <= mid) {  
            temp[k++] = nums[i++];  
        }  
  
        // 把右边边剩余的数移入数组  
        while (j <= high) {  
            temp[k++] = nums[j++];  
        }  
  
        // 把新数组中的数覆盖nums数组  
        for (int k2 = 0; k2 < temp.length; k2++) {  
            nums[k2 + low] = temp[k2];  
        }  
    }

    public static void MergeSort1(int a[], int l, int r) {
        if (l < r) {
            int mid = (l + r) / 2;
            MergeSort1(a, l, mid);
            MergeSort1(a, mid + 1, r);
            Merge(a, l, mid, r);
        }
    }

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

算法5、快速排序

基本思想：

　　将一个数组分层两个子数组，将两部分独立地排序，快速排序和归并排序是互补的：归并排序将数组分层两个子数组分别排序，并将有序的子数组归并以将整个数组排序。而快速排序将数组排序的方式则是当两个子数组都有序时整个数组也就自然有序了。

算法特点：

　　时间复杂度平均和最好为O(nlogn)，最坏为O(N²),空间复杂度为O(1),不稳定排序。

package basic.sort;
/**
 * 快速排序
 */
import java.util.Arrays;

public class QuickSort {
    public static int[] sort(int[] nums, int low, int high) {  
        if (low < high) {  
            int mid = partition(nums, low, high);  
            //左边  
            sort(nums, low, mid - 1);  
            //右边  
            sort(nums, mid + 1, high);  
        }  
        return nums;  
    }  
  
    public static int partition(int[] nums, int low, int high) {  
        int key = nums[low];//基准数  
        int i = low;//左指针  
        int j = high;//右指针  
  
        if (low < high) {  
            while (i < j) {  
                //形象点可以理解为,右指针左移  
                while (i < j && nums[j] >= key) {  
                    j--;  
                }  
  
                if (i < j) {  
                    nums[i] = nums[j];  
                    i++;  
                }  
  
                //形象点可以理解为,左指针右移  
                while (i < j && nums[i] <= key) {  
                    i++;  
                }  
  
                if (i < j) {  
                    nums[j] = nums[i];  
                    j--;  
                }  
            }  
  
            //把key填入最后的位置,即基准数位  
            nums[i] = key;  
        }  
        return i;  
    }  
  
    public static void main(String[] args) {  
        int[] nums = {2, 7, 8, 3, 1, 6, 9, 0, 5, 4};  
  
        QuickSort.sort(nums, 0, nums.length - 1);  
        System.out.println(Arrays.toString(nums));  
    }  
}

算法6、堆排序

基本思想：

　　通过建堆和调整堆的方式，将数组排序。

算法特点:

　　时间复杂度最好，平均和最坏都是O(nlogn)，空间复杂度为O(1)不稳定。

package basic.sort;

import java.util.Arrays;
/**
 * 堆排序
 * 降序
 * 
 * Created by Evan on 2016-8-19.
 */
public class HeapSort {

    public static void MinHeapFixdown(int a[], int i, int n) {
        int j, temp;

        temp = a[i];
        j = 2 * i + 1;
        while (j < n) {
            if (j + 1 < n && a[j + 1] < a[j]) // 在左右孩子中找最小的
                j++;

            if (a[j] >= temp)
                break;

            a[i] = a[j]; // 把较小的子结点往上移动,替换它的父结点
            i = j;
            j = 2 * i + 1;
        }
        a[i] = temp;
    }

    public static void MinheapsortTodescendarray(int a[], int n) {
        for(int i = a.length / 2 - 1; i>= 0; i--){
            MinHeapFixdown(a,i,a.length);
        }
        for (int i = n - 1; i >= 1; i--) {
            int temp = a[0];
            a[0] = a[i];
            a[i] = temp;
            MinHeapFixdown(a, 0, i);
        }
    }

    public static void main(String[] args) {
        int[] nums = { 2, 7, 8, 3, 1, 6, 9, 4, 5, 4 };
        
        HeapSort.MinheapsortTodescendarray(nums, nums.length);
        System.out.println(Arrays.toString(nums));
    }
}

算法7、冒泡排序

基本思想：

　　两两比较，将较小的向上调整，较大的向下交换，较小的数就好比气泡一样向上浮动。

算法特点：

　　时间复杂度最好为O(n),平均和最坏为O(N²)，空间复杂度O(1)，稳定排序。

package basic.sort;

import java.util.Arrays;
/**
 * 冒泡排序
 * 这里提供两个版本，本质是一样的，注释部分是每次将未排序中最大的数排到最终位置；
 * 第二种，是将未排序中最小的数排到最终位置。
 * Created by Evan on 2016-8-18.
 */
public class BubbleSort {
    public static void bubbleSort(int[] a) {
        int i;
        int j;
        int len = a.length;
        int temp;
        /*for (i = 0; i < len; i++) {
            for (j = 0; j + 1 < len - i; j++) {
                if (a[j + 1] < a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
            //System.out.println(i+1 + ": "+Arrays.toString(a));
        }*/
        for (i = 0; i < len; i++) {
            for (j = len - 1; j > i; j--) {
                if (a[j - 1] > a[j]) {
                    temp = a[j];
                    a[j] = a[j - 1];
                    a[j - 1] = temp;
                }
            }
            //System.out.println(i+1 + ": "+Arrays.toString(a));
        }
    }

    public static void main(String[] args) {
        int a[] = { 5, 4, 7, 8, 9, 5, 9, 2, 3, 1 };
        bubbleSort(a);
        System.out.println(Arrays.toString(a));
    }
}