資料結構常用排序（java）

標籤：資料結構 排序 java

資料結構排序演算法的概念是從網上抄錄的：

基本概念：

1、  排序：按照一定的關鍵字，將一個序列排列成想要得到的一個新的序列。

2、  內部排序和外部排序：整個排序過程完全在記憶體中進行，叫做內部排序。資料量較大需要藉助外部存放裝置才能完成，叫做外部排序。

3、  主關鍵字和此關鍵字：

4、  排序的穩定性：對於相同的元素來說，在排序之前和之後的書訊是一樣的，那麼這種排序就是穩定的排序，如果順序發生了變化，那麼就是不穩定排序。

插入類排序：

（一）   思想：在一個已經排好序的序列中，將未被排進的元素按照原先的規定插入到指定位置。

（二）   分類：

1、  直接插入排序：

①   思想：最基本的插入排序，將第i個插入到前i-1個中的適當位置。

②   時間複雜度：T(n) = O(n)。

③   空間複雜度：S(n) = O(1)。

④   穩定性：穩定排序。迴圈條件while(r[0].key < r[j].key)保證的。

⑤   程式：

 /**  * 直接插入排序：  * 1.從第一個元素開始，該元素可以認為已經被排序   * 2.取出下一個元素，在已經排序的元素序列中從後向前掃描  * 3.如果該元素小於前面的元素（已排序），則依次與前面元素進行比較如果小於則交換，直到找到大於該元素的就則停止；  * 4.如果該元素大於前面的元素（已排序），則重複步驟2 5.重複步驟2~4 直到所有元素都排好序 。  *   * @param a  */ public static void insert(int[] a) {  for (int i = 1; i < a.length; i++) {   int key = a[i];   for (int j = i - 1; j >= 0; j--) {    if (key < a[j]) {     int temp = a[j];     a[j] = key;     a[i] = temp;     i = j;    }   }  } }

2、  折半插入排序：

①   思想：因為是已經確定了前部分是有序序列，所以在尋找插入位置的時候可以用折半尋找的方法進行尋找，提高效率。

②   時間複雜度：比較時的時間減為O(n㏒n)，但是移動元素的時間耗費未變，所以總是得時間複雜度還是O(n)。

③   空間複雜度：S(n) = O(1)。

④   穩定性：穩定排序。

