常用排序算法总结

#include<iostream>
using namespace std;

//show array
void show(int *ar, int len)
{
for(int i=0; i<len; ++i)
{
cout<<ar[i]<<" ";
}
cout<<endl;
}
//bubbleSort
//冒泡排序是一种稳定的排序算法
//最好时间复杂度为O(n)平均时间复杂度为O(n^2)最坏时间复杂度为O(n^2)
//空间复杂度为O(1)
void bubbleSort(int *ar, int len)
{
bool flag = true;//使用标记可以是有序序列排序时间复杂度为O(n)
for(int i=0; i<len-1&&flag; ++i)
{
for(int j=0; j<len-1-i; ++j)
{
flag = false;
if(ar[j] > ar[j+1])
{
ar[j] ^= ar[j+1];
ar[j+1] ^= ar[j];
ar[j] ^= ar[j+1];
flag = true;
}
}
}
}

//selectSort
//直接选择排序不稳定 最好最坏平均时间复杂度都是O(n^2) 空间复杂度O(1)
void selectSort(int *ar, int len)
{
for(int i=0; i<len-1; ++i)
{
//假设第i个元素最小,以此类推
int min = i;
for(int j=i+1; j<len; ++j)
{
if(ar[j] < ar[min])
{
min = j;
}
}

//如果第i个不是最小,把最小的交换到第一个 以此类推
if(i != min)
{
ar[i] ^= ar[min];
ar[min] ^= ar[i];
ar[i] ^= ar[min];
}
}
}

//insertSort
//直接插入排序为稳定排序
//最好时间复杂度O(n) 最坏时间复杂度O(n^2) 平均时间复杂度O(n^2)
//直接插入排序的特点是待排序数组越有序速度越快
//空间复杂度为O(1)
void insertSort(int *ar, int len)
{
for(int i=1; i<len; ++i)
{
int temp = ar[i];

//从后向前比较(有序数组可以保证时间复杂度为O(n)) 在合适的位置插入
int j = i-1;
for(j; j>=0; --j)
{
if(ar[j] > temp)
{
ar[j+1] = ar[j];
}
else
{
break;
}
}

ar[j+1] = temp;
}
}

//shellSort
void shell(int *ar, int len, int size)
{
for(int i=size; i<len; ++i)
{
int temp = ar[i];
int j = i-size;
for(j; j>=0; j-=size)
{
if(ar[j] > temp)
{
ar[j+size] = ar[j];
}
else
{
break;
}
}
ar[j+size] = temp;
}
}
void shellSort(int *ar, int len)
{
int d[] = {5,3,1};//size
for(int i=0; i<sizeof(d)/sizeof(d[0]); ++i)
{
shell(ar, len, d[i]);
}
}

//quickSort(recursion)
int partition(int *ar, int low, int high)
{
int temp = ar[low];

while(low < high)
{
while(low<high && ar[high] >= temp)
{
--high;
}
if(low == high)
{
break;
}
else
{
ar[low] = ar[high];
}

while(low<high && ar[low] <= temp)
{
++low;
}
if(low == high)
{
break;
}
else
{
ar[high] = ar[low];
}
}

ar[low] = temp;
return low;
}
void quick(int *ar, int low, int high)
{
int par = partition(ar, low, high);

if(par > low+1)
{
quick(ar, low, par-1);
}
if(par < high-1)
{
quick(ar, par+1, high);
}
}
void quickSort(int *ar, int len)
{
quick(ar, 0, len-1);
}

//quickSort2(norecursion)
void quickSort2(int *ar, int len)
{
int *stack = new (nothrow) int[len];
int top = 0;
int low = 0;
int high = len-1;

stack[top++] = low;
stack[top++] = high;
do
{
high = stack[--top];
low = stack[--top];
int par = partition(ar, low, high);
if(par > low+1)
{
stack[top++] = low;
stack[top++] = par-1;
}
if(par < high-1)
{
stack[top++] = par+1;
stack[top++] = high;
}
}while(top > 0);

delete []stack;
}

//mergeSort(recursion)
void sort(int *ar, int low, int mid, int high)
{
int i = low, j = mid+1, k = 0;
int *temp = new (nothrow) int[high-low+1];

while(i<=mid && j<=high)
{
if(ar[i] < ar[j])
{
temp[k++] = ar[i++];
}
else
{
temp[k++] = ar[j++];
}
}

while(i<=mid)
{
temp[k++] = ar[i++];
}
while(j<=high)
{
temp[k++] = ar[j++];
}

for(int i=low, k=0; i<=high; ++i, ++k)
{
ar[i] = temp[k];
}
delete []temp;
}
void merge(int *ar, int low,  int high)
{
if(low < high)
{
int mid = (low+high)/2;
merge(ar, low, mid);
merge(ar, mid+1, high);
sort(ar, low, mid, high);
}
}
void mergeSort(int *ar, int len)
{
merge(ar, 0, len-1);
}

//mergeSort2(norecursion)
void mergeSort2(int *ar, int len)
{
int size = 1, low, mid, high;

while(size < len-1)
{
low = 0;
while( low+size < len)//low+size-1 < len-1
{
mid = low+size-1;
high = mid+size;
if(high > len-1)
{
high = len-1;
}
sort(ar, low, mid, high);
low = high+1;
}
size *= 2;
}
}
//堆排序为不稳定排序 时间复杂度为O(nlog2n) 空间复杂度为O(1)
void adjustFromUp(int *ar, int start, int end)//调整最大堆 end下标可取
{
int i=start, j=2*i+1;//记录双亲结点和孩子结点
int temp = ar[i];

while(j<=end)
{
if(j+1<=end && ar[j+1]>ar[j])//在不越界的情况下,j为值最大的孩子结点
{
++j;
}
if(temp >= ar[j])//start结点比孩子结点大
{
break;
}
ar[i] = ar[j];//将大的孩子结点赋值个双亲结点
//调整下标
i = j;
j = 2*i+1;
}
ar[i] = temp;
}
void makeMaxHeap(int *ar, int len)//建立最大堆
{
for(int i=(len-1)/2; i>=0;--i)
{
adjustFromUp(ar, i, len-1);//扩大的调整范围
}
}
void heapSort(int *ar, int len)
{
//建立最大堆
makeMaxHeap(ar,len);
for(int i=0;i<len-1; ++i)
{
//将最大的元素和最后一个元素交换
int temp = ar[0];
ar[0] = ar[len-i-1];
ar[len-i-1] = temp;
adjustFromUp(ar, 0, (len-1-i)-1); //len-1-i保证下标可取, 再减1表示最后一个元素已经有序,不需要再调整
}
}

int main(void)
{
int ia[] = {45,56,78,9,23,45,12,99,82,65,3000,};
int len =sizeof(ia)/sizeof(ia[0]);
//heapSort(ia, len);

//bubbleSort(ia, len);
//selectSort(ia, len);
//insertSort(ia, len);
//shellSort(ia, len);
quickSort(ia, len);
//quickSort2(ia, len);
//mergeSort(ia, len);
//mergeSort2(ia, len);
show(ia, len);

return 0;
}