注:所有排序都是写的由小到大排序的情况
1.插入排序
1)直接插入排序(稳定)
代码:
void DirectInsertSort(int* arr, int len)
{
if(NULL==arr || len<=1)
return;
int keyIndex;//要插入的值下标
for(keyIndex=1;keyIndex<len;++keyIndex)
{
int key=arr[keyIndex]; //要插入的值
int sortedIndex=keyIndex-1; //前面已经排好序的值的下标,由后往前比较
while(sortedIndex>=0 && arr[sortedIndex]>key)
{
arr[sortedIndex+1]=arr[sortedIndex];
--sortedIndex;
}
arr[sortedIndex+1]=key; //注意这里的下标 sortedIndex+1
}
}
2)希尔排序 (不稳定)
希尔排序好的增量序列的共同特征:
http://baike.baidu.com/view/178698.htm?fromtitle=希尔排序算法&fromid=1801475&type=syn
① 最后一个增量必须为1
② 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况
代码:void ShellSort(int* arr, int len)
{
if(NULL==arr || len<=1)
return;
for (int gap = len / 2; gap > 0; gap /= 2) //增量(gap/2.2时间效率更好)
for (int keyIndex = gap; keyIndex < len; ++keyIndex) //插入排序即为gap=1的情况
{
int key = arr[keyIndex];
int sortedIndex = keyIndex -gap;
while(sortedIndex >= 0 && arr[sortedIndex] > key)
{
arr[sortedIndex+gap] = arr[sortedIndex];
sortedIndex -=gap;
}
arr[sortedIndex+gap] = key;
}
}
2.选择排序
1)直接选择排序(不稳定)
第一次从R[0]~R[n-1]中选取最小值,与R[0]交换,第二次从R[1]~R[n-1]中选取最小值,与R[1]交换,....,第i次从R[i-1]~R[n-1]中选取最小值,与R[i-1]交换,.....,第n-1次从R[n-2]~R[n-1]中选取最小值,与R[n-2]交换,总共通过n-1次,得到一个按排序码从小到大排列的有序序列·
初始状态 [ 8 3 2 1 7 4 6 5 ] 8 <--> 1
第一次 [ 1 3 2 8 7 4 6 5 ] 3 <--> 2
第二次 [ 1 2 3 8 7 4 6 5 ] 3 <--> 3
第三次 [ 1 2 3 8 7 4 6 5 ] 8 <--> 4
第四次 [ 1 2 3 4 7 8 6 5 ] 7 <--> 5
第五次 [ 1 2 3 4 5 8 6 7 ] 8 <--> 6
第六次 [ 1 2 3 4 5 6 8 7 ] 8 <--> 7
第七次 [ 1 2 3 4 5 6 7 8 ] 排序完成
代码:
void DirectChooseSort(int* arr, int len)
{
if(NULL==arr || len<=1)
return;
for(int keyIndex=0;keyIndex<len-1;++keyIndex)
{
int minIndex=keyIndex;
for(int leftIndex=keyIndex+1;leftIndex<len;++leftIndex) //arr[keyIndex]~arr[len-1]最小值
{
if(arr[minIndex]>arr[leftIndex])
minIndex=leftIndex;
}
if(minIndex!=keyIndex)
{
int temp=arr[minIndex];
arr[minIndex]=arr[keyIndex];
arr[keyIndex]=arr[minIndex];
}
}
}
2)堆排序(不稳定)---最大堆
最大堆性质:树中每个结点的值都大于或者等于任意一个子结点的值
代码:
给出了非递归和递归方法
//递归方法
void MaxHeapify_Recursively(int* arr, int idx, int len)
{
int leftIdx=2*idx+1;
int rightIdx=2*idx+2;
int maxIdx=idx;//idx,leftIdx和rightIdx中最小值的下标
if(leftIdx<len && arr[maxIdx]<arr[leftIdx])
maxIdx=leftIdx;
if(rightIdx<len && arr[maxIdx]<arr[rightIdx])
maxIdx=rightIdx;
if(maxIdx!=idx)
{
int temp=arr[idx];
arr[idx]=arr[maxIdx];
arr[maxIdx]=temp;
MaxHeapify_Recursively(arr,maxIdx,len);
}
}
//非递归循环方法
void MaxHeapify_Iteratively(int* arr, int idx, int len)
{
while(idx<len/2)
{
int leftIdx=2*idx+1;
int rightIdx=2*idx+2;
int maxIdx=idx;//idx,leftIdx和rightIdx中最小值的下标
if(leftIdx<len && arr[maxIdx]<arr[leftIdx])
maxIdx=leftIdx;
if(rightIdx<len && arr[maxIdx]<arr[rightIdx])
maxIdx=rightIdx;
if(maxIdx!=idx)
{
int temp=arr[idx];
arr[idx]=arr[maxIdx];
arr[maxIdx]=temp;
idx=maxIdx;
}
else
return;
}
}
void BuildMaxHeap(int* arr, int len)
{
for(int i=len/2-1;i>=0;--i)
MaxHeapify_Recursively(arr,i,len);
}
void MaxHeapSort(int*arr, int len)
{
if(NULL==arr || len<=1)
return;
BuildMaxHeap(arr,len);
for(int i=len-1;i>=1;--i)
{
int temp=arr[0];
arr[0]=arr[i];
arr[i]=temp;
MaxHeapify_Recursively(arr,0,i);
}
}
3.交换排序
1)冒泡排序(稳定)
代码:
void BubbleSort(int *arr, int len)
{
if(NULL==arr || len<=1)
return;
bool isOrdered=true; //判断在一次冒泡过程时没有发生交换,即为已经排序好
for(int i=1;i<len-1;++i) //冒泡找到第i大的数
for(int j=0;j<len-i;++j)
{
if(arr[j+1]<arr[j])
{
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
isOrdered=false;
}
if(isOrdered)
break;
}
}
代码:(使用尾递归的随机化快排)
void Swap(int & a, int &b)
{
int temp=b;
b=a;
a=temp;
}
int Partition(int *arr, int start, int end)
{
int index=rand()%(end-start+1)+ start; //产生[start,end]之间的随机整数
Swap(arr[index],arr[end]);
int small=start-1;
for(index=start;index<end;++index)
{
if(arr[index]<arr[end])
{
++small;
if(small<index)
Swap(arr[small],arr[index]);
}
}
++small;
Swap(arr[small],arr[end]);
return small;
}
void TailQuickSort(int *arr,int length, int start, int end) //尾递归
{
if(NULL==arr || length<=1 || start<0 || end>=length)
return;
while(start<end)
{
int index=Partition(arr,start,end);
if((index-start)<(end-index))
{
TailQuickSort(arr,length, start,index-1);
start=index+1;
}
if((index-start)>=(end-index))
{
TailQuickSort(arr,length,index+1,end);
end=index-1;
}
}
}
4.归并排序(稳定)
代码:
void Merge(int* arr, int start, int end, int leftEnd)
{
int *pOrdered=new int[end-start+1];
int index=0;
int leftBegin=start;
int rightBegin=leftEnd+1;
while(leftBegin<=leftEnd && rightBegin<=end)
{
if(arr[leftBegin]<=arr[rightBegin])
pOrdered[index++]=arr[leftBegin++];
else
pOrdered[index++]=arr[rightBegin++];
}
while(leftBegin<=leftEnd)
pOrdered[index++]=arr[leftBegin++];
while(rightBegin<=end)
pOrdered[index++]=arr[rightBegin++];
for(int i=0;i<index;++i)
arr[start++]=pOrdered[i];
delete[] pOrdered;
pOrdered=NULL;
}
void MergeSort(int*arr, int len, int start, int end)
{
if(NULL==arr || len<=1 || start<0 || end>=len)
return;
if(start<end)
{
int leftEnd=(end+start)/2;
MergeSort(arr, len, start, leftEnd);
MergeSort(arr,len, leftEnd+1, end);
Merge(arr, start, end, leftEnd);
}
}
5.线性时间排序
1)计数排序(稳定)
数组中每个数都在[0,k]之间
代码:
void CountSort(int *arr ,int len, int k)
{
if(NULL==arr || len<=1 || k<0)
return;
int* countArr=new int[k+1];
int* sortedArr=new int[len];
for(int m=0;m<k+1;++m)
countArr[m]=0;
for(int i=0;i<len;++i)
++countArr[arr[i]];
for(int j=1;j<k+1;++j)
countArr[j]+=countArr[j-1];
for(int l=len-1;l>=0;--l)
{
sortedArr[countArr[arr[l]]-1]=arr[l]; //注意这里的下标 countArr[arr[l]]-1
--countArr[arr[l]];
}
for(int i=0;i<len;++i)
arr[i]=sortedArr[i];
delete[] countArr;
countArr=NULL;
delete[] sortedArr;
sortedArr=NULL;
}
2)基数排序
代码:
(以十进制为例,设每一位的排序基于计数排序的思想)
int MaxBits(int* arr, int len,int base) //辅助函数,求数据的最大位数
{
int nMaxBits = 1;
for(int i = 0; i<len; ++i)
{
while(arr[i] >= base)
{
base *= 10;
++nMaxBits;
}
}
return nMaxBits;
}
void RadixSort(int* arr, int len) //基数排序
{
if(NULL==arr || len<=1)
return;
int base=10;
int nMaxBits= MaxBits(arr,len,base);
int* countArr=new int[base+1];
int* sortedArr=new int[len];
int radix=1;
for(int i=0;i<nMaxBits;++i) //由低位到高位按照计数排序的思想排序
{
for(int m=0;m<base+1;++m)
countArr[m]=0;
for(int i=0;i<len;++i)
++countArr[(arr[i]/radix)%base];
for(int j=1;j<base+1;++j)
countArr[j]+=countArr[j-1];
for(int l=len-1;l>=0;--l)
{
int bitNum=(arr[l]/radix)%base;
sortedArr[countArr[bitNum]-1]=arr[l]; //注意这里的下标 countArr[bitNum]-1
--countArr[bitNum];
}
for(int i=0;i<len;++i)
arr[i]=sortedArr[i];
radix*=10;
}
delete[] countArr;
countArr=NULL;
delete[] sortedArr;
sortedArr=NULL;
}
3)桶排序
代码: