排序总结

今天总结下所有排序算法

冒泡排序

public class bubble {/**冒泡排序： * （从后往前）从第一个开始交换和他相邻的元素，两两比较， * 如果右边的数比左边的大，就交换他们的位置，这样就确定了第一大的数字了 * 。。。。。依次进行得到第二大、第三大的数字。。。 * */        static void sort(int[] number){        int temp=0;        for(int i=0;i<number.length;i++){            for(int j=number.length-1;j>0;j--){                if(number[j]<number[j-1]){                    temp=number[j];                    number[j]=number[j-1];                    number[j-1]=temp;                }            }        }    }

直接插入排序

public class insert {/** * 直接插入排序： 我们打扑克牌的时候，每次抓到新的牌都插入原先排好序的牌，形成新的排好序的一副牌 *  * */    public static void sort(int[] number) {        int temp;        //由于第一个肯定是排好序的，下标从i=1开始        for(int i=1;i<number.length;i++){            temp=number[i];            int j;            for(j=i-1;j>=0;j--)                //如果number[j]比temp大，把number[j]向后移动一位，                //等到一旦temp<number[j]不满足的时候，直接跳出循环                if(temp<number[j])                    number[j+1]=number[j];                else {                    //跳出循环                    break;                }            number[j+1]=temp;        }        System.out.println("insert直接插入排序");    }}

简单选择排序

public class choose {    /**     * 简单选择排序：选出做大的数字排第一，剩余的再次选出最大的排第二。。。。依次下去     *可以比喻成抢钱，比如可以让你随意从一堆钱里面拿钱，先挑面额最大     * 的，然后依次拿面额更小一点的     *      * 和 冒泡的相似：都是依次确定第k个数字的     *      * 和 冒泡的区别：     * 冒泡： 确定第k位的时候是用相邻不断交换     * 简单选择： 确定第k位的时候是先从右边（包括第K位）选择最小的数字，最终再和第K位的数字交换     *      * */        public static void sort(int[] number) {            for (int i = 0; i < number.length - 1; i++) {                int temp = 0;                int index = i; // 用来保存最小值得索引                // 寻找第i个小的数值                for (int j = i + 1; j < number.length; j++) {                    if (number[index] > number[j]) {                        index = j;                    }                }                // 将找到的第i个小的数值放在第i个位置上                temp = number[index];                number[index] = number[i];                number[i] = temp;            }            System.out.println("choose简单选择排序");        }}

快速排序

package com.yuzhiyun;import java.util.Arrays;public class QuickSort2 {    public static void main(String[] args) {        // TODO Auto-generated method stub        int[] array={8,6,9,7,4,3};        quickSort(array, 0, array.length-1);        System.out.println(Arrays.toString(array));    }    public static void quickSort(int[] list,int l,int r) {        if(l>=r)            return;        //list[l]是基准        int temp=list[l];        int i=l;        int j=r+1;        /**         * 把小于temp的元素交换到temp左边         * 把大于temp的元素交换到temp右边         * */        while(true){            //i往右移动，j往左移动，直到list[i]>分割点，list[j]<分割点            while(list[++i]<temp && i<r);            while(list[--j]>temp);                       //System.out.println("i="+i+" j="+j);//          结束条件            if(i>=j)                break;            swap(list,i,j);           // System.out.println(Arrays.toString(list));        }        //list[l]和list[j]交换        list[l]=list[j];        list[j]=temp;        //递归        quickSort(list, l, j-1);        quickSort(list, j+1,r );    }    private static void swap(int[] array,int a,int b) {        int temp=array[a];        array[a]=array[b];        array[b]=temp;    }}

堆排序

核心思想：

堆排序是优化了的选择排序，就是先建立最大堆，然后去除堆顶元素，这样就得到了最大的元素，然后剩余的元素再次建立最大堆，再得到第二大的元素，循环往复。
参考自 http://blog.csdn.net/xuxurui007/article/details/7651018

难点：

1.用什么数据结构存储最大堆？
使用一个数组存储所有元素，比如int[] array,array[0]用0填充,更方便一点，然后我们的目的是使得数组的内容满足这样一个性质，array[k]>=array[2k] && array[k]>=array[2k+1],只要满足了这个性质，就可以说这个数组存储了一个最大堆了。
2.那么如何让一个数组array[n]满足array[k]>=array[2k] && array[k]>=array[2k+1]这个条件呢？

那就是从array[n/2]处开始， 让这个节点和它的子节点比较，把大的元素交换上来，然后是array[n/2 -1 ]，array[n/2 -2 ],最需要注意的是，很有可能某个节点和孩子节点交换之后，导致以这个孩子节点为根节点的最大堆不再是最大堆，所以需要再次深入直至叶子节点，继续交换使得这个孩子节点维持它自己的最大堆性质。

要点：

如何巧妙的去除堆顶得到最大值呢？那就是堆顶元素与堆的最后一个节点交换位置，然后再去除最后的节点，而不是直接去除堆顶，去除之后，再次建立最大堆。

package sort;public class HeapSort {    public static void main(String[] args) {        // 数组0下标元素作为暂存单元        int[] array = { 0, 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5,                4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51 };        System.out.println("排序前：");        printArray(array);        heapSort(array);        System.out.println("排序后：");        printArray(array);    }    /**     * 打印数组     * @param array     */    public static void printArray(int[] array) {        for (int i = 1; i < array.length; i++) {            System.out.print(array[i] + " ");        }        System.out.println();    }    /**     * 堆排序函数     * @param array     */    public static void heapSort(int[] array) {        // 对数组进行筛选，建成一个大顶堆        int len = array.length - 1;        for (int i = len / 2; i > 0; i--) {            heapAdjust(array, i, array.length - 1);        }        for (int i = array.length - 1; i > 1; i--) {            // 将堆顶元素与最后一个元素调换位置，即输出最大值            swap(array, 1, i);            // 将最后一位剔出，数组最大下标变为i-1。自队顶至叶子进行调整，形成一个新堆，此过程称为筛选            heapAdjust(array, 1, i - 1);        }    }    /**     * 建堆函数     * 使得以array[s]为根的二叉树满足大顶堆定义     * @param array     * @param s     * @param m     */    public static void heapAdjust(int[] array, int s, int m) {        // 用0下标元素作为暂存单元        array[0] = array[s];        // 沿孩子较大的结点向下筛选        for (int j = 2 * s; j <= m; j *= 2) {            // 保证j为较大孩子结点的下标，j < m 保证 j+1 <= m ，不越界            if (j < m && array[j] < array[j + 1]) {                j++;            }            if (!(array[0] < array[j])) {                break;            }            // 若S位较小，应将较大孩子上移            array[s] = array[j];            // 较大孩子的值变成S位的较小值，可能引起顶堆的不平衡(意思是原本该节点是大于两个孩子节点的，因为交换就不平衡了，所以需要再次往下层循环直至叶子节点)，故对其所在的堆进行筛选            s = j;        }        // 若S位较大，则值不变；否则，S位向下移动至2*s、4*s、。。。        array[s] = array[0];    }    /**     * 交换函数     * @param array     * @param i     * @param j     */    public static void swap(int[] array, int i, int j) {        int temp;        temp = array[i];        array[i] = array[j];        array[j] = temp;    }}