排序算法

package order;

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        // 生产一个数组
        int a[] = new int[90];
        for (int i = 0; i < 90; i++) {
            a[i] = i + 1;
        }
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+",");
        }
        System.out.println();
        //将这个数组变成一个无序数组
        int b[] = new int[90];
        for (int i = 0; i < 90; i++) {
            b[i] = play(a,90 - i);
        }
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i]+",");
        }
        System.out.println();
        // 测试排序函数
        int[] tempArray = new int[90];
        gnomesort(b);
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i]+",");
        }
    }
    
    
    /**
     * 1.插入排序
     * 将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。
     * @param a
     */
    public static void insertSort(int[] a){
        int i, j;// 分别为有序区和无序区指针
        for (i = 0; i < a.length-1; i++){ // 逐步扩大有序区
            j = i + 1;
            int t = a[j];// 存储待排序元素
            int k;
            for (k = i; k >= 0 && t < a[k]; k--) {
                a[k + 1] = a[k];
            }
            a[k + 1] = t;// 将元素插入
            
        }
    }
    
    /**
     * 2.冒泡排序
     * 将序列划分为无序和有序区，不断通过交换较大元素至无序区尾完成排序。
     * @param a
     */
    public static void bubbleSort(int[] a){
        int i, j;
        for (j = a.length-1; j >= 0; j--)
        {
            for (i = 0; i < j; i++)
            {
                if (a[i] > a[i + 1])// 如果发现较重元素就向后移动
                {
                    int temp = a[i];
                    a[i] = a[i + 1];
                    a[i + 1] = temp;
                }
            }
        }
    }
    
    /**
     * 3.选择排序（快速排序）
     * 将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，有序区扩大一个，循环最终完成全部排序。
     * @param a
     */
    public static void selectSort(int[] a){
        int i,j,k;//分别为有序区，无序区，无序区最小元素指针
        for (i = 0; i < a.length; i++)
        {
            k = i; // 最小元素指针
            for (j = i+1; j < a.length; j++) {
                if(a[j] < a[k]){
                    k = j;
                }
            }
            if (k != i)// 若发现最小元素，则移动到有序区
            {
                int temp = a[k];
                a[k] = a[i];
                a[i] = temp;
            }
        }
    }
    
    /**
     * 调整堆
     * @param a
     * @param i
     * @param size
     */
    private static void heapAdjust(int[] a,int i,int size)  //调整堆
    {
        int lchild=2*i;       //i的左孩子节点序号
        int rchild=2*i+1;     //i的右孩子节点序号
        int max=i;            //临时变量
        if(i<=size/2)          //如果i是叶节点就不用进行调整
        {
            if(lchild<=size&&a[lchild]>a[max])
            {
                max=lchild;
            }    
            if(rchild<=size&&a[rchild]>a[max])
            {
                max=rchild;
            }
            if(max!=i)
            {
                swap(a,i,max);
                heapAdjust(a,max,size);    //避免调整之后以max为父节点的子树不是堆
            }
        }        
    }

    /**
     * 构建堆（大顶堆）
     * @param a
     * @param size
     */
    private static void buildHeap(int[] a,int size)    //建立堆
    {
        int i;
        for(i=size/2;i>=1;i--)    //非叶节点最大序号值为size/2
        {
            heapAdjust(a,i,size);    
        }    
    }

    /**
     * 4. 堆排序
     * 堆排序时数组的下标需要从1开始，便于计算。
     * @param a
     * @param size
     */
    public static void heapSort(int[] a,int size)    //堆排序
    {
        int i;
        buildHeap(a,size);
        for(i=size;i>=1;i--)
        {
            //cout<<a[1]<<" ";
            swap(a, 1,i);           //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面
              //BuildHeap(a,i-1);        //将余下元素重新建立为大顶堆
            heapAdjust(a,1,i-1);      //重新调整堆顶节点成为大顶堆
        }
    }
    
    private static void swap(int[] a, int i, int max){
        int t = a[i];
        a[i] = a[max];
        a[max] = t;
    }
    
    
    private static int play(int[] pool, int size){
        Random r = new Random();
        int i =  r.nextInt(size);
        int t = pool[i];
        for (int j = i; j < size - 1; j++) {
            pool[j] = pool[j + 1];
        }
        pool[size - 1] = 0;
        return t;
    }
    
    /**
     * 5. 归并排序
     * 分而治之思想,先将数组分成两个子数组，将字数组排序后合并。
     * 子数组递归拆分成更小的数组，直到每个数组只有一个元素为止。
     * 然后再逐个合并成一个有序的数组
     * @param a
     * @param size
     */
    public static void mergeSort(int[] a, int[] tempArray, int left,  int right)
    {
        if (left < right)
        {
            int center = (left + right) / 2;
            mergeSort(a, tempArray, left, center);
            mergeSort(a, tempArray, center + 1,right);
            merge(a, tempArray, left, center, right);
        }
    }
    /**
     * 合并两个有序数组
     * @param a
     * @param tempArray
     * @param left
     * @param leftEnd
     * @param right
     */
    private static void merge(int[] a, int[] tempArray, int left, int leftEnd, int rightEnd) {
        int tempPos = left;
        int numElements = rightEnd - left + 1;
        int right = leftEnd + 1;
        //合并两个有序数组
        while (left <= leftEnd && right <= rightEnd){
            if(a[left] < a[right]){
                tempArray[tempPos++] = a[left++];
            }else{
                tempArray[tempPos++] = a[right++];
            }
        }
        // 合并数组剩余部分
        while (left <= leftEnd){
            tempArray[tempPos++] = a[left++];
        }
        while (right <= rightEnd){
            tempArray[tempPos++] = a[right++];
        }
        // 将临时数组复制回元数组
        for (int i = 0; i < numElements; i++, rightEnd--) {
            a[rightEnd] = tempArray[rightEnd];
        }
        
    }
    
    /**
     * 地精排序
     * 号称最简单的排序算法,只有一层循环,默认情况下前进冒泡,一旦遇到冒泡的情况发生就往回冒,直到把这个数字放好为止
     * @param ar
     */
    public static void gnomesort(int ar[]) {
        int i = 0;
        while (i < ar.length) {
            if (i == 0 || ar[i - 1] <= ar[i])
                i++;
            else {
                int tmp = ar[i];
                ar[i] = ar[i - 1];
                ar[--i] = tmp;
            }
        }
    }
}