排序算法小结

各种排序算法：

冒泡排序：

public void BurbleSort(int []aa) { for(int i=0; i<aa.length; i++) { for(int j=(aa.length-1); j>i; j--) //當前數組，兩兩元素比較冒泡出最小的。 { if (aa[j] < aa[j - 1]) exchange(aa, j, j-1); } } }

选择排序：

public void ChooseSort(int []aa) { for(int i=0; i<aa.length; i++)//每次選取當前數組最小的元素插入到起始位置； { int min = i; for(int j = i+1; j<aa.length; j++) { if(aa[j] < aa[min]) min = j; //有不相鄰位置交換，不穩定 } if (min != i) { exchange(aa, i, min); } } }

插入排序：

public void ClassicInsertSort(int []aa) { for(int i=1; i<aa.length; i++)//從第二個元素開始插入 { int j; int t = aa[i]; //記錄插入位置的值 for(j=i; j>0&&aa[j-1]>t; j--) //如果前面元素較大，則前面元素向後移動，騰出插入預算的位置。 aa[j] = aa[j-1]; aa[j] = t; //在待插位置插入元素 } }

希尔排序：

public static void ShellSort(int a[], int d) { int len = a.length; while(d>0) { for(int i=0;i<d;i++) { for(int j=i+d;j<len;j+=d)//插入排序 { int t = a[j]; int k = j; while(k>i&&t<a[k-d]) { a[k] = a[k-d]; k = k-d; } a[k] = t; } } d = d/2; } }

快速排序：

private int Partion(int []aa, int start, int end) { int temp = aa[end]; //最後一個元素作標記 int i=start-1,j; for(j = start; j<end; j++) //j記錄當前小於標記元素的位置 { if(aa[j] < temp) //i記錄大於標記的元素最小位置 { i++; exchange(aa,i,j); //遇到小於標記元素的交換。 } } exchange(aa,i+1,end); //將標記位置放到定好的位置。 return i+1; } private int SwingPartion(int []aa, int start, int end) { int i=start,j=end; int temp = aa[start]; //第一個元素做標記 while(true) { while(aa[j]>temp && i<j){ j--; }; //從后向前讀到讀到第一個小於標記的元素 while(aa[i]<temp && i<j){//或者從前向後讀到第一個大於標記的元素 i++; //(aa[i]或aa[j]有一個為標記值) }; exchange(aa,i,j); //交換兩元素的位置 if(i==j) break; } return j; } public void QuicklySort(int []aa, int start, int end) { if(start < end) { int partpos; // partpos = Partion(aa, start, end); partpos = SwingPartion(aa, start, end); QuicklySort(aa, start, partpos - 1); QuicklySort(aa, partpos + 1, end); } }

堆排序：

private void Heapify(int []aa,int node,int endnode) //調整節點 { int nchild = 2*node+1; if(nchild <= endnode) //較大的子節點 { if(nchild+1 <= endnode) { if(aa[nchild+1]>aa[nchild]) { nchild++; } } if (aa[nchild] > aa[node]) { exchange(aa, node, nchild); } Heapify(aa,nchild,endnode); //加此行保證node開始節點為大根堆。 } } private void BuildMaxHeap(int []aa, int start, int end) { for(int i = (end-1)/2;i>=start;i--) //從有child節點向前，依次調整，使成為大根堆 { Heapify(aa,i,end); } } public void HeapSort(int []aa) //一次建立，多次調整 { BuildMaxHeap(aa,0,aa.length-1); //首先建立大根堆 for(int i=aa.length-1; i>0; i--) { exchange(aa,0,i); //交換首尾兩個節點 Heapify(aa,0,i-1); //重新調整使之成為大根堆。 } }

归并排序：

public void MergeSort(int[]aa,int start, int end) { if (start < end) { int mid = (end + start) / 2; MergeSort(aa, start, mid); //遞歸 MergeSort(aa, mid + 1, end); //Merge Array int[] bb = new int[end + 1 - start]; //空間o(n) int k = 0; int i = start, j = mid + 1; //一個元素時不變，歸併。 while (i <= mid && j <= end) { bb[k++] = aa[i] < aa[j] ? aa[i++] : aa[j++]; } while (j <= end) { bb[k++] = aa[j++]; } while (i <= mid) { bb[k++] = aa[i++]; } for(i=0;i< end-start+1;i++) aa[i+start] = bb[i]; } }

 

另外还有一些排序：

      希尔排序是插入排序的改进版。实质是增量倍减分组的插入排序。插入排序是稳定的，而希尔排序则不稳定。

      基数排序使用分别排序和收集的排序方法，是一种稳定的排序方法。

      桶排序先将待排序数划分为均匀的桶区间，然后桶内采用以上的排序算法。

排序算法的稳定性：

      如果算法中不存才不相邻元素位置的交换，则此排序算法是稳定的。

      冒泡，插入，归并，基数排序都是稳定的排序算法。

      选择， 希尔，快速，堆排序是不稳定的排序算法。

算法的时间复杂度：

      基本语句（执行最多的语句）的执行频度为此算法的时间复杂度。

      冒泡，选择，插入为n² ，

      快速，归并，堆，为nlogn

      希尔 n^1.2