排序-算法总结

最新推荐文章于 2020-06-24 20:55:56 发布

MOKA

最新推荐文章于 2020-06-24 20:55:56 发布

阅读量321

点赞数

分类专栏：算法

算法专栏收录该内容

34 篇文章 0 订阅

订阅专栏

==============================
冒泡排序算法
==============================
1.算法稳定性
稳定

2.复杂度
空间复杂度O(1); 平均时间复杂度O(n2)

3.极限情况分析
最好情况：向量本来就是有序的，则一趟扫描即可结束，共比较n-1次，无交换。
最坏情况：向量是逆序的，则一共需要做n-1次扫描，每次扫描都必须比较n-i次，由等差数列求和公式知道，一共需做n(n-1)/2次比较和交换。

4.算法实现

<pre class="cpp" name="code">template<typename T>
void bubble_sort(T * array, const int size)
{
if(size < 2 || array == NULL)
{
cout << "illegal input!" << endl;
return;
}

bool exchanged = false;
T tmp;

for(int i=0; i<size-1; ++i)
{
exchanged = false;

for(int j=size-1; j>i; --j)
{
 if(array[j] < array[j-1])
 {
 tmp = array[j];
 array[j] = array[j-1];
 array[j-1] = tmp;
 exchanged = true;
 }
}

if(!exchanged)
{
 return;
}
}
}
</pre>
<pre></pre>
5. 算法改进 
(1) 奇偶交换排序 
 稳定性？稳定 //TODO need verifying 
 空间复杂度O(1), 时间复杂度O(n2) 
 极限情况分析：正向有序：n-1次比较；逆向有序((n+1)/2)*n+(n/2-1)次比较 
 综合而言，性能和冒泡排序相当，所以一般不用此种排序方法。 
 算法实现：
<pre class="cpp" name="code">template<typename T>
void oe_sort(T * array, const int size)
{
if(size < 2 || array == NULL)
{
cout << "illegal input!" << endl;
return;
}

T tmp;
bool exchanged = true;
while(exchanged)
{
exchanged = false;

//scan odd index
for(int i=1; i<size-1; i+=2)
{
 if(array[i] > array[i+1])
 {
 tmp = array[i];
 array[i] = array[i+1];
 array[i+1] = tmp;
 exchanged = true;
 }
}

//scan even index
for(int j=0; j<size-1; j+=2)
{
 if(array[j] > array[j+1])
 {
 tmp = array[j];
 array[j] = array[j+1];
 array[j+1] = tmp;
 exchanged = true;
 }
}
}
}
</pre>
 
 
 
(2) 每次扫描记住最后一次扫描发生的位置lastExchange 
 如此一样，下一趟排序时区间[0, lastExchange-1]是有序区, [lastExchange, size-1]是无序区。如果不记录，则下一趟排序时区间[0, i]有序区间，i为上次排序的趟数。自然的，lastExchange的最小可能数值就是i，所以此种改性是有效的。 
 算法性能和普通冒泡一样。 
 算法实现： //TODO 
 
(3) 改进冒泡算法的不对称性 
 什么是不对称性？比如上面的冒泡排序算法，如果数组中的最大值位于a[0]，理论上一遍扫描就可以完成排序，但实际仍旧需要n-1遍扫描。而如果改冒泡为沉底，则一遍即可。 
 所以引出了解决不对称性的方法：冒泡和沉底交替进行。 
 算法性能和普通冒泡一样。 
 算法实现： //TODO 
 
 
========================== 
快速排序算法 
========================== 
1. 基本思想 
 分治法：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
2. 算法描述 
 核心是：选取哨兵结点，划分区域，并找到哨兵结点所在的位置。 
 (1) 选取一个哨兵结点，通常取首结点，或者末结点，或者中间结点。但最合理的应该是随机选择一个结点。 
 (2) 根据哨兵结点，将原数组划分为左右2个部分，并决定哨兵结点的位置。 
 (3) 分别对左右部分递归地进行(1)和(2)，递归结束条件是分出的子数组长度小于等于1
3. 算法稳定性 
 不稳定
4. 复杂度 
 平均空间复杂度是O(lgn), 注意是以2为底的对数。 
 平均时间复杂度是O(nlgn)。
