常用排序算法总结

最新推荐文章于 2022-03-21 17:12:12 发布

转载最新推荐文章于 2022-03-21 17:12:12 发布 · 117 阅读

文章标签：

#常用排序算法总结

java 专栏收录该内容

252 篇文章

订阅专栏

常用排序算法总结：选择法、冒泡法、直接插入法、希尔算法、快速算法、归并算法

2019年04月08日 10:52:26 意义丶阅读数：1622

本文总结了六种排序算法，分别是：选择法、冒泡法、直接插入法、希尔算法、快速算法、归并算法。

一、选择法排序：
/*

选择排序的基本思想是：每一趟在n-i+1（i=1，2，…n-1）个记录中选取关键字最小的记录作为有序序列中第i个记录。基于此思想的算法主要有简单选择排序、树型选择排序和堆排序。
*/

/*
第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换；
第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换；
以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，
使有序序列不断增长直到全部排序完毕。所以只会循环n-1次。
*/

template<class T>
void SelectSort(T *array, const int len)
{
//T temp = 0;
for (int i = 0; i < len - 1; i++)
{
int index_min = i;//假设待排序列中的第一个当做最小的，然后在待排序列中找到最小的
for (int j = i + 1; j < len; j++) //从第i个元素的后面一个元素开始找剩余的序列中最小的值的下标。
{
if (array[j] < array[index_min])
{
index_min = j;//找到新的最小的元素了
}
}
if (index_min != i)//若无序区第一个元素不是无序区中最小元素，则进行交换
{
array[index_min] = array[index_min] ^ array[i];
array[i] = array[index_min] ^ array[i];
array[index_min] = array[index_min] ^ array[i];
/*两种数据交换方式，第二种需要在前面定义一个缓存temp
//temp = array[index];
//array[index] = array[i];
//array[i] = temp;
*/
}
}
}

二、冒泡法排序：
/*

冒泡法排序与选择法类似，选择法是先找到最小值的下标，而冒泡法是找到一个小的（不一定是最小的）就交换。
*/

template<class T>
void BubbleSort(T *array, const int len)
{
for(int i = 0; i < len - 1; i++)
{
for(int j = i + 1; j < len; j++)
{
if(array[i] > array[j])
{
array[i] = array[i] ^ array[j];
array[j] = array[i] ^ array[j];
array[i] = array[i] ^ array[j];
}
}
}
}

三、直接插入法排序：
/*

在排序之前我们需要搞清一个思路，新插入一个数据的时候，排序过后的数组都是从小到大排列好的，所以我们需要从后往前查找，直到找到比我们要插入的数字还小的值。这个时候我们需要一个变量j作为标识
*/

template<class T>
void InsertSort(T * array, const int len)
{
T temp = 0;
for (int i = 1; i < len; i++)//还是n-1趟，只是这里从1开始，即第二个元素开始，前面的是有序的。
{
temp = array[i];//取出这个要和前面有序序列比较的元素。
int j = 0;
for (j = i - 1;j >= 0;j--)//这个元素的和前面有序序列比较，直到下标0
{
if (array[j] > temp)//将大于temp的数向后移动
{
array[j + 1] = array[j];
}
else
{
break;//不再比temp大了，就不移动了
}
}
//移动完，就插入元素
array[j + 1] = temp;//这里，因为j--，跳出循环时，j多减了一次
}
}

四、希尔排序算法：
/*

在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中
再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。
*/

template<class T>
void ShellSort(T *array, int len)
{
T temp;
int gap = len;////初始化划分增量
do
{
//业界统一实验的平均最好情况经过若干次后，收敛为1(跳出循环)
gap = gap / 3 + 1;
for (int i = gap; i < len; i += gap) //对每个划分进行直接插入法排序
{
temp = array[i];//找到当前这个元素
int j = 0;
for (j = i - gap; j >= 0; j -= gap)//这个元素的和前面有序序列比较，直到下标0
{
if (array[j] > temp)//将大于temp的数向后移动
{
array[j + gap] = array[j];
}
else
{
break;//不再比temp大了，就不移动了
}
}
//移动完，就插入元素
array[j + gap] = temp;//这里，因为j-gap，跳出循环时，j多减了一次gap
}
} while (gap > 1);
}

五、希尔排序算法：
/*

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
*/

template<class T>
void Quicksort(T *array, int low, int high)//high = len-1
{
if (low >= high)
{
return;//递归结束标志
}
int first = low;
int last = high;
int key = array[first];//用字表的第一个记录作为枢轴(区分小的分段和大的分段)
while (first < last)
{
while (first < last && array[last] >= key)
{
--last;
}
array[first] = array[last];/*将比key小的移到低端*/
while (first<last && array[first] <= key)
{
++first;
}
array[last] = array[first];/*将比key大的移到高端*/
}
array[first] = key;//重新确定枢轴的值，这里的first = last；(一定相等)//前面的枢轴值被覆盖了。
Quicksort(array, low, first - 1);//对左边的数据段排序
Quicksort(array, first + 1, high);//对右边的数据段排序
}

六、归并排序算法：
/*

归并排序法（Merge Sort，以下简称MS）是分治法思想运用的一个典范。其主要算法操作可以分为以下步骤：
Step 1：将n个元素分成两个含n/2元素的子序列
Step 2：用MS将两个子序列递归排序（最后可以将整个原序列分解成n个子序列）
Step 3：合并两个已排序好的序列（合并是该算法的核心）
*/