排序算法小结

各种排序算法：

冒泡排序：

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 Arrayint[] 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