排序总结归纳

对于一个int数组，请编写一个归并排序算法，对数组元素排序。

给定一个int数组A及数组的大小n，请返回排序后的数组。

测试样例：

[1,2,3,5,2,3],6

[1,2,2,3,3,5]

1、冒泡排序 O(n^2)

class BubbleSort {
public:
int* bubbleSort(int* A, int n) {
for(int i=0;i<n;i++){
for(int j=i;j<n;j++){
int tmp;
if(A[i]>A[j]){
tmp = A[i];
A[i]= A[j];
A[j]= tmp;
}
}
}
return A;
}
};

2、归并排序 O(nlogn)

class MergeSort {
public:

int* mergeSort(int* A, int n) {
int* tmp = new int
;
mergeSort1(A,0,n-1,tmp);
delete []tmp;
return A;
}
void mergeSort1(int* A,const int first,const int last,int* tmp){
if(first < last){
int mid = (first + last) / 2;
mergeSort1(A,first,mid,tmp);
mergeSort1(A,mid+1,last,tmp);
merge(A,first,mid,last,tmp);
}
}

void merge(int* A,const int first,const int mid,const int last,int* tmp){
int i=0,j=0,k=0;
for(i=first,j=mid+1;i<=mid && j<= last;){
if(A[i]<A[j])
tmp[k++] = A[i++];
else
tmp[k++] = A[j++];
}
while(i<=mid) tmp[k++] = A[i++];
while(j<=last) tmp[k++] = A[j++];
for(i=0;i<k;i++){
A[first+i] = tmp[i];
}

}
};

3、快速排序 O(nlogn)

class QuickSort {
public:
int* quickSort(int* A, int n) {
quickSort1(A,0,n-1);
return A;
}
void quickSort1(int* A,const int first,const int last){
if(first<last){
int mid = Sort(A,first,last);
quickSort1(A,first,mid);
quickSort1(A,mid+1,last);
}
}
int Sort(int* A,const int first,const int last){
int i=first;
int j=last;
int key = A[first];
if(first < last){
while(i<j){
while(i<j && key<=A[j])
j--;
if(i<j)
A[i++] = A[j];
while(i<j && key>=A[i])
i++;
if(i<j)
A[j--] = A[i];
}
A[i] = key;
}
return i;
}
};

4、堆排序 O(nlogn)

class HeapSort {
public:
int* heapSort(int* A, int n) {
int len = n;
for(int i=len/2-1;i>=0;i--)//bulid the heap
heapAdjust(A,i,len);
for(int i=len-1;i>=1;i--){// swap and adjust
swap(A,0,i);
heapAdjust(A,0,i);
}
return A;
}
void heapAdjust(int* A,int idx,int len){
int left = 2*idx+1;
int right = left+1;
int largest = idx;

if(left<len && A[left] > A[idx]) largest = left;
if(right<len && A[right] > A[largest]) largest = right;
if(largest != idx){
swap(A,idx,largest);
heapAdjust(A,largest,len);
}
}
void swap(int* A,int a,int b){
int tmp;
tmp = A[a];
A[a]= A[b];
A[b]= tmp;
}
};

5、希尔排序

class ShellSort {
public:
int* shellSort(int* A, int n) {
for(int step=n/2;step>=1;step /= 2){
for(int i=0;i<n;i+=step){
int tmp = A[i];
int j = i-step;
for(;j>=0;j-=step){
if(A[j]>tmp)
A[j+step] = A[j];
else
break;
}
A[j+step] = tmp;
}
}
return A;
}
};