JAVA中的排序

public static void main(String[] args){
    SortUtil sortUtil=new SortUtil();
    //sortUtil.insertSort(datas);
    sortUtil.shellSort(datas);
    //sortUtil.bubbleSort(datas);
    //sortUtil.quickSort(datas);

    //sortUtil.selectSort(datas);
    sortUtil.heapSort(datas);
}

static int[] datas={23,67,87,54,99,9,34,45,66,88,14,8,37,23};

public void print(int[] table){
    for (int i:table) {
        System.out.print(i+",");
    }
    System.out.println("");
}



/**
 * 插入排序
 * @param table
 * 原理：
 * 从第二个元素开始，依次忘前面的集合中插入（循环比较前一个）；
 * 两次循环，第一次大循环是，是n-1次扫描
 * 第二次循环是在插入集合中比较(从后往前)
 */
public void insertSort(int[] table){
    //从第二个元素开始
    for (int i = 1; i < table.length; i++) {   //n-1趟扫描
        int key=table[i];
        int j;
        for (j=i-1; j>=0&&key<table[j]; j--) {
            table[j+1]=table[j];
        }
        table[j+1]=key;
        System.out.println("插入排序：第"+i+"趟:");
        print(table);
    }
}

/**
 * 希尔排序(不稳定)
 * @param table
 */
public void shellSort(int[] table){
    for (int delta = table.length/2; delta >0; delta/=2) {
        for (int i = delta; i < table.length; i++) {
            int temp=table[i];
            int j;
            for (j = i-delta; j >=0&&temp<table[j]; j-=delta) {
                table[j+delta]=table[j];
            }
            table[j+delta]=temp;
        }
    }
    System.out.print("希尔排序：");
    print(table);
}


/**
 * 冒泡排序（属于交换排序）
 * @param table
 * 原理：
 * 两个数之间比较，然后交换
 */
public void bubbleSort(int[] table){
    boolean exchange=true;     //如果有一趟没有进行排序，说明排序完成，不必再执行了
    for (int i = 0; i < table.length&&exchange; i++) {    //从第一个数开始，每次循环中前后两个交换
        exchange=false;
        for (int j = 0; j < table.length; j++) {    //实现前后两个数交换
            if(table[j+1]<table[j]){
                int temp=table[j];
                table[j]=table[j];
                table[j]=temp;
                exchange=true;
            }
        }
    }
    System.out.print("冒泡排序：");
    print(table);
}

/**
 * 快速排序（属于交换排序）
 * @param table
 * 将第一个值作为参考值，然后依次和最后j、最前比较i；
 * 如果最后的值小于参考值，则将最后的值放给i，否则j--；
 * 如果最前的值大于参考值，则将最前的值放给j,否则i++;
 * 直到i=j，同时将参考值放给i；
 * 这样就执行完第一次循环，并把参考值之前和之后分成前后组，然后在递归前后组，直到begin>=end；
 */
public void quickSort(int[] table){
    quickSort(table,0,table.length-1);
    //System.out.print("快速排序：");
    //print(table);
}



private void quickSort(int[] table, int begin, int end) {
    if(begin<end){
        int i=begin,j=end;
        int vot=table[begin];    //每次为分组中第一个元素作为比较值
        while(i!=j){
            while(i<j&&vot<=table[j]){    //先从分组中最后一个开始，如果最后一个大于比较值，则j--
                j--;
            }
            if(i<j){      
                table[i]=table[j];     //如果最后一个值小于比较值则，将最后这个值给i
                i++;
            }
            while(i<j&&vot>=table[i]){   //如果前面的第一个值小于参考值则i++
                i++;
            }
            if(i<j){      
                table[j]=table[i];      //如果前面值大于比较值，则将这个值给j
                j--; 
            }
        }
        table[i]=vot;     //知道和j相等的时候，将比较值给i；
        System.out.print("第1次快速排序：");
        print(table);   
        quickSort(table,begin,j-1);    //递归前面分组
        quickSort(table,i+1,end);     //递归后面分组

    }   

}




/**
 * 直接选择排序
 * @param table
 * 从数组中选出最小的元素放在最先的位置，然后i++
 * 
 */
public void selectSort(int[] table){
    for (int i = 0; i < table.length; i++) {
        int min=table[i];
        for (int j = i+1; j < table.length; j++) {   //找出最小的数，并给i
            if(table[j]<min){
                table[i]=table[j];
                table[j]=min;
                min=table[i];
            }
        }
    }
    System.out.print("直接选择排序：");
    print(table);

}


/**
 * 堆排序
 * @param table
 * 
 */
public void heapSort(int[] table){
    if(table==null||table.length<1){
        return;
    }
    //创建大堆
    buildMaxHeap(table);
    for (int i = table.length-1;i>=1;i--) {   //通过这个循环之后每个除了叶子节点，每个结点都是一个大堆
        exchangeElements(table, 0, i);
        maxHeap(table, i, 0);   //由于上次已经形成大堆了，这次不需要交换下面的，因为第二个已经是最大。
    }
    System.out.print("堆排序：");
    print(table);
}


/**
 * 创建一个大堆
 * @param table
 */
private void buildMaxHeap(int[] table) {
    // TODO Auto-generated method stub
    int half=(table.length-1)/2;
    for (int i = half; i >=0 ; i--) {
        maxHeap(table,table.length,i);
    }
}



private void maxHeap(int[] table, int length, int i) {
    int left=i*2+1;
    int right=i*2+2;
    int largest=i;
    if(left<length&&table[left]>table[i]){
        largest=left;
    }

    if(right<length&&table[right]>table[largest]){
        largest=right;
    }
    if(i!=largest){
        exchangeElements(table,i,largest);
        maxHeap(table, length, largest);
    }


}



private void exchangeElements(int[] table, int i, int largest) {
    int temp=table[i];
    table[i]=table[largest];
    table[largest]=temp;

}