前言
本文是以C语言来编写的程序，排序都为升序排序。前两种算法我接触的比较多，后面接触比较少，理解还不深入，以后再补充。本文是作者关于排序算法的一些粗陋见解，如有不正确的地方，欢迎指出。
一、选择法排序
选择法排序应该是大家最先接触的排序算法，它的主要逻辑对数组首先进行遍历，寻找最小那个元素，将这个元素和数组的0号位置元素交换；再在剩下的n-1个元素中寻找最小值，将找到的最小元素与1号元素交换；……一直循环到只剩一个元素，由于前面的n-1个元素已经排完序，所以最后一个一个还未排序的元素一定是最大值
#include <stdio.h>
#include <stdlib.h>
/*-------------------- 排序规则 --------------------
它的工作原理是每一次从待排序的数据元素中选出
最小（或最大）的一个元素，存放在序列的起始位
置，直到全部待排序的数据元素排完。
稳定性:选择排序是不稳定的排序方法 如:[5,5,3]
-------------------------------------------------*/
//选择排序(升序排序)
void selectionSort(int* array, int len)
{
int min = -1;//指向最小的元素的位置
//外层循环
for (int i = 0; i < len - 1; i++)
{
min = i;
for (int k = i + 1; k < len; k++)
{
if (array[min] > array[k])
{
min = k;
}
}
//判断是否需要交换
if (min != i)
{
//找到了新的最小值
//交换
int tmp = array[min];
array[min] = array[i];
array[i] = tmp;
}
}
}
#if 0
int main()
{
int i;
//定义整型数组
int array[] = { 12, 5, 33, 6, 10 };
//计算数组长度
int len = sizeof(array) / sizeof(int);
//遍历数组
printf("待排序数组序列: ");
for (i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
//排序
selectionSort(array, len);
//遍历
printf("选择排序之后的序列: ");
for (i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
system("pause");
return 0;
}
#endif // 0
二、冒泡排序
冒泡排序从0号元素开始，让其与下一元素比较大小，如果下一个元素小，则交换二者位置，一直比较到最后一个元素，就可以将最大元素交换到n-1号位置；在从0号位置开始比较，一直比到最后一个元素，就可以将第二大元素交换到n-2号位置……一直循环n次即可完成该排序。
我们首先发现，在第n-1次循环中，就将第n-1大的元素交换到1号位置，接下来不需要再去比较，因为剩下0号位置元素就是最小元素；其次，我们没必要每次都比较到最后一个元素，因为每进行一次循环，就已经从数组尾部排好一个元素。
#include <stdio.h>
#include <stdlib.h>
/********************* 排序规则 *********************
冒泡排序算法的运作如下：（从后往前）
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
稳定性:冒泡排序是一种稳定排序算法
***************************************************/
//冒泡排序(升序)
void bubbleSort(int* array, int len) //O(n²)
{
for (int i = 0; i < len - 1; i++)
{
//交换
for (int j = 1; j < len-i; j++)
{
if (array[j] < array[j - 1])
{
int tmp = array[j];
array[j] = array[j - 1];
array[j - 1] = tmp;
}
}
}
}
#if 0
void main()
{
int i;
//定义整型数组
int array[] = { 11, 8, 7, 6, 3 };
//计算数组长度
int len = sizeof(array) / sizeof(int);
//遍历数组
printf("待排序数组序列: ");
for (i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
//排序
bubbleSort(array, len);
//遍历
printf("冒泡排序之后的序列: ");
for (i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
system("pause");
}
#endif
三、插入排序
#include <stdio.h>
#include <stdlib.h>
/******************* 排序规则 *******************
每次处理就是将无序数列的第一个元素与有序数列
的元素从后往前逐个进行比较，找出插入位置，将
该元素插入到有序数列的合适位置中。
稳定性:插入排序是稳定的
***********************************************/
//插入排序算法(升序排列)
void insertionSort(int* array, int len)
{
int tmp = 0;//储存基准数
int index = 0;//坑的位置
//遍历无序序列
for (int i = 1; i < len; i++)
{
index = i;
tmp = array[i];
for (int j = i - 1; j >= 0; j--)
{
//基准数跟有序序列中的元素比较
if (tmp < array[j])
{
//有序序列元素后移
array[j + 1] = array[j];
//坑的位置
index = j;
}
else
{
break;
}
}
//填坑
array[index] = tmp;
}
}
#if 0
int main()
{
int i;
//定义整型数组
int array[] = { 12, 5, 33, 6, 10 };
//计算数组长度
int len = sizeof(array) / sizeof(int);
//遍历数组
printf("待排序数组序列: ");
for (int i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
//排序
insertionSort(array, len);
//遍历
printf("插入排序之后的序列: ");
for (i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
system("pause");
return 0;
}
#endif
四、快速排序
#include<stdio.h>
#include<stdlib.h>
#if 1
#define SWAP(x,y){int z;z=x;x=y;y=z;}
//快速排序 不稳定
int partition(int number[], int left, int right)
{
int i, j;
int tmp = number[left];
while (left < right)
{
while (number[right] > tmp)
{
right--;
}
while (number[left] < tmp)
{
left++;
}
SWAP(number[left], number[right]);
}
return left;
}
void quickSort(int s[], int left, int right)
{
int q;
if (left < right)
{
q = partition(s, left, right);
quickSort(s, left, q-1);
quickSort(s, q + 1, right);
}
}
#endif // 1
#if 0
int main()
{
int i;
//定义整型数组
int array[] = { 12, 5, 33, 6, 10 };
//计算数组长度
int len = sizeof(array) / sizeof(int);
//遍历数组
printf("待排序数组序列: ");
for (i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
//排序
quickSort(array, 0, len - 1);
//遍历
printf("快速排序之后的序列: ");
for (i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
system("pause");
return 0;
}
#endif
五、希尔排序
#include <stdio.h>
#include <stdlib.h>
/**************************** 排序规则 ****************************
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；
随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰
被分成一组，算法便终止。
稳定性: 希尔排序是非稳定排序算法。
*****************************************************************/
//希尔排序nlogn
void shellSort(int* array, int len)
{
//步长
int gap = len;
while (gap > 1)
{
//步长递减公式
gap = gap / 3 + 1;
//分组
for (int i = 0; i < gap; i++)
{
int tmp;//基准数
int index;//坑的位置
//插入排序
//无需序列
for (int j = i+gap; j < len; j+=gap)
{
tmp = array[j];
index = j;
//有序排序（从后往前遍历）
for (int k = j - gap; k >= 0; k -= gap)
{
if (array[k] > tmp)
{
//后移
array[k + gap] = array[k];
//位置
//位置
index = k;
}
else
{
break;
}
}
//填坑
array[index] = tmp;
}
}
}
}
#if 0
int main()
{
int i;
//定义整型数组
int array[] = { 12, 5, 33, 6, 10 };
//计算数组长度
int len = sizeof(array) / sizeof(int);
//遍历数组
printf("待排序数组序列: ");
for (int i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
//排序
shellSort(array, len);
//遍历
printf("希尔排序之后的序列: ");
for (i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
system("pause");
return 0;
}
#endif
六、归并排序
#include <stdio.h>
#include <stdlib.h>
//将两个有序数列a[first...mid]和a[mid+1...last]合并。
void mergeArray(int a[], int first, int mid, int last, int temp[])
{
int i = first;//第一个有序数组的起始下标
int j = mid + 1;//第二个有序数组的起始下表
int length = 0;//插入数据的个数，也就是下一次插入的位置
while (i <= mid && j <= last)
{
if (a[i] < a[j])
{
temp[length++] = a[i++];
}
else
{
temp[length++] = a[j++];
}
}
//将未插入的数组元素插入
while (i <= mid)
{
temp[length++] = a[i++];
}
while (j <= last)
{
temp[length++] = a[j++];
}
// 覆盖原来位置的无序序列
for (int k = 0; k < length; k++)
{
// 找到原来 的第一个有序序列的开始位置 - 开始覆盖
a[first + k] = temp[k];
}
}
//归并排序
void mergeSort(int a[], int first, int last, int temp[])
{
//递归结束条件
if (first >= last)
{
return;
}
//从中间拆分
int mid = (first + last) / 2;
// 拆分
// 左半边
mergeSort(a, first, mid, temp);
// 右半边
mergeSort(a, mid + 1, last, temp);
// 合并两个有序序列
mergeArray(a, first, mid, last, temp);
}
#if 1
int main()
{
int i;
//定义整型数组
int array[] = { 12, 5, 33, 6, 10 };
//计算数组长度
int len = sizeof(array) / sizeof(int);
//遍历数组
printf("待排序数组序列: ");
for (i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
//创建合适大小的临时数组
int* p = (int*)malloc(sizeof(int) * len);
if (p == NULL)
{
return -1;
}
mergeSort(array, 0, len - 1, p);
free(p);
//遍历
printf("归并排序之后的序列: ");
for (i = 0; i < len; ++i)
{
printf("%d\t", array[i]);
}
printf("\n");
system("pause");
return 0;
}
#endif
总结
625
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