5. 极限情况分析 
 最好情况下，空间复杂度是O(lgn), 时间复杂度是O(nlgn)。此处的空间复杂度主要是递归产生的栈空间。 
 最坏情况下，空间复杂度是O(n), 时间复杂度是O{n2}。最坏情况是每次哨兵结点都是整个数组的最大值，或者最小值。 
 
6. 算法实现 

<pre class="cpp" name="code">template<typename T>
int partition(T * array, const int low, const int high)
{
//select the first elem as pivot. Here use random index for pivot will be better
T pivot = array[low];
for(int i=low, j=high; i<j;)
{
//scan for the first elem that smaller than pivot
while(j>i && array[j]>=pivot)
 j--;
if(i<j)
{
 //since array[i] is already be array[j] which is smaller than pivot, array[i+1] will firstly checkde in next scan
 array[i++] = array[j];
}

//scan for the first elem that bigger than pivot
while(i<j && array[i]<=pivot)
i++;
if(i<j)
{
 array[j--] = array[i];
}
}

//put the pivot to right position, pls notice that i will be equal with j at this point
array[i] = pivot;

return i;
}

template<typename T>
quick_sort(T * array, const int low, const int high)
{
int pivotPos = 0;

if(low < high)
{
//the most important is locating index for pivot, then partition will be possible
pivotPos = partition(array, low, high);
quick_sort(array, low, pivotPos-1);
quick_sort(array, pivotPos+1, high);
}
}
</pre>
注意：冒泡排序和快速排序均属于交换排序算法。
 
======================== 
直接插入排序算法 
======================== 
1.算法稳定性 
 稳定 
 
2.复杂度 
空间复杂度O(1); 时间复杂度O(n2) 
 
3.极限情况分析 
最好情况：向量是正序的，共比较关键字n-1次，无交换。 
最坏情况：向量是逆序的，则一共比较关键字│(n+2)(n-1)/2次，记录移动次数n-1)(n+4)/2次 
 
4. 算法实现 

<pre class="cpp" name="code">template<typename T>
void insert_sort(T * array, const int size)
{
if(size < 2 || array == NULL)
{
cout << "illegal input!" << endl;
return;
}

T pivot;

for(int i=1; i<size; ++i)
{
if(array[i] >= array[i-1])
{
 continue;
}

pivot = array[i];
int j = i-1;
do
{
 array[j+1] = array[j];
 --j;
}while(pivot < array[j] && j>=0);

array[j+1] = pivot;
}
}
</pre>
 
======================== 
希尔排序算法 
======================== 
1.算法稳定性 
不稳定 
 
2.算法描述 
(1)直接插入排序的变体，取一个小于数组长度n的整数d作为初始增量，将整个数组分为d个小组。 
比如说整个数组的长度为7，选择初始增量d为5, 则a[0], a[5]为第一组。a[1]和a[6]为第二组，a[2]和a[7]为第三组，a[3]为第四组，a[4]为第五组 
然后在每个小组内进行直接插入排序。 
(2)按照一定的减少d, 比如说第二次改变为3，再次进行上述的(1)和(2)。直到d减少到为1，并最后一次执行直接排序为止。 
 
3.复杂度 
空间复杂度O(1); 时间复杂度O(n(lgn)2) 译为n乘以lgn的平方。其复杂度收到增量递减方式的影响。最好的步长序列由Marcin Ciura设计为{1, 4, 10, 23, 57, 132, 301, 701, 1750, ...} 
 
4.极限情况分析 
最好情况：向量是正序的，共比较关键字n-1次，无交换。 
最坏情况：向量是逆序的，则一共比较关键字│(n+2)(n-1)/2次，记录移动次数n-1)(n+4)/2次 
 
5.算法实现
<pre class="cpp" name="code">template<typename T>
void shellInteration(T * array, const int size, const int increment)
{
T pivot;

for(int i=increment; i<size; ++i) //此算法中，将所有的increment改成1，就退化成了直接插入排序算法
{
if(array[i] >= array[i-increment])
{
 continue;
}

pivot = array[i];
int j = i-increment;
do
{
 array[j+increment] = array[j];
 j -= increment;
}while(pivot < array[j] && j>=0);

array[j+increment] = pivot;
}
}

template<typename T>
void shellSort(T * array, const int size)
{
if(size < 2 || array == NULL)
{
cout << "illegal input!" << endl;
return;
}

int increaArray[3] = {5, 3, 1}; //增量序列，必须以1结束

for(int i=0; i<sizeof(increaArray)/sizeof(int); ++i)
{
shellInteration(array, size, increaArray[i]);
}
}
</pre>
 
注意：直接插入排序和希尔排序都是插入排序。
 
======================== 
直接选择排序算法 
======================== 
1. 基本思想 
 进行n-1次扫描，每次从无序区中选择关键字最小的记录，并移动到有序区中。
2. 算法稳定性 
 不稳定
3. 复杂度 
 平均空间复杂度是O(l)。 
 平均时间复杂度是O(n2)。
4. 极限情况分析 
 最好情况下，空间复杂度是O(1), 时间复杂度是O(n2)。此处的空间复杂度，即便在正向有序的情况下，第i趟都需要比较关键字n-i次。 
 最坏情况下，空间复杂度是O(1), 时间复杂度是O{n2}。
5. 算法实现
<pre class="cpp" name="code">template<typename T>
void select_sort(T * array, const int size)
{
if(size < 2 || array == NULL)
{
cout << "illegal input!" << endl;
return;
}

//pivotIndex index to monitor the smallest elem in every scan
int pivotIndex = 0;

for(int i=0; i<size; ++i)
{
pivotIndex = i;
for(int j=i+1; j<size; ++j)
{
 if(array[j] < array[pivotIndex])
 pivotIndex=j;
}

if(pivotIndex!=i)
{
 T tmp = array[pivotIndex];
 array[pivotIndex] = array[i];
 array[i] = tmp;
}
}
}
</pre>
 
======================== 
堆排序算法 
======================== 
1. 基本思想 
 在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系，在当前无序区中选择关键字最大(或最小)的记录。
2. 算法稳定性 
 不稳定
3. 复杂度 
 平均空间复杂度是O(l)。 
 平均时间复杂度是O(nlogn)。
4. 极限情况分析 
 最坏情况下，时间复杂度是O(nlogn)。
5. 算法实现
<pre class="cpp" name="code">template<typename T>
void heapAdjust(T * array, const int startIndex, const int length)
{
//注意此函数的功能不是建立大根堆，只是做有限的调整

int pivotIndex = startIndex;

while(2*pivotIndex+1 < length)
{
int lChildIndex = 2*pivotIndex+1, rChildIndex = 2*pivotIndex+2;

//取得左右孩子中较大值的下标
int maxChildIndex = lChildIndex;
if(rChildIndex < length)
{
 maxChildIndex = array[lChildIndex]<array[rChildIndex]?rChildIndex:lChildIndex;
}

//如果孩子结点的值大于父亲结点的值，则交换2个结点值
if(array[maxChildIndex] > array[pivotIndex])
{
 T tmp = array[pivotIndex];
 array[pivotIndex] = array[maxChildIndex];
 array[maxChildIndex] = tmp;

 //交换后，子堆被破坏，继续调整子堆
 pivotIndex = maxChildIndex;
}
else
{
 break; //如果已经符合了大根堆的规则，则直接退出
}
}
}

template<typename T>
void heap_sort(T * array, const int size)
{
if(size < 2 || array == NULL)
{
cout << "illegal input!" << endl;
return;
}

//第一步，把数组看成是完全二叉树的层次遍历存储，并将整个数组建成一个大根二叉堆
//size/2-1所标记的结点，完全二叉树的最后一个叶子结点的父结点
for(int i=size/2-1; i>=0; --i)
{
heapAdjust(array, i, size);

//test
//printResult(cout, array, 10);
}

//经过第一步后，array[0]存储的是此数组中最大值，将array[0]和array[size-1]交换，这样无序区就变成了
//array[0, size-2],再对无序区进行大根堆的调整。
//这里需要注意一点：array[0, size-2]成为不符合大根堆原则的区间，仅仅因为调整后的根结点array[0]位置不对，
//所以只需要将array[0]“下沉交换”到合适的层次，使得整个区间再次成为大根堆时，array[0]变再次成为子区间中的最大值。依次类推。
for(int j=size-1; j>0; --j)
{
T tmp = array[0];
array[0] = array[j];
array[j] = tmp;
heapAdjust(array, 0, j); //TODO: I suspect that it should be j-1 here
}
}
</pre>
 
