数据结构 各种排序算法

数据结构各种排序算法总结2009-08-19 11:09计算机排序与人进行排序的不同：计算机程序不能象人一样通览所有的数据，只能根据计算机的"比较"原理，在同一时间内对两个队员进行比较，这是算法的一种"短视"。

1. 冒泡排序 BubbleSort最简单的一个public void bubbleSort(){int out, in;for(out=nElems-1; out>0; out--) // outer loop (backward)for(in=0; in<out; in++) // inner loop (forward)if( a[in] > a[in+1] ) // out of order?swap(in, in+1); // swap them} // end bubbleSort()效率：O(N2)2. 选择排序 selectSortpublic void selectionSort(){int out, in, min;for(out=0; out<nElems-1; out++) // outer loop{min = out; // minimumfor(in=out+1; in<nElems; in++) // inner loopif(a[in] < a[min] ) // if min greater,min = in; // we have a new minswap(out, min); // swap them} // end for(out)} // end selectionSort()效率：O(N2)3. 插入排序 insertSort在插入排序中，一组数据在某个时刻实局部有序的，为在冒泡和选择排序中实完全有序的。

public void insertionSort(){int in, out;for(out=1; out<nElems; out++) // out is dividing line{long temp = a[out]; // remove marked itemin = out; // start shifts at outwhile(in>0 && a[in-1] >= temp) // until one is smaller,{a[in] = a[in-1]; // shift item to right--in; // go left one position}a[in] = temp; // insert marked item} // end for} // end insertionSort()效率：比冒泡排序快一倍，比选择排序略快，但也是O(N2)如果数据基本有序，几乎需要O(N)的时间4. 归并排序 mergeSort利用递归，不断的分割数组，然后归并有序数组效率为O(N*logN),缺点是需要在存储器中有一个大小等于被排序的数据项数目的数组。

public void mergeSort() // called by main(){ // provides workspacelong[] workSpace = new long[nElems];recMergeSort(workSpace, 0, nElems-1);}//-----------------------------------------------------------private void recMergeSort(long[] workSpace, int lowerBound,int upperBound){if(lowerBound == upperBound) // if range is 1,return; // no use sortingelse{ // find midpointint mid = (lowerBound+upperBound) / 2;// sort low halfrecMergeSort(workSpace, lowerBound, mid);// sort high halfrecMergeSort(workSpace, mid+1, upperBound);// merge themmerge(workSpace, lowerBound, mid+1, upperBound);} // end else} // end recMergeSort()//----------------------------------------------------------- private void merge(long[] workSpace, int lowPtr,int highPtr, int upperBound){int j = 0; // workspace index int lowerBound = lowPtr;int mid = highPtr-1;int n = upperBound-lowerBound+1; // # of itemswhile(lowPtr <= mid && highPtr <= upperBound)if( theArray[lowPtr] < theArray[highPtr] )workSpace[j++] = theArray[lowPtr++];elseworkSpace[j++] = theArray[highPtr++];while(lowPtr <= mid)workSpace[j++] = theArray[lowPtr++];while(highPtr <= upperBound)workSpace[j++] = theArray[highPtr++];for(j=0; j<n; j++)theArray[lowerBound+j] = workSpace[j];} // end merge()5. 希尔排序 ShellSortpublic void shellSort(){int inner, outer;long temp;int h = 1; // find initial value of h while(h <= nElems/3)h = h*3 + 1; // (1, 4, 13, 40, 121, ...) while(h>0) // decreasing h, until h=1 {// h-sort the filefor(outer=h; outer<nElems; outer++){temp = theArray[outer];inner = outer;// one subpass (eg 0, 4, 8) while(inner > h-1 && theArray[inner-h] >= temp){theArray[inner] = theArray[inner-h];inner -= h;}theArray[inner] = temp;} // end forh = (h-1) / 3; // decrease h} // end while(h>0)} // end shellSort()希尔排序是基于插入排序的，由于插入排序复制的次数太多，导致效率的下降，而ShellSort先利用n-增量排序将数据变为基本有序，然后在利用插入排序（1-增量排序）。

n在排序中的一系列取值方法：Lnuth序列，间隔h=3h + 1效率：O(N3/2) 到O(N7/6)6. 快速排序其根本机制在于划分：划分数据就是把数据分为两组，使所有关键字大于特定值的数据项在一组，使所有关键字小于特定值的数据项在另一组。

public int partitionIt(int left, int right, long pivot){int leftPtr = left - 1; // right of first elemint rightPtr = right + 1; // left of pivotwhile(true){while(leftPtr < right && // find bigger itemtheArray[++leftPtr] < pivot); // (nop)while(rightPtr > left && // find smaller itemtheArray[--rightPtr] > pivot); // (nop)if(leftPtr >= rightPtr) // if pointers cross,break; // partition doneelse // not crossed, soswap(leftPtr, rightPtr); // swap elements} // end while(true)return leftPtr; // return partition} // end partitionIt()快速排序算法本质上通过把一个数组划分为两个子数组，然后递归的调用自身为每一个子数组进行快速排序。

枢纽（Pivot）的选择：选择数组最右端的数据项作为枢纽：public void recQuickSort(int left, int right){if(right-left <= 0) // if size <= 1,return; // already sortedelse // size is 2 or larger{long pivot = theArray[right]; // rightmost item// partition rangeint partition = partitionIt(left, right, pivot);recQuickSort(left, partition-1); // sort left siderecQuickSort(partition+1, right); // sort right side}} // end recQuickSort()//--------------------------------------------------------------public int partitionIt(int left, int right, long pivot)int leftPtr = left-1; // left (after ++)int rightPtr = right; // right-1 (after --)while(true){ // find bigger itemwhile( theArray[++leftPtr] < pivot ); // (nop)// find smaller itemwhile(rightPtr > 0 && theArray[--rightPtr] > pivot); // (nop)if(leftPtr >= rightPtr) // if pointers cross,break; // partition doneelse // not crossed, soswap(leftPtr, rightPtr); // swap elements} // end while(true)swap(leftPtr, right); // restore pivotreturn leftPtr; // return pivot location} // end partitionIt()当数据是有序的或者是逆序时，从数组的一端或者另外一端选择数据项作为枢纽都不是好办法，比如逆序时，枢纽是最小的数据项，每一次划分都产生一个有N-1个数据项的子数组以及另外一个只包含枢纽的子数组三数据项取中划分：选择第一个、最后一个以及中间位置数据项的中值作为枢纽public void recQuickSort(int left, int right)int size = right-left+1;if(size <= 3) // manual sort if smallmanualSort(left, right);else // quicksort if large{long median = medianOf3(left, right);int partition = partitionIt(left, right, median);recQuickSort(left, partition-1);recQuickSort(partition+1, right);}} // end recQuickSort()//-------------------------------------------------------------- public long medianOf3(int left, int right){int center = (left+right)/2;// order left & center if( theArray[left] > theArray[center] )swap(left, center);// order left & right if( theArray[left] > theArray[right] )swap(left, right);// order center & rightif( theArray[center] > theArray[right] )swap(center, right);swap(center, right-1); // put pivot on right return theArray[right-1]; // return median value } // end medianOf3()public int partitionIt(int left, int right, long pivot){int leftPtr = left; // right of first elem int rightPtr = right - 1; // left of pivotwhile(true){while( theArray[++leftPtr] < pivot ) // find bigger ; // (nop)while( theArray[--rightPtr] > pivot ) // find smaller ; // (nop)if(leftPtr >= rightPtr) // if pointers cross,break; // partition doneelse // not crossed, soswap(leftPtr, rightPtr); // swap elements} // end while(true)swap(leftPtr, right-1); // restore pivotreturn leftPtr; // return pivot location } // end partitionIt()。