排序总结

今天总结下所有排序算法

冒泡排序

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[head]为根的左右子树是最大堆的前提下把以array[head]为根的树调整为最大堆
     * @param array
     * @param head
     * @param tail
     */
    static void adjustHeap(int[] array,int head,int tail){
        int root=array[head];
        int i=2*head;
        while(i<=tail){
            int max=array[i];
            if(i+1<=tail)
                if(array[i+1]>array[i]){
                    max=array[i+1];
                    i++;
                }
            if(root>max)
                //别手抖写成了return;
                break;
            else{
                array[i/2]=array[i];        
            }
            i*=2;
        }
        array[i/2]=root;
    }

    /**
     * 交换函数
     * @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;
    }
}