注意：直接选择排序和堆排序都属于选择排序的范畴。
 
======================== 
箱排序算法 
======================== 
1. 基本思想 
 箱排序也称桶排序(Bucket Sort)，其基本思想是：设置若干个箱子，依次扫描待排序的记录R[0]，R[1]，…，R[n-1]，把关键字等于k的记录全都装入到第k个箱子里(分配)，然后按序号依次将各非空的箱子首尾连接起来(收集)。
2. 算法稳定性 
 如果保证元素入箱和出箱时都遵守FIFO，则箱排序是稳定的。 
 
3. 复杂度 
 平均空间复杂度是O(n)。 
 平均时间复杂度是O(m+n)。其中，m是箱子的个数。如果箱子个数的数量级是O{n}，则时间复杂度是O{n} 
 
4. 极限情况分析 
 最坏情况下，时间复杂度是o{n2}。比如说一个有10个元素的数组排序，元素的取值范围是1-100, 用100个箱子进行排序，此时m=n2=100, 时间复杂度也变成了O(n2).
5. 算法实现 
//TODO
 
======================== 
基数排序算法 
======================== 
1. 基本思想 
 定义比较抽象，以十进制的整数数组为例说明。一个十进制整数的每一位的取值范围是0-9，可能的取值个数是10，这个可能的取值个数成为基数。 
再比如是英文小写字符数组，则取值范围是'a'到'z'，一共26个可能的取值，基数则为26。 
首先设置基数个箱子，比如整数数组排序，则设置10个箱子，序号从0到9。然后从低位到高位对每个元素进行箱排序。排序所需要进行的趟数，是最大的元素位数。比如说一个整数数组，最大元素是1000，其它元素都小于1000，则需要进行4趟扫描。
2. 算法稳定性 
 要保证基数排序的正确性，必须保证除开第一趟外的每趟箱排序是稳定的。这点保证了基数排序本身也是稳定的。 
 
3. 复杂度 
 平均时间复杂度 O{n} 
 平均空间复杂度 O(n+基数)
4. 算法实现 
 //TODO 

 
======================== 
归并排序算法 
======================== 
1. 基本思想 
 算法导论上第一章中谈分治法时的例子，基于二路归并操作(对2个有序数组进行合并，形成新的有序序列)。首先将整个数组不断二分直至只有一个元素(已然有序)，然后对子数组进行二路归并操作，最后合并操作结果。
2. 算法的稳定性 
 是稳定的。
3. 复杂度 
 平均时间复杂度 O{nlgn}, 空间复杂度O{n}。就时间复杂度为言，和快速排序一样，但快速排序是就地排序。 
 
4. 算法实现
<pre class="cpp" name="code">//merge [left, middle] and [middle+1, right], then copy back to array
template<typename T>
void mergeAndCopy(T * array, const int left, int middle, int right)
{
T * buff = new T[right-left+1];

//merge two part of array
 int i=left, j=middle+1;
int buff_index=0;
while(i<=middle && j<=right)
{
buff[buff_index++] = array[i]<=array[j]?array[i++]:array[j++];
}

//merge the rest part
while(i<=middle)
{
buff[buff_index++] = array[i++];
}
while(j<=right)
{
buff[buff_index++] = array[j++];
}

//copy buff data back to original array
for(int k=left, index=0; k<=right; ++k, ++index)
{
array[k] = buff[index];
}
}

template<typename T>
void mergeSort(T * array, const int left, const int right)
{
if(NULL == array)
{
cout << "illegal input" << endl;
return;
}

if(left < right)
{
int middle = (left + right)/2;
mergeSort(array, left, middle);
mergeSort(array, middle+1, right);
mergeAndCopy(array,left,middle,right);
}
}
</pre>

MOKA

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
排序-算法总结

==============================冒泡排序算法==============================1.算法稳定性稳定2.复杂度空间复杂度O(1); 平均时间复杂度O(n2)3.极限情况分析最好情况：向量本来就是有序的，则一趟扫描即可结束，共比较n-1次，无交换。最坏情况：向量是逆序的，则一共需要做n-1
复制链接

扫一扫

专栏目录