1、快速排序
平均复杂度是nlogn
#include<iostream>
#include<stdlib.h>
#include<time.h>
using namespace std;
//化分区间,找到最后元素的排序位置。并返回分隔的点（即最后一数据排序的位置）。
//划分的区间是[nBegin, nEnd). pData是保存数据的指针
int Partition(int *pData, int nBegin, int nEnd)
{
int i = nBegin + rand()%(nEnd - nBegin);
int x = pData[i];
pData[i] = pData[nBegin];
pData[nBegin] = x;
--nEnd;
while(nBegin < nEnd)
{
//从后向前，找到比X小的元素位置
while(pData[nEnd] > x)
{
--nEnd;
}
if(nBegin < nEnd)
{
pData[nBegin] = pData[nEnd];
pData[nEnd] = x; //这里是为了做一个哨兵，防止小区域增加时越界。
++nBegin;
}
//小的区域增加，找到一个不比x小的元素。
while(pData[nBegin] < x)
{
++nBegin;
}
//把不比x小的元素存放在大的区域内。nEnd刚好预留了此位置。
if(nBegin < nEnd)
{
pData[nEnd] = pData[nBegin];
--nEnd;
}
}
pData[nBegin] = x; //这里一定要赋值，不然如果是nEnd退出循环，他是保存着以前的大值，会出错。
return nBegin; //返回nD的位置，就是分割的位置
}
//排序的递归调用
int QuickSortRecursion(int *pData, int nBegin, int nEnd)
{
if(nBegin >= nEnd - 1)
{
return 1;
}
//这里因为分割的时候，分割点处的数据就是排序中他的位置
//也就是说他的左边的数据都小于等于他，他右边的数据都大于他
//所以他不在递归调用的数据中
int i = Partition(pData, nBegin, nEnd);
QuickSortRecursion(pData, nBegin, i);
QuickSortRecursion(pData, i + 1, nEnd);
return 1;
}
//快速排序
int QuickSort(int* pData, int nLen)
{
srand((unsigned int)time(NULL));
//递归调用，快速排序。
QuickSortRecursion(pData, 0, nLen);
return 1;
}
int main()
{
int nData[10] = {2,6,3,4,1,5,7,8,10,9}; //测试数据
QuickSort(nData, 10);
for (int i = 0; i < 10; ++i)
{
cout << nData[i] << " ";
}
cout << endl;
system("pause");
return 0;
}
2、堆排序
#include<iostream>
#include<stdlib.h>
#include<time.h>
using namespace std;
inline void Swap(int &a, int &b)
{
if(a != b)
{
a^=b;
b^=a;
a^=b;
}
}
int Heapify(int *npData, int nPos, int nLen)
{
int nMax = -1; //暂存最大值
int nChild = nPos * 2; //他的左孩子位置
while(nChild <= nLen)
{
nMax = npData[nPos];
if(nMax < npData[nChild])
{
nMax = npData[nChild];
}
if(nMax != npData[nPos])
{
Swap(npData[nPos], npData[nChild]);
nPos = nChild;
nChild *= 2;
}
else
{
break;
}
}
return 1;
}
//建立一个堆
int BuildHeap(int* npData, int nLen)
{
//从nLen / 2最后一个有叶子的数据开始，逐一的插入堆，并维持堆得平衡。
//因为堆是一个完全二叉树，所以nlen/2+1- nLen之间肯定都是叶子。
//叶子还判断什么呢。只有一个数据，肯定满足堆得性质咯。
for (int i = nLen / 2; i >= 1; --i)
{
Heapify(npData, i, nLen);
}
return 1;
}
//堆排序
int HeapSort(int* npData, int nLen)
{
BuildHeap(npData, nLen); //建立一个堆。
while(nLen >= 1) //逐一交和第一个元素交换数据到最后
{ //完成排序
Swap(npData[nLen], npData[1]);
--nLen;
Heapify(npData, 1, nLen);//交换之后一定要维持一下堆得性质。
} //不然小的成第一个元素,就不是堆了。
return 1;
}
int main()
{
int nData[11] = {0,9,8,7,6,5,4,3,2,1,0}; //测试数据，下标从1开始哦。
HeapSort(nData, 10); //堆排序
for (int i = 1; i <= 10; ++i) //输出排序结果。
{
cout << nData[i] << " ";
}
cout << endl;
system("pause");
return 0;
}
3、冒泡排序
#include<iostream>
using namespace std;
void bubbleSort(int *pData, int len)
{
bool flag = false;
int temp;
for(int i = len - 1; i > 0; i--)
{
flag = false;
for(int j = 0; j < i; j++)
{
if(pData[j] > pData[j + 1])
{
temp = pData[j];
pData[j] = pData[j + 1];
pData[j + 1] = temp;
flag = true;
}
}
if(flag == false)
{
break;
}
}
for(int j = 0; j < len; j++)
{
cout << pData[j] << " ";
}
cout << endl;
}
int main()
{
int pData[] = {0, 4, 2, 6, -3, 5, 3, 9, 7, 8};
bubbleSort(pData, 10);
system("pause");
return 0;
}
4、插入排序
#include<iostream>
using namespace std;
void insertSort(int *pData, int len)
{
int temp;
for(int i = 0; i < len; i++)
{
for(int j = i - 1; j >= 0; j--)
{
if(pData[j + 1] < pData[j])
{
temp = pData[j + 1];
pData[j + 1] = pData[j];
pData[j] = temp;
}
}
}
for(int j = 0; j < len; j++)
{
cout << pData[j] << " ";
}
cout << endl;
}
int main()
{
int pData[] = {0, 4, 2, 6, -3, 5, 3, 9, 7, 8};
insertSort(pData, 10);
system("pause");
return 0;
}
4、shell排序
#include<iostream>
using namespace std;
void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
void shell(int *p, int n)
{
int gap = n/2;
int i,j;
for(; gap > 0; gap = gap/2)
{
for(i = gap; i <= n - 1; i++) //´Ógap¿ªÊ¼ÎªËùÔÚµÄÿ¸ö×é½øÐвåÈëÅÅÐò£¬i=gapÊǸÃ×éµÄµÚ¶þ¸öÔªËØ
{
j = i;
if(*(p+j) < *(p+j-gap))
{
while(j >= gap && *(p + j - gap))
{
swap(p+j, p+j-gap);
j = j-gap;
}
}
}
}
}
int main()
{
int a[]= {5,4,3,21,1,100,93,1,3,2,4};
shell(a, 11);
for(int k = 0; k < 10; k++)
{
cout << *(a+k) << " ";
}
cout << endl;
system("pause");
return 0;
}
