数据结构各种排序算法总结

数据结构各种排序算法总结

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

1. 冒泡排序BubbleSort

最简单的一个

public void bubbleSort()

{

int out, in;

for(out=nElems-1; out>0; out--) // outer loop (backward)

for(in=0; in

if( a[in] > a[in+1] ) // out of order?

swap(in, in+1); // swap them

} // end bubbleSort()

效率：O(N2)

2. 选择排序selectSort

public void selectionSort()

{

int out, in, min;

for(out=0; out

{

min = out; // minimum

for(in=out+1; in

if(a[in] < a[min] ) // if min greater,

min = in; // we have a new min

swap(out, min); // swap them

} // end for(out)

} // end selectionSort()

效率：O(N2)

3. 插入排序insertSort

在插入排序中，一组数据在某个时刻实局部有序的，为在冒泡和选择排序中实完全有序的。public void insertionSort()

{

int in, out;

for(out=1; out

{

long temp = a[out]; // remove marked item

in = out; // start shifts at out

while(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 workspace

long[] 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 sorting else

{ // find midpoint

int mid = (lowerBound+upperBound) / 2;

// sort low half recMergeSort(workSpace, lowerBound, mid);

// sort high half recMergeSort(workSpace, mid+1, upperBound);

// merge them merge(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 items

while(lowPtr <= mid && highPtr <= upperBound)

if( theArray[lowPtr] < theArray[highPtr] )

workSpace[j++] = theArray[lowPtr++];