Java排序之排序大綜合

一、最近寫了一些排序，於是和和大家分享一下：（默認都是從小到大排序）

二、冒泡排序

　　1、什么是冒泡排序：原理是臨近的兩個數比較大小，將較大的數往后移，這樣遍歷一趟數組以后，最大的數就排在的最后面（時間復雜的為O（N2））

　　　重復上面步驟N次。

　　2、原理描述：data{44,77,55,33,66}

　　　　　　第一次運行：data{44,55,33,66,77}

　　　　　　第二次運行：data{44，33，55，66，77}

　　　　　　。。。。。。

　　　　　　第N次執行：data{33，44，55，66，77}

　　3、參考代碼：

import java.util.Arrays; /** * Description:冒泡排序 * Author: Hey * Date: 2015/12/7 */
public class BubbleSort { public static void main(String[] args) { int[] data = {11, 66, 33, 44, 77, 55}; for (int i = 0; i < data.length-1; i++) { for (int j = data.length - i; j > 0; j--) { if (data[i] > data[i + 1]) { data[i] = data[i] ^ data[i + 1]; data[i + 1] = data[i + 1] ^ data[i]; data[i] = data[i] ^ data[i + 1]; } } } // for(int i=0;i<data.length;i++){ // System.out.println(data[i]); // }
 System.out.println(Arrays.toString(data)); } }

三、選擇排序

　　1、什么是選擇排序：選擇排序是選擇數組中最小的數將該數移動到數組最前面，將其他元素往后移動，重復N次操作（時間復雜的（O（N2）））

　　2、原理：data{44,77,55,33,66}

　　　第一次運行：data{33，44，77，55，66}

　　　第二次運行：data{33，44，77，55，66}

　　　。。。。。。。

　　　第N次運行：data{33，44，55，66，77}

　　3、參考代碼：

　　

import java.util.Arrays; /** * Description:選擇排序 * Author: Hey * Date: 2015/12/7 */
public class SelectionSort { public static void main(String [] args){ int[] data = {11, 66, 33, 44, 77, 55}; int minData=0; for(int i=0;i<data.length;i++){ minData=data[i]; for(int j=i+1;j<data.length;j++){ if(data[j]<minData){ data[j]=data[j]^minData; minData=minData^data[j]; data[j]=data[j]^minData; } data[i]=minData; } } System.out.print(Arrays.toString(data)); } }

四、插入排序：

　　1、什么是插入排序：插入排序是將數組划分為兩個部分：有序部分和無序部分，將無序部分插入有序部分，重復執行N-1次,默認數組第一項就是有序的（時間復雜的O（N2））

　　2、插入排序的原理：data{44,77,55,33,66}

　　　　　　　　第一次：data{44，77，55，33，66}

　　　　　　　　第二次：data{44，55，77，33，66}

　　　　　　　　。。。。

　　　　　　　　第N次：data{33，44，55，66，77}

　　3、參考代碼

package cn.edu.insertionsort; import java.util.Arrays; /** * Description:插入排序 * Author: Hey * Date: 2015/12/7 */
public class InsertSort { public static void main(String[]args){ int[] data = {11, 66, 33, 44, 77, 55}; int i; // int j;

        for(i=1;i<data.length;i++){ /*int temp=data[i]; for(j=i-1;j>0;j--){ if(data[i]<data[j]){ if(data[j]>data[i]); data[i]=data[j]; data[j]=temp; }else{ break; } }*/


            if(data[i-1]>data[i]){ int temp=data[i]; int j=i; while(j>0&&data[i]<data[j-1]){ data[j]=data[j-1]; j--; } data[j]=temp; } } System.out.print(Arrays.toString(data)); } }

五、希爾排序

　　1、（歷史）希爾排序是選擇排序的進化版：插入排序算法對大致有序的數組效率比較高；

　　　但是如果是反序，那么插入排序將會進行大量的移動復制，如果先讓部分的局部有序，那么久能夠減少移動的次數

　　　（什么是希爾排序）先取一個小於n的整數d1作為第一個增量，把文件的全部記錄分組。

　　　所有距離為d1的倍數的記錄放在同一個組中。先在各組內進行直接插入排序；然后，取第二個增量d2<d1重復上述的分組和排序，

　　　直至所取的增量  =1( <  …<d2<d1)，即所有記錄放在同一組中進行直接插入排序為止。

　　2、關於增量的選取一般用3h+1的算數公式

　　3參考代碼：

　　

import java.util.Arrays; /** * Description:希爾排序,希爾排序的之間的間隔是使用3h+1（運行個數）來定義的。 * h代表間隔(由於排序算法是基於插入算法的，當數組大小至少為3時，插入排序才比較有效) * Author: Hey * Date: 2015/12/7 */
public class HillSort { public static void main(String[]args){ int[] data = {11, 66, 33, 44, 77, 55}; //計算間隔
        int length=data.length; int h=1; while(h<=length/3) h=3*h+1; while(h>0){ for(int i=h;i<length;i++){ int temp=data[i]; int j=i; while(j>h-1&&data[j-h]>temp){ data[j]=data[j-h]; j-=h; } data[j]=temp; } h=(h-1)/3; } System.out.print(Arrays.toString(data)); } }

六、快速排序

　　1、什么事快速排序：快速排序是在數組選擇一個標准位（其實也就是在數組中選擇一個數做參考），將比標志位大的數右移，比標志位小的左移，讓縮小范圍繼續比較

　　3、參考代碼：

package cn.edu.quicksort; import java.util.Arrays; /** * Description:快速排序 * Author: Hey * Date: 2015/12/7 */
public class QuickSort { int[] data = {11, 66, 33, 44, 77, 55}; public void quickSort(int left, int right) { if ((right - left) <= 0) return; else { int pivot = data[right]; int parttion=recQuickSort(left,right,pivot); quickSort(left, parttion-1); quickSort(parttion + 1, right); } } public int recQuickSort(int left, int right, int pivot) { int leftPtr=left-1; int rightPtr=right; while (true) { while (data[++leftPtr] < pivot) ; while (data[--rightPtr] > pivot) ; if (leftPtr >= rightPtr) break; else swap(leftPtr, rightPtr); } swap(leftPtr, right); return leftPtr; } public void swap(int i, int j) { data[i] = data[i] ^ data[j]; data[j] = data[j] ^ data[i]; data[i] = data[i] ^ data[j]; } public static void main(String[] args) { QuickSort q=new QuickSort(); q.quickSort(0,q.data.length-1); System.out.print(Arrays.toString(q.data)); } }

七：堆排序

　　1、什么事堆排序：堆排序(Heapsort)是指利用堆積樹（堆）這種數據結構所設計的一種排序算法，它是選擇排序的一種。

　　可以利用數組的特點快速定位指定索引的元素。堆分為大根堆和小根堆，是完全二叉樹。大根堆的要求是每個節點的值都不大於其父節點的值，

　　即A[PARENT[i]] >= A[i]。在數組的非降序排序中，需要使用的就是大根堆，因為根據大根堆的要求可知，最大的值一定在堆頂。

　　2、參考代碼：

package cn.edu.heapsort; import java.util.Arrays; /** * Description:堆排序 * Author: Hey * Date: 2015/12/7 */
public class HeapSort { private int size; private Node[]nodes; private int elms; public HeapSort(int size){ elms=0; this.nodes=new Node[size]; } public boolean insert(int value){ if(elms>=value) return false; Node node=new Node(value); nodes[elms]=node; trickUp(elms++); return true; } public Node remove(){ Node temp=nodes[0]; nodes[0]=nodes[--elms]; trickDown(0); return temp; } private void trickUp(int index){ int parent=(index-1)/2; Node temp=nodes[index]; while(index>0&&nodes[parent].value<temp.value){ nodes[index]=nodes[parent]; index=parent; parent=(parent-1)/2; } nodes[index]=temp; } private void trickDown(int index){ Node temp=nodes[0]; int largeChild=0; while(index<elms/2){ largeChild=maxNode(index); if(temp.value>nodes[largeChild].value) break; else{ nodes[index]=nodes[largeChild]; index=largeChild; } } nodes[index]=temp; } public static void main(String []args){ HeapSort h=new HeapSort(10); h.insert(10); h.insert(23); h.insert(12); h.insert(17); h.insert(33); h.print(); System.out.println(h.remove()); System.out.println(h.remove()); System.out.println(h.remove()); System.out.println(h.remove()); System.out.println(h.remove()); } private void print() { System.out.println(Arrays.toString(nodes)); } private int maxNode(int parent){ int left=parent*2+1; int right=parent*2+2; if (right<elms&&nodes[left].value<nodes[right].value) return right; else
            return left; } private class Node{ public int value; public Node(int value){ this.value=value; } @Override public String toString() { return "HeapSort{" +
                     "value=" + value +
                     '}'; } } }