⑤   程式：

 /**  * 折半插入排序：  * 在將一個新元素插入已排好序的數組的過程中，尋找插入點時， 將待插入地區的首元素設定為a[low]，末元素設定為a[high]，  * 比較時將待插入元素與a[m]，其中m=(low+high)/2相比較,如果比參考元素大，  * 則選擇a[low]到a[m-1]為新的插入地區(即high=m-1)， 否則選擇a[m+1]到a[high]為新的插入地區（即low=m+1），  * 如此直至low<=high不成立，即將此位置之後所有元素後移一位， 並將新元素插入a[high+1]。  *   * @param a  */ public static void binaryInsert(int[] a) {  // {1, 5, 5, 3, 4, 3,2}  for (int i = 1; i < a.length; i++) {   int key = a[i];   int low = 0;   int high = i - 1;   while (low <= high) {    int mid = (low + high) / 2;    if (key < a[mid]) {     high = mid - 1;    } else {     low = mid + 1;    }   }   System.out.println("low:" + low + ",high:" + high + ",i:" + i     + ",key:" + key);   for (int j = i; j > high + 1; j--) {    a[j] = a[j - 1];   }   a[high + 1] = key;  } }

3、shell排序

交換類排序：

（一）   思想：通過交換逆序元素進行排序的方法。

（二）   分類：

1、  冒泡排序：

①   思想：反覆掃描待排序序列，在掃描的過程中順次比較相鄰的兩個元素的大小，若逆序就交換位置。第一趟，從第一個資料開始，比較相鄰的兩個資料，（以升序為例）如果大就交換，得到一個最大資料在末尾；然後進行第二趟，只掃描前n-1個元素，得到次大的放在倒數第二位。以此類推，最後得到升序序列。如果在掃描過程中，發現沒有交換，說明已經排好序列，直接終止掃描。所以最多進行n-1趟掃描。

②   時間複雜度：T(n) = O(n)。

③   空間複雜度：S(n) = O(1)。

④   穩定性：穩定排序。

⑤   程式：

 /**  * 冒泡排序：  * 依次比較相鄰的兩個數，將小數放在前面，大數放在後面。 即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。  * 然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續， 直至比較最後兩個數，將小數放前，大數放後。 至此第一趟結束，將最大的數放到了最後。  * 依次執行以上步驟a.leng-1次，排序完成。  *   * @param a  */ public static void bubble(int[] a) {  // {1, 5, 5, 3, 4, 3,2}  for (int i = 1; i < a.length; i++) {   for (int j = 0; j < a.length - i; j++) {    if (a[j + 1] < a[j]) {     int temp = a[j + 1];     a[j + 1] = a[j];     a[j] = temp;    }   }  } }

2、  快速排序：

①   思想：冒泡排序一次只能消除一個逆序，為了能一次消除多個逆序，採用快速排序。以一個關鍵字為軸，從左從右依次與其進行對比，然後交換，第一趟結束後，可以把序列分為兩個子序列，然後再分段進行快速排序，達到高效。

②   時間複雜度：平均T(n) = O(n㏒n)，最壞O(n)。

③   空間複雜度：S(n) = O(㏒n)。

④   穩定性：不穩定排序。{3， 2， 2}

⑤   程式：

 /**  * 快速排序：  * 一趟快速排序的演算法是：   * 1）設定兩個變數l、h，排序開始的時候：l=0，h=N-1；  * 2）以第一個數組元素作為關鍵資料，賦值給key，即key=A[0]；  * 3）從j開始向前搜尋，即由後開始向前搜尋，找到第一個小於key的值A[j]，將A[j]和A[i]互換,然後h--；  * 4）從i開始向後搜尋，即由前開始向後搜尋，找到第一個大於key的A[i]，將A[i]和A[j]互換,然後l++；  *  5）重複第3、4步，直到l==h  *   * @param a  */ public static void quick(int[] a, int l, int h) {  int low = l;  int high = h;  int key = a[low];  while (low < high) {   //從後往前找   while (low < high && key < a[high]) {    high--;   }   if (low < high) {    int temp = a[high];    a[high] = a[low];    a[low] = temp;    low++;   }   //從前往後找   while (low < high && key > a[low]) {    low++;   }   if (low < high) {    int temp = a[high];    a[high] = a[low];    a[low] = temp;    high--;   }  }  if (low > l) {   quick(a, l, low-1);  }  if (high < h) {   quick(a, high+1, h);  } }

選擇類排序：

（一）   思想：每一趟在n – i + 1 ( i = 1,2, … , n - 1)個記錄中選取關鍵字最小的記錄作為有序序列中的第i個記錄。

（二）   分類：

1、  簡單選擇排序：

①   思想：第一趟時，從第一個記錄開始，通過n – 1次關鍵字的比較，從n個記錄中選出關鍵字最小的記錄，並和第一個記錄進行交換。第二趟從第二個記錄開始，選擇最小的和第二個記錄交換。以此類推，直至全部排序完畢。

②   時間複雜度：T(n) = O(n)。

③   空間複雜度：S(n) = O(1)。

④   穩定性：不穩定排序，{3， 3， 2}。

⑤   程式：

 /**  * 選擇排序：  * 在第一趟遍曆N個資料，找出其中最小的數值與第一個元素交換，  * 第二趟遍曆剩下的N-1個資料，找出其中最小的數值與第二個元素交換......  * 第N-1趟遍曆剩下的2個資料，找出其中最小的數值與第N-1個元素交換，  * 至此選擇排序完成。  * @param a  */ public static void selectSort(int[] a) {  //{ 1, 5, 5, 3, 4, 3, 2 };  for(int i=1; i<a.length; i++) {   int flag = i-1;   for(int j=i; j<a.length; j++) {    if(a[flag] > a[j]) {     flag = j;    }   }   if(flag != i-1) {    int temp = a[flag];    a[flag] = a[i-1];    a[i-1] = temp;   }   toString(a);  } }

3、  堆排序：

①   思想：把待排序記錄的關鍵字存放在數組r[1…n]中，將r看成是一刻完全二叉樹的順序表示，每個節點表示一個記錄，第一個記錄r[1]作為二叉樹的根，一下個記錄r[2…n]依次逐層從左至右順序排列，任意節點r[i]的左孩子是r[2i]，右孩子是r[2i+1]，雙親是r[i/2向下取整]。然後對這棵完全二叉樹進行調整建堆。

②   時間複雜度：T(n) = O(n㏒n)。

③   空間複雜度：S(n) = O(1)。

④   穩定性：不穩定排序。{5， 5， 3}

資料結構常用排序（java）