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实现
白话经典算法系列之六 快速排序 快速搞定