###冒泡排序

/**

* 冒泡排序 logN^2

* 基本思路：每次从数组底端将最小的数“冒”上来

*

**/

void BubbleSort(int *p, int len){

for(int i=0; i

for(int j=len-1; j>i; j--){

if(*(p+j)

*(p+j) ^= *(p+j-1);

*(p+j-1) ^= *(p+j);

*(p+j) ^= *(p+j-1);

}

}

}

}

###选择排序

/**

* 选择排序 logN^2

**/

void SelectSort(int *p, int len){

for(int i=0; i

int min = i;

for(int j=len-1; j>i; j--){

if(*(p+j)

}

if(min != i){

*(p+i) ^= *(p+min);

*(p+min) ^= *(p+i);

*(p+i) ^= *(p+min);

}

}

}

###插入排序

/**

* 插入排序 logN^2

**/

void InsertSort(int *p, int len){

for(int i=0; i

for(int j=i+1; j>0; j--){

if(*(p+j)

*(p+j) ^= *(p+j-1);

*(p+j-1) ^= *(p+j);

*(p+j) ^= *(p+j-1);

}else break;

}

}

}

###希尔排序

/**

* 希尔排序 N^1.5

* 基本思路：选取某个增量，将数组分为若干的子序列，对子序列进行插入排序，

* 逐渐减小增量，重复上述操作，直到增量为1，此时数组基本有序，最后进行一次插入排序。

**/

void ShellSort(int *p, int len){

for(int incre=len/2; incre>=1; incre--){

for(int i=0; i

for(int j=i+incre; j

for(int k=j; k>i; k-=incre){

if(*(p+k)

*(p+k) ^= *(p+k-incre);

*(p+k-incre) ^= *(p+k);

*(p+k) ^= *(p+k-incre);

}else break;

}

}

}

}

}

###快速排序

/**

* 快速排序 N*logN

**/

void QuickSort(int *p, int len){

if(len<=1) return;

int *b = p;

int *e = p + len - 1;

int sentry = *p;

while(b

while(b= sentry) e--;

*b = *e;

while(b

*e = *b;

}

*b = sentry;

QuickSort(p, b-p);

QuickSort(b+1, len-(b-p)-1);

}

###归并排序

/**

* 归并排序 N*logN

* 需要额外的空间存放数据

* 基本思想：将一个数组分成两份，如果这两份数组的有序的，那么将这两份数组归并，

* 对上述操作进行递归操作，直到分成的数组仅仅只有一个元素，那么它理所当然是有序的。

**/

void MergeArray(int *p, int len1, int *q, int len2){

int temp[len1+len2];

int i,j,k;

i = j = k = 0;

while(i

if(*(p+i)

temp[k++] = *(p+i++);

}else{

temp[k++] = *(q+j++);

}

}

while(i

while(j

for(i=0; i

}

void MergeSort(int *p, int len){

if(len<=1) return;

int middle = len/2;

MergeSort(p, middle);

MergeSort(p+middle, len-middle);

MergeArray(p, middle, p+middle, len-middle);

}

###堆排序

/**

* 堆排序 N * logN

* len/2 -1 最后一个节点的父节点

* 2*i + 1 左孩子节点

* 2*i + 2 右孩子节点

* 基本思路：将一个数组看作是完全二叉树，先调整整个堆，然后将根节点和

* 末节点互换，重新调整堆

**/

void HeapAdjust(int *p, int len, int i){

int child = 2*i+1;

if(child>=len) return;

if(child

if(*(p+i)

*(p+i) ^= *(p+child);

*(p+child) ^= *(p+i);

*(p+i) ^= *(p+child);

HeapAdjust(p, len, child);

}

}

void HeapSort(int *p, int len){

//首先先从最后一个节点的父节点开始调整堆

for(int i=len/2-1; i>=0; i--) HeapAdjust(p, len, i);

for(int i=len-1; i>0; i--){

*p ^= *(p+i);

*(p+i) ^= *p;

*p ^= *(p+i);

HeapAdjust(p, i, 0); //

}

}