Java 数据结构（一）---排序（二） 交换排序

上一篇：Java 数据结构（一）—排序（一） 插入排序

一、选择排序

基本思想：两两比较待排序记录的关键字。当发现两个记录的次序相反时候进行交换，直至没有反序存在为止。

二、冒泡泡排序

比较两个数大小，顺序不对的话，就交换两个数，然后循环到下一个比较对象，每次排列 都把最大或者最小的放到当前队尾，直至最后两个数比较的完成。

这是一个比较简单的排序算法，就是反复交换，找到最值的那个放在末尾。但是它的运行时间，时间复杂度是O（N^2）;

    public void bubbleSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - i-1; j++) {
                if (array[j] > array[j + 1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
        }
    }

三、快速排序 —这是一个效率较高的内排序法

该方法的基本思想是：
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。
时间复杂度：O(N*logN)。
根据基本思想，很容易设计出下面的计算方法。

    /**
     * 数据结构与算法分析-java语言 第198页给的案例 
     *  简单的递归排序法
     * 
     * @param items
     */
    public void QuickSort(List<Integer> items) {
        //递归直至最大最小 都为一
        if (items.size() > 1) {
            List<Integer> smaller = new ArrayList<Integer>();
            List<Integer> same = new ArrayList<Integer>();
            List<Integer> larger = new ArrayList<Integer>();

            //折半选择关键字，枢纽元
            Integer chosenItem = items.get(items.size() / 2);
            //数组分组，大于 小于 等于 三组
            for (Integer i : items) {
                if (i < chosenItem)
                    smaller.add(i);
                else if (i < chosenItem)
                    smaller.add(i);
                else
                    same.add(i);
            }
            //然后递归 小于和大于组的元素
            QuickSort(smaller);
            QuickSort(larger);
            //清除原始数据
            items.clear();
            //获取排序后的数据，三个顺序 不能变
            items.addAll(smaller);
            items.addAll(same);
            items.addAll(larger);
        }
    }

对于枢纽元的选择，是个很复杂的问题，如果选择第一个，遇到逆序或者预排序的数，将会产生劣质的分割；使用随机数作为枢纽元，随机数会产生很大的开销，执行效率优化不大；
数中值分割法，这很难算出并且会明显减慢快速排序的速度。

    /**
     * 分组，按照大于等于基数和小于基数分组
     * 
     * @param array
     * @param low
     * @param high
     * @return
     */
    public int QkSort(int[] array, int low, int high) {

        // 先把第一位数存个副本，第一个位置挖个坑
        int temp = array[low];

        int privotkey = array[low];

        // 循环 直至左右相等
        while (low < high) {
            // 从高位向低位寻找到 小于基数得数 如果出现
            while (low < high && array[high] >= privotkey)
                high--;

            // 是否还在循环里面。在的话，把高位数传给低位。high位即为挖坑位置
            if (low < high) {
                array[low] = array[high];
                low++;
            }

            // 从低位向高为寻找 大于基数的数
            while (low < high && array[low] < privotkey)
                low++;

            // 把低位的数传给高位，在上面挖了坑的位置，low位即为挖坑位置
            if (low < high) {
                array[high] = array[low];
                high--;
            }

        }
        //把最后的坑，用保存的副本 即为基数保存进low位置
        array[low] = temp;
        return low;
    }
//分治法
    public void QkSort1(int[] array, int low, int high) {
        if (low < high) {
            int poi = QkSort(array, low, high);
            QkSort1(array, low, low - 1);
            QkSort1(array, low + 1, high);
        }
    }

代码的优化：

//快速排序  
/**
这段优化代码来自： http://blog.csdn.net/morewindows/article/details/6684558
我反复优化了好几次都出现了错。
*/
void 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)  
        {  
            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数  
                j--;    
            if(i < j)   
                s[i++] = s[j];  

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

public class QuickSort {
    public int[] quickSort(int[] A, int n) {
        quicksort(A,0,n-1);
        return A;
    }

    public void quicksort(int[] a,int left,int right){
        if(left>=right)
            return;
        int tmp =a[left];
        int i=left;
        int j=right;
        while(i<j){
            //从后找到第一个小于基准数的数
            while(a[j]> tmp && i<j)
                j--;
            //移到左侧空出的位置
            if(i<j){
                a[i]=a[j];
                i++;
            }
            //从前找，找到第一个大于基准数的数
             while(a[i]< tmp && i<j) 
                 i++;
            if(i<j){
                a[j]=a[i];
                j--;
            }
            //移到右侧空出的位置

        }
        //把基准数放到空缺位置
        a[i]=tmp;
        quicksort(a,left,i-1);
        quicksort(a,i+1,right);
    }



}

参考：
快速排序（Quicksort）的Javascript实现
白话经典算法系列之六 快速排序 快速搞定