几种常用排序算法的实现

声明

选择排序

#include <stdlib.h>
#include <stdio.h>

/*
* 选择排序法
* 从i=0遍历到i=size-1，
* 每次从[i, size)这些位置上筛选出最小的值，赋值给第i个元素
* 每次选择一个最小值，
* 选择size -1 次，即可确定完整的顺序
*/
void sort_select(int Arr[],int A_size)
{
int tmp;
for(int i = 0;i<A_size -1 ;i++)
{
for(int j = i+1 ;j<A_size ;j++)
{
if(Arr[i] >Arr[j])
{
tmp = Arr[i];
Arr[i] = Arr[j];
Arr[j] = tmp;
}
}
}
}

int main_selectsort()
{
int a[8] = {50, 10, 20, 30, 70, 40, 80, 60};
int i;
sort_select(a, 8);
for(i=0; i<8; i++)
printf("%d ", a[i]);
printf("\n");
return 0;
}

冒泡排序

#include <stdlib.h>
#include <stdio.h>
//冒泡排序
/*
* 从0到size-1遍历
* 每次比较两个相邻元素(arr[i], arr[i+1])，如果逆序，则交换他们
* 那么，在每次遍历结束后，遍历区域后面的第一个元素则是排好序的，
* 经历size-1次遍历后，全部有序。比较相邻元素需要从0到size-1-i范围去比。
* 因为此后的元素已经通过前面的冒泡排好序了
*
*/
void sort_maopao(int Arr[],int A_size)
{
int tmp;
for(int i = 0;i< A_size - 1 ;i++)
{
for(int j = 0 ;j< A_size - 1 - i;j++)
{
if(Arr[j] >Arr[j + 1])
{
tmp = Arr[j+1];
Arr[j+1] = Arr[j];
Arr[j] = tmp;
}
}
}
}

int main_bubblesort()
{
int a[8] = {50, 10, 20, 30, 70, 40, 80, 60};
int i;
sort_maopao(a, 8);
for(i=0; i<8; i++)
printf("%d ", a[i]);
printf("\n");
return 0;
}

插入排序

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

/*
* 插入排序，
* 创建一个临时数组，依次从原数组中挨个元素往临时数组中插入新的元素
* 保证插入新元素后，临时数组仍然有序
* 当所有元素都插入到临时数组后，即完成排序，再将结果从临时数组中拷回来即可
* 关键点在于：插入数据到临时数组时，需要寻找一个合适的位置来保证插入后临时数组仍然有序
*/
void sort_insert(int Arr[],int A_size)
{
int *tmpArr = (int*)malloc(sizeof(int)*A_size);
memset(tmpArr,0,sizeof(int)*A_size);
tmpArr[0] = Arr[0];
int idx;
for(int i=1;i<A_size;i++)
{
// 默认位置为临时数组的末尾
idx = i;
//寻找一个合适的位置插入新元素，要先将后面的元素移至合适的位置
while(idx > 0 && tmpArr[idx - 1] > Arr[i]) {
tmpArr[idx] = tmpArr[idx-1];
idx--;
}
tmpArr[idx] = Arr[i];
}
//拷贝回原数组
for(int j=0;j<A_size;j++)
Arr[j] = tmpArr[j];
free(tmpArr);
}

int main_insertsort()
{
int a[8] = {50, 10, 20, 30, 70, 40, 80, 60};
int i;
sort_insert(a, 8);
for(i=0; i<8; i++)
printf("%d ", a[i]);
printf("\n");
return 0;
}

归并排序

#include <stdlib.h>
#include <stdio.h>

void Merge(int sourceArr[],int tempArr[], int startIndex, int midIndex, int endIndex)
{
int i = startIndex, j=midIndex+1, k = startIndex;
while(i!=midIndex+1 && j!=endIndex+1)
{
if(sourceArr[i] > sourceArr[j])
tempArr[k++] = sourceArr[j++];
else
tempArr[k++] = sourceArr[i++];
}
while(i != midIndex+1)
tempArr[k++] = sourceArr[i++];
while(j != endIndex+1)
tempArr[k++] = sourceArr[j++];
for(i=startIndex; i<=endIndex; i++)
sourceArr[i] = tempArr[i];
}

//内部使用递归
/*
* MergeSort 归并排序
* 思路：1. 将一个无序序列分解成2个子序列，每个子序列内部有序。2. 将两个有序子序列合并到一块临时空间，合并后有序。
* 实现过程：
*   1. 开辟一块缓存，将来存储合并的结果；
*   2. 以数组中心位置为分界线，将待排数组分成2个小的数组
*   3. 递归分解数组，直到每个小数组中只有1个元素
*   4. 合并2个内部有序的小数组，使合并后的数组有序
*   5. 递归调用2-3-4结束后，序列即已完成排序，排序结果存储在缓存的数组中
*   6. 再将缓存的数据拷回原始序列，原始序列完成排序
*/

void MergeSort(int sourceArr[], int tempArr[], int startIndex, int endIndex)
{
int midIndex;
if(startIndex < endIndex)
{
midIndex = (startIndex + endIndex) / 2;
MergeSort(sourceArr, tempArr, startIndex, midIndex);
MergeSort(sourceArr, tempArr, midIndex+1, endIndex);
Merge(sourceArr, tempArr, startIndex, midIndex, endIndex);
}
}

int main_mergesort()
{
int a[8] = {50, 10, 20, 30, 70, 40, 80, 60};
int i, b[8];
MergeSort(a, b, 0, 7);
for(i=0; i<8; i++)
printf("%d ", a[i]);
printf("\n");
return 0;
}

快速排序

#include <stdlib.h>
#include <stdio.h>

//快速排序
/*
* 该方法的基本思想是：
* 1．先从数列中取出一个数作为基准数。
* 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
* 3．再对左右区间重复第二步，直到各区间只有一个数。
*/
void quick_sort(int s[], int l, int r)
{
if (l < r)
{
//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
int i = l, j = r, x = s[l];
while (i < j)
{
while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
j--;
if(i < j)
s[i++] = s[j];

while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
i++;
if(i < j)
s[j--] = s[i];
}
s[i] = x;
quick_sort(s, l, i - 1); // 递归调用
quick_sort(s, i + 1, r);
}
}

int main_quicksort()
{
int a[8] = {50, 10, 20, 30, 70, 40, 80, 60};
int i;
quick_sort(a, 0, 7);
for(i=0; i<8; i++)
printf("%d ", a[i]);
printf("\n");
return 0;
}