常见排序算法总结

最新推荐文章于 2024-12-14 18:08:54 发布

一小闷棍666

最新推荐文章于 2024-12-14 18:08:54 发布

阅读量177

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/crusierLiu/article/details/88637215

该博客展示了多种排序算法的代码实现，包括选择排序、冒泡排序、插入排序、希尔排序、快速排序、归并排序和堆排序等。给出了算法的函数定义和具体实现代码，还包含一个测试程序，对数组进行排序并输出结果，体现了不同排序算法的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Algorithm.h

#include <stdio.h>

//堆管理结构体
typedef struct heap_t{
int *array; //堆的数组

int arrlength; //数组的长度
}heap;

//选择排序算法
int* ChooseSort(int *sp,int len);
//遍历数组
void PrintSort(int *sp,int len);
//冒泡排序算法1
int * BubbleSort(int *sp, int len);
//冒泡排序算法2
int *BubbleSort2(int *sp, int len);
//插入排序算法
int * InsertSort(int *sp, int len);
//希尔排序算法
int *ShellSort(int *sp, int len);
//快速排序算法
int *QuickSort(int *sp, int begin, int end);
//归并排序算法
void MergeSort(int *a, int first, int last, int *temp);
//合并两个数组
void MergeArray(int *a, int first, int mid, int last, int *temp);

//堆排序算法
void heapsort(heap *a, int *array, int arrlen);
//构建最大堆
void max_heapfiy(heap *sp, int i);
//构建堆
heap* built_min_heap(int *array, int arrlen, heap *sp);
//交换两个元素
void swap(int *a, int *b);

Algorithm.c

#include "Algorithmnprac.h"

//选择排序算法
int * ChooseSort(int *sp,int len)
{
   int min = 0;
   for (int i = 0; i < len-1; i++)
   {
       min = i;
       for (int j = i + 1; j < len; j++)
       {
           if (sp[min] <sp[j])
               //保留最小的位置
               min = j;
       }
           if (min != i)
           {
               int temp = sp[min];
               sp[min] = sp[i];
               sp[i] = temp;
           }
   }

return sp;
}

//打印数组排序结果
void PrintSort(int *sp,int len)
{
for (int i = 0; i < len; i++)
printf("%d ", sp[i]);
}

//冒泡排序算法1
int* BubbleSort(int *sp, int len)
{
   //外层循环，代表每个元素
   for (int i = 0; i < len; i++)
   {
       for (int j = 1; j < len - i; j++)
       {
           if (sp[j] < sp[j - 1])
           {
               int tmp = sp[j - 1];
               sp[j - 1] = sp[j];
               sp[j] = tmp;
           }
       }
   }
   return sp;
}

int *BubbleSort2(int *sp, int len)
{
   //外层循环
   for (int i = len - 1; i >= 0; i--)
   {
       //内层循环
       for (int j = 0; j < i + 1; j++)
       {
           if (sp[j] < sp[j + 1])
           {
               //交换
               int temp = sp[j + 1];
               sp[j + 1] = sp[j];
               sp[j] = temp;
           }
       }
   }

return sp;
}

//插入排序算法
int * InsertSort(int *sp, int len)
{
   //遍历数组元素
   for (int i = 1; i < len; i++)
   {
       int index = i;
       int temp = sp[i];
       for (int j = i - 1; j >= 0; j--)
       {
           if (temp < sp[j])
           {
               sp[j + 1] = sp[j];
               index = j;
           }
       }
       sp[index] = temp;
   }

return sp;
}

//希尔排序算法
int *ShellSort(int *sp, int len)
{
   //外层循环控制gap递减
   int gap = len;
   while (gap > 1)
   {
       gap = gap / 3 + 1;
       //控制每组gap的循环次数
       for (int i = 0; i < gap; i++)
       {
           //对每组gap的第一个元素进行插入排序
           for (int j = i + gap; j < len; j += gap)
           {
               int temp = sp[j]; //记录基准数的位置
               int index = j; //记录坑的位置

               //向前遍历有序数组
               for (int k = j - gap; k >= 0; k-=gap)
               {
                   //进行数据比较
                   if (temp > sp[k])
                   {
                       //向后移动数据元素
                       sp[k + gap] = sp[k];
                       //保留坑的位置
                       index = k;
                   }
                   else
                       break;
               }
               //填坑
               sp[index] = temp;
           }
       }
   }

return sp;
}

//快速排序算法
int *QuickSort(int *sp, int begin, int end)
{
   //递归结束的条件
   if (begin == end)
       return NULL;

   int i = begin;
   int j = end;
   //将第一个元素值赋给临时变量，挖坑
   int temp = sp[begin];

   while (i < j)
   {
       while (i < j && sp[j] >= temp)
           j--;
       if (i < j)
       {
           sp[i] = sp[j];
           i++;
       }
       while (i < j && sp[i] < temp)
           i++;
       if (i < j)
       {
           sp[j] = sp[i];
           j--;
       }
       //填坑
       sp[i] = temp;
       //递归进行
       int *m = QuickSort(sp, begin, i - 1);
       int *n = QuickSort(sp, i + 1, end);
   }

return sp;
}
//合并两个数组[first,mid-1]和[mid+1,last]
void MergeArray(int *a, int first, int mid, int last, int *temp)
{

int i = first; // 第一个有序序列的开始下标
int j = mid + 1; // 第2个有序序列的开始下标

   int length = 0;
   // 合并两个有序序列
   while (i <= mid && j <= last)
   {
       // 找二者中比较小的数
       if (a[i] > a[j])
       {
           temp[length] = a[i];
           i++;
       }
       else
       {
           temp[length] = a[j];
           j++;
       }
       length++;
   }
   // 还剩下一个有序序列中有数据
   while (i <= mid)
   {
       temp[length++] = a[i++];
   }
   while (j <= last)
   {
       temp[length++] = a[j++];
   }

   // 覆盖原来位置的无序序列
   for (int i = 0; i < length; ++i)
   {
       // 找到原来的第一个有序序列的开始位置 - 开始覆盖
       a[first + i] = temp[i];
   }

}

//归并排序算法
void MergeSort(int *sp, int first, int last, int *temp)
{
   if (first == last)
       return;
   //使用递归进行拆分
   int mid = (first + last) / 2;
   //左侧拆分
   MergeSort(sp, first, mid, temp);

   //右侧拆分
   MergeSort(sp, mid + 1, last, temp);
   MergeArray(sp, first, mid, last, temp);

}

//交换两个元素
void swap(int *a, int *b)
{
   int temp = *a;
   *a = *b;
   *b = temp;
}

//构建最小堆
void max_heapfiy(heap *sp, int i)
{
   int l = 2 * i; //左子树的下标
   int r = 2 * i + 1; //右子树的下标
   int max = 0; //记录最大值的位置

   //进行比较
   if (l <= sp->arrlength && sp->array[l] > sp->array[i])
       max = l;
   else
       max = i;
   if (r <= sp->arrlength && sp->array[r] > sp->array[max])
       max = r;

   //进行值交换
   if (max != i)
   {
       swap(sp->array[i], sp->array[max]);
       min_heapfiy(sp, max);
   }
   else
       return;
}

//构建堆
heap * built_min_heap(int *array, int arrlen, heap *sp)
{
   //初始化堆
   sp->array = array;
   sp->arrlength = arrlen;

   //依次调整堆的大小
   for (int j = arrlen / 2; j >= 0; j--)
   {
       max_heapfiy(sp, j);
   }

return sp;
}

//堆排序算法
void heapsort(heap *a,int *array,int arrlen)
{
   heap*m = built_min_heap(array, a->arrlength, a);
   while (a->arrlength > 0)
   {
       swap(array[0], array[a->arrlength]);
       a->arrlength--;
       max_heapfiy(a, 0);
   }
}

//测试程序

//main.c

#include "Algorithmnprac.h"

int main()
{
   int array[] = { 10, 20, 78, 46, 13, 25, 56, 43, 33 };
   int size = sizeof array / sizeof(array[0]);
   printf("数组的元素个数为:%d\n",size);

   //正常情况下这是9个数，最后一个元素的下标为8,数组遍历从0开始也就是0-8{i=0；i<len;}
   printf("数组元素为:\n");
   PrintSort(array, size);
   int *pointer = ChooseSort(array,size);

   printf("\n");
   printf("选择排序的结果为:\n");
   PrintSort(pointer,size);
   printf("\n");
   printf("指针所占的字节数:");
   printf("%d ", sizeof(pointer));

   printf("\n");
   printf("冒泡排序的结果:\n");
   int *pointer1 = BubbleSort(array, size);
   PrintSort(pointer1, size);

   printf("\n");
   printf("冒泡排序的结果为:\n");
   int *pointer2 = BubbleSort2(array, size);
   PrintSort(pointer2, size);

   printf("\n");
   printf("插入法排序的结果为:\n");
   int *pointer3 = InsertSort(array, size);
   PrintSort(pointer3, size);

   printf("\n");
   printf("希尔排序算法结果为:\n");
   int *pointer4 = ShellSort(array, size);
   PrintSort(pointer4, size);

   printf("\n");
   printf("快速排序的结果为:\n");
   int *pointer5 = QuickSort(array, 0, size-1);
   PrintSort(pointer5, size);

   printf("\n");
   int *tmp = (int *)malloc(sizeof(array));
   printf("归并排序结果为:\n");
   MergeSort(array, 0, size-1 , tmp);
   PrintSort(array, size);

   heap m;
   printf("\n");
   printf("堆排序的结果为:\n");
   heapsort(&m, array, size-1);
   PrintSort(array, size);

}