排序算法二冒泡排序和快排

冒泡排序想必大家都非常熟悉了，这里就直接贴代码了

void BubbleSort(int array[],int len)
{
assert(array && len>0 );

for(int i = 0; i < len-1; ++i)
{
int flag = 1;
for(int j = 0; j < len-1-i; ++j)
{
if(array[j] > array[j+1])
{
swap(array[j], array[j+1]);
flag = 0;
}
}

if(flag == 1)
break;
}
}

时间复杂度为O（N*N),最好的情况下：优化后正序有序为O(n),稳定的算法。

没有优化的与原始序列的状态无关，优化后与原始序列的状态有关

快排

挖坑法

双指针法

//paration版本一：挖坑法
int Paration(int array[], int left, int right)
{
int key = array[right];

while(left < right)
{
while((left < right)&&(array[left] <= key) )
{
left++;
}
swap(array[left], array[right]);

while((left < right) && (array[right] >= key))
{
right--;
}
swap(array[left], array[right]);
}
return left;
}

//paration版本二：双指针法
int Paration2(int array[], int left, int right)
{

int key = array[right];
int pcur = left;
int pre = pcur-1;

while(pcur <= right)
{
if((array[pcur] <= key) && (++pre != pcur) )
{
swap(array[pcur], array[pre]);
}
++pcur;
}
return pre;
}

void QuickSort(int array[], int left ,int right)
{
assert(array);

if(left < right)
{
int index = Paration2(array, left ,right);
QuickSort(array, left, index-1);
QuickSort(array, index+1, right);
}
}

非递归实现：

void QuickSort2(int array[], int left, int right)
{
stack<int> s;

s.push(right);
s.push(left);

while(!s.empty())
{
int left = s.top();
s.pop();
int right = s.top();
s.pop();

if(left < right) //防止下面插入index+1, inex-1越界。
{
int mid = (left+right)/2;
int index = Paration2(array, left, right);

s.push(right);
s.push(index+1);

s.push(index-1);
s.push(left);
}
}
}

优化：

1）三数取中法

2）当区间已经划分到很小的时候可以改用插入排序

3）尾递归减少递归次数

//三数取中法，防止取到极端数据
int Middle(int array[], int left, int mid, int right)
{
if(array[left] > array[right])
{
if(array[right] > array[mid])
return right;
else if(array[left] > array[mid])
return mid;
else
return left;
}
else
{
if(array[right] < array[mid])
return right;
else if(array[left] < array[mid])
return mid;
else
return left;
}
}

//paration版本二：双指针法
int Paration2(int array[], int left, int right)
{

int mid = (left+right)/2;
int pos = Middle(array, left, mid, right);
swap(array[pos], array[right]);

int key = array[right];
int pcur = left;
int pre = pcur-1;

while(pcur <= right)
{
if((array[pcur] <= key) && (++pre != pcur) )
{
swap(array[pcur], array[pre]);
}
++pcur;
}
return pre;
}

void InsertSort(int array[], int size)
{
for(int i = 1; i < size; ++i)
{
int temp = array[i];
int end = i-1;

while(end>=0 && array[end] > temp)
{
array[end+1] = array[end];
end--;
}
array[end+1] = temp;
}
}

void QuickSort(int array[], int left ,int right)
{
assert(array);

while(right-left > 5)  //使用尾部递归
{
int index = Paration2(array, left ,right);
QuickSort(array, left, index-1);
left = index+1;
}

if(right-left <= 5)  //当分成很小的区间时，插入排序效率更高。
{
InsertSort(array+left, right-left+1);
}
}

时间复杂度为O(n*lgn),最好情况为O(n*lgn),最坏情况O（n*n),因为递归空间复杂度O（lgn)

不稳定的算法

最坏的情况下：基本有序时，退化为冒泡排序，几乎要比较N*N次，故为O(N*N)

它的应用场景是大规模的数据排序

快速排序算法的实际执行性能依赖与切分是否均衡，当正好把数组从中间”切开”时，

快速排序的实际性能最好。

切分越不均衡快速排序的实际性能就越差，

最坏情况下（第一次选取的切分元素是数组里最小的，第二次的切分元素是第二小的…）

算法的时间复杂度会退化到O(n^2)。