C语言数据结构之基本排序算法（一）

最新推荐文章于 2024-06-14 12:00:00 发布
最新推荐文章于 2024-06-14 12:00:00 发布
阅读量78 收藏
点赞数
分类专栏： C语言入门 文章标签： 排序算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68045296/article/details/133904163
版权

目录

前言

本篇文章分析了选择排序法、冒泡排序法和插入排序法的逻辑，给出了C语言实现代码及其复杂度分析。参考自书籍 Fundamentals of Data Structures In C。本篇文章代码均已测试通过，欢迎大家批评指正🙏


引入

在正式讲解排序法之前，我们先来对已排好序的数组搭建一个最基础的排序过程：首先搜索整个数组，比较相邻元素、如果左边的值大于右边的值，则相邻元素交换，遍历上述过程直至相邻元素总保持左边小于右边，实现过程如下：

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#define MAX_SIZE 101		// 初始化数组的最大长度
#define SWAP(x, y, t) ((t) = (x), (x) = (y), (y) = (t))     /*  宏定义可适用于任何数据类型，函数定义法见swap */
#define COMPARE(x, y) (((x) < (y)) ? -1 :((x) == (y)) ? 0 : 1)      /* the other way is func: compare() */

void swap(int *x, int *y);          /* change the location of two values */
int compare(int x, int y );         /* 判断两数关系 */
void sort(int [], int);             /* 交换两数位置 */

void main()
{
    int i, n, a, b, num;
    int list[MAX_SIZE];
    printf("Enter the number of numbers to generate: ");
    scanf("%d", &n);
    if(n < 1 || n > MAX_SIZE)
    {
        fprintf(stderr, "Improper value of n\n");           // write the data into the file
        exit(1);					
    }
    /* randomly generate numbers */
    for(i = 0; i < n; i++)
    {
        list[i] = rand() % 1000;
        printf("%d ", list[i]);
    }
    sort(list, n);
    printf("\n Sorted array: \n");
    for(i = 0; i < n; i++)
        printf("%d  ", list[i]);
    printf("\n");
}

/* Actually it's a selection sorting */
void sort(int list[], int n)
{
    int i, j, min, temp;
    for(i = 0; i < n-1; i++)
    {
        min = i;
        for(j = i+1; j < n; j++)
            if(list[j] < list[min])
                min = j;
        SWAP(list[i], list[min], temp);
    }
}

void swap(int *x, int *y)
{
    int temp = *x;
    *x = *y;        // *x指向存储y所指向的地址
    *y = temp;
}

/* compare x and y, return -1 for less than, 0 for equal, 1 for greater */
int compare(int x, int y)
{
    if(x < y) return -1;
    else if(x == y) return 0;
    else return 1;
}

输出为：

在这里插入图片描述


一、选择排序法

选择排序算法（selection sort algorithm）基本思想：搜索整个列表，找到最小项的位置；如果该位置不是列表的第一个位置（即索引值为0），就会交换这两位置的值。（这实际上就是我们在引入中搭建的排序算法）

在使用选择排序法将数组元素按升序排序后，我们还可以查找某个元素是否在该数组中，顺序查找是最简单的思路却不是最佳的方法，在此程序中，我们使用二分查找将复杂度从O(n)降低至O(lgn)。

💻代码实现：

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#define MAX_SIZE 101
#define SWAP(x, y, t) ((t) = (x), (x) = (y), (y) = (t))     /*  宏定义可适用于任何数据类型，函数定义法见swap */
#define COMPARE(x, y) (((x) < (y)) ? -1 :((x) == (y)) ? 0 : 1)      /* the other way is func: compare() */

void swap(int *x, int *y);          /* change the location of two values */
int compare(int x, int y );         /* 判断两数关系 */
void sort(int [], int);             /* selection sort */
int binarysearch(int list[], int num, int left, int right);        /* 折半查找法基本思路 */

void main()
{
   int i, n, a, b, num;
    int list[MAX_SIZE];
    printf("Enter the number of numbers to generate: ");
    scanf("%d", &n);
    if(n < 1 || n > MAX_SIZE)
    {
        fprintf(stderr, "Improper value of n\n");           // write the data into the file
        exit(1);
    }
    /* randomly generate numbers */
    printf("The target list: /n");
    for(i = 0; i < n; i++)
    {
        list[i] = rand() % 1000;
        printf("%d ", list[i]);
    }
    sort(list, n);
    printf("\n Sorted array: \n");
    for(i = 0; i < n; i++)
        printf("%d  ", list[i]);
    printf("\n");

    printf("Type the expected value: ");
    scanf("%d", &num);

    a = binarysearch(list, num, 0, n-1);
    printf("Is 【%d】 in this random array?(【1】-> YES, 【-1】-> NO, 0 -> right in the middle)\n", num);
    printf("The answer is 【%d】\n", a);

}

/* 取已排序好的数组内0~n-1的数查找，先取该范围内中间的数进行判断，若该数小于则右边界减一，若大于则左边界加一 */
int binarysearch(int list[], int num, int left, int right)
{
    int middle;
    while(left <= right)
    {
        middle = (right + left) / 2;
        switch (COMPARE(list[middle], num))
        {
        case -1: left = middle + 1;
            break;
        case 0: return middle;
        case 1: right = middle - 1;
        }
    }
    return -1;
}

void sort(int list[], int n)
{
    int i, j, min, temp;
    for(i = 0; i < n-1; i++)
    {
        min = i;
        for(j = i+1; j < n; j++)
            if(list[j] < list[min])
                min = j;
        SWAP(list[i], list[min], temp);
    }
}

void swap(int *x, int *y)
{
    int temp = *x;
    *x = *y;        // *x指向存储y所指向的地址
    *y = temp;
}

/* compare x and y, return -1 for less than, 0 for equal, 1 for greater */
int compare(int x, int y)
{
    if(x < y) return -1;
    else if(x == y) return 0;
    else return 1;
}

👀输出如下：

在这里插入图片描述

💻折半查找的递归代码实现以及复杂度分析：

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>
#define MAX_SIZE 101
#define SWAP(x, y, t) ((t) = (x), (x) = (y), (y) = (t))     /*  宏定义可适用于任何数据类型，函数定义法见swap */
#define COMPARE(x, y) (((x) < (y)) ? -1 :((x) == (y)) ? 0 : 1)      /* the other way is func: compare() */

int binarysearch(int list[], int num, int left, int right);        /* 折半查找法基本思路 */
int binsearch(int list[], int num, int left, int right);          /* 递归的折半查找法 */
void sort(int [], int);             /* selection sort */
void swap(int *x, int *y);          /* change the location of two values */
int binarysearch(int list[], int num, int left, int right);         /* 折半查找法 */
int compare(int x, int y );         /* 判断两数关系 */

void main(void)
{
    int i, n, a, b, num;
    int list[MAX_SIZE];
    clock_t start, stop1, stop2;
    double duration; 

    printf("Enter the number of numbers to generate: ");
    scanf("%d", &n);
    if(n < 1 || n > MAX_SIZE)
    {
        fprintf(stderr, "Improper value of n\n");           // write the data into the file
        exit(1);
    }
    /* randomly generate numbers */
    printf("The target list: \n");
    for(i = 0; i < n; i++)
    {
        list[i] = rand() % 1000;
        printf("%d ", list[i]);
    }

    // 计时开始
    start = clock();
    // 排序
    sort(list, n);
    printf("\n Sorted array: \n");
    for(i = 0; i < n; i++)
        printf("%d  ", list[i]);
    printf("\n");
    // 查找
    printf("Type the expected value: ");
    scanf("%d", &num);

    printf("=============未使用递归==============\n");
    a = binarysearch(list, num, 0, n-1);
    // 非递归的二分查找计时结束
    stop1 = clock();
    printf("Is 【%d】 in this random array?(【>0】-> YES, 【-1】-> NO, 0 -> right in the middle)\n", num);
    if (num <= 0) {
        printf("The answer is 【%d】\n", a);
    }
    else {
        printf("YES. It's at the position【%d】\n", a);
    }

    printf("=============使用递归===============\n");
    b = binsearch(list, num, 0, n-1);
    // 递归的二分查找计时结束
    stop2 = clock();
    printf("Is 【%d】 in this random array?(【>0】-> YES, 【-1】-> NO, 0 -> right in the middle)\n", num);
    if (num <= 0) {
        printf("The answer is 【%d】\n", b);
    }
    else {
        printf("YES. It's at the position【%d】\n", b);
    }

    duration = ((double) (stop1-start)) / CLOCKS_PER_SEC;
    printf("不使用递归的折半查找消耗时间：%f\n" ,duration);
    duration = ((double) (stop2-stop1+start)) / CLOCKS_PER_SEC;
    printf("使用递归的折半查找消耗时间：%f\n" ,duration);
}

void sort(int list[], int n)
{
    int i, j, min, temp;
    for(i = 0; i < n-1; i++)
    {
        min = i;
        for(j = i+1; j < n; j++)
            if(list[j] < list[min])
                min = j;
        SWAP(list[i], list[min], temp);
    }
}

void swap(int *x, int *y)
{
    int temp = *x;
    *x = *y;        // *x指向存储y所指向的地址
    *y = temp;
}

/* compare x and y, return -1 for less than, 0 for equal, 1 for greater */
int compare(int x, int y)
{
    if(x < y) return -1;
    else if(x == y) return 0;
    else return 1;
}

/* 取已排序好的数组内0~n-1的数查找，先取该范围内中间的数进行判断，若该数小于则右边界减一，若大于则左边界加一 */
int binarysearch(int list[], int num, int left, int right)
{
    // 渐进复杂度为O(lgn)
    int middle;
    while(left <= right)
    {
        middle = (right + left) / 2;
        switch (COMPARE(list[middle], num))
        {
        case -1: left = middle + 1;
            break;
        case 0: return middle;
        case 1: right = middle - 1;
        }
    }
    return -1;
}

/* 递归的折半查找，返回调用直至逼近值然后返回，若找到则返回1，未找到则返回-1 */
int binsearch(int list[], int num, int left, int right)
{
    // 渐进复杂度为O(n^2)
    int middle;
    if(left <= right)
    {
        middle = (left + right) / 2;
        switch (COMPARE(list[middle], num))
        {
        case -1: return
            binsearch(list, num, middle+1, right);
        case 0: return middle;
        case 1: return
            binsearch(list, num, left, middle-1);
        }
    }
    return -1;
}

👀输出如下：

在这里插入图片描述


二、冒泡排序法

冒泡排序（bubble sort）：从列表索引为0处开始，并比较每一对数据项，直到移动到列表的末尾。每当成堆的两项之间的顺序不正确时（左大右小），就会交换位置，整体上表现为将最大的项移动到列表末尾。

💻代码实现：

/* 冒泡排序法 */

#include<stdio.h>
 
int main()
{
   int data[5];
   printf("请输入五个数组元素：\n");
   int i,j;
   for(i = 0;i < 5;i ++)
   {
   	scanf("%d",&data[i]);	
   }
   
   for(i = 0;i < 5;i ++)  
   {
   	for(j = 0;j < 5 - 1 - i;j++)
   	{
   	   if(data[j] > data[j+1])     // 这里默认采用升序来排列 
		   {
		 	   int temp;       
            temp = data[j];
			   data[j] = data[j+1];
			   data[j+1] = temp;
		   }	
	   }
   }
   
   printf("排序好的数组为：\n");
   for(i = 0;i < 5;i ++)    
   {
   	 printf("%d ",data[i]);
   }
   return 0;
} 

// 冒泡排序法的渐进复杂度为O(n^2)

👀输出为：

在这里插入图片描述


三、插入排序法

插入排序（Insertion sort）：在第i轮通过列表时，第i个项应该插入到列表的前i个项之中的正确排序位置。

💻代码实现：

/* 插入排序法 */


#include<stdio.h>
 
// 打印结果的函数 
void print(int data[],int n)
{
	int i;
	for(i=0;i<n;i++)
	{
		printf("%d ",data[i]);
	}
	printf("\n"); 
}

// 选择排序
void insertSort( int data[] ,int n )   
{
    int i,j;
    int t;
    for(i=1;i<n;i++)
    {
        t = data[i];
        j = i -1;
        while(j>=0 && data[j]>t)
        {
            data[j+1]=data[j];
            j--;
        }
        data[j+1] = t;
        print(data,n);         //显示排序的过程 
    }
}
 
int main()
{
	// 原数组
	int data[8]={5, 0, 2, 1, 3, 6, 7, 8};
	// 应用插入排序法后的数组
	insertSort(data ,8);
	return 0;
} 

// 插入排序法的复杂度为O(n^2)

👀输出为：

在这里插入图片描述

Larissa857
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
一些公司的笔试题
幽客独往
10-11 1万+
转载自瀚海星云Sony笔试题 　　1．完成下列程序 　　* 　　*.*. 　　*..*..*.. 　　*...*...*...*... 　　*....*....*....*....*.... 　　*.....*.....*.....*.....*.....*..... 　　*......*......*......*......*......*......*...... 　　*.......*
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
蓝桥杯——2009 北航计算机研究生机试真题（2017.2.4）
cr496352127的博客
02-04 650
1. 迭代求立方根 源代码： #include int main() { double x,n; double y0,y1; while(scanf("%lf %lf",&x,&n)!=EOF) { if(n==0) //迭代次数为0，直接开3次方得结果 y0=x; else
顺序查找的概念及实现代码详解
薛定谔的猫的博客
11-23 5622
文章目录顺序查找的概念一般线性表的顺序查找（顺序表）完整代码平均查找长度一般线性表的顺序查找（链表）完整代码平均查找长度顺序查找的优缺点关键字有序的顺序表的顺序查找平均查找长度 顺序查找的概念  顺序查找，又称为线性查找，主要用于在线性表中进行查找。  设若表中有n个元素，则顺序查找从线性表的先端开始，顺序用各元素的关键码值与给定值x进行比较，直到找到与其值相等的元素，则查找成功，给出该元素在表中的位置；若整个表检测完仍未找到与x相等的元素，则查找失败，给出失败信息。  顺序查找通常分为对一般的无序线性表
几种常见排序算法的实现（C语言实现）
q1430186623的博客
04-18 390
这里我给大家做了4种排序算法的实现，分别是：冒泡排序、选择排序、直接插入排序、快速排序。其中冒泡和选择是用链式结构来实现的，因此我这里先定义了链表的基本结构和创建操作。 #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode //定义链表类型 { ElemType data; //数据域 struct LNode *next; //指针域 }LNode,*Li
【求职】京东 2018 秋招测试开发工程师笔试题
瑞新の博客：bennyrhys
06-17 3863
京东 2018 秋招测试开发工程师笔试题 一.单选题 1.若度为m 的哈夫曼树中，其叶结点个数为 n，则非叶结点的个数为( ) A. n-1 B. n/m-1 C. (n-1)/(m-1) D. n/(m-1)-1 E. (n+1)/(m+1)-1 2.进程会在各个状态之间切换，下面哪些是不可能的( ) A. 运行→就绪 B. 运行→等待 C. 等待→运行 D. 等待→就绪 3.若一序列进栈顺序为 a1,a2,a3,a4，问存在多少种可能的出栈序列( ) A. 12 B. 13 C. 14 D. 15 4.
【C语言数据结构-插入排序算法】
DMHY123的博客
09-01 2131
理解并使用C语言实现三种插入排序算法
数据结构-排序算法（c语言实现篇）
CHAKMING1的博客
08-08 8490
数据结构中最全的排序算法（C语言实现）
内部排序算法比较-数据结构C语言课设
T1ngSh0w的博客
10-24 4802
(1)对以下7中常会用的内部排序算法进行比较：冒泡排序、直接插入排序、简单选择排序、希尔排序、堆排序、归并排序、快速排序。(2)待排序表的表不小于2000；比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换计为3次)。(3)最后要对结果做出简单分析，包括对各组数据得出结果波动大小的解释。在教科书中，各种内部排序算法的时间复杂的分析结果只给出了算法执行时间的阶，或大概执行时间。试通过随机数据比较各种算法的关键字比较次数和关键字移动次数，以取得直观感受。人狠话不多，直接上代码！
八大排序算法（C语言实现）
热门推荐
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
数据结构之冒泡排序算法 c语言ppt
12-02
详细讲解了冒泡排序算法，里面包含了c语言编程和冒泡排序的时间复杂度及相关定义
数据结构排序算法C语言实现
11-26
包括插入排序、堆排序、归并排序、基数排序、快速排序、冒泡排序、桶排序、拓扑排序、希尔排序、选择排序。
C语言数据结构8大排序算法完整代码（可直接上机运行）
11-11
包括：插入、希尔、冒泡、快速、选择、堆排序、归并（二路归并）、基数排序8个排序算法，完整的C语言代码，可点开直接运行，并附详细注释，方便理解和维护
最快的排序算法 C语言最简单的排序算法冒泡排序并返回排序前索引序号，排序算法数据结构
04-07
在计算机科学中，排序算法是最基本也是最重要的算法之一。冒泡排序是一种简单的排序算法，它的主要思想是通过不断地比较相邻元素，并交换它们以达到排序的目的。在C语言中，冒泡排序的实现非常简单，下面我们将详细...
【排序算法】计数排序（CountSort）
SWsunlight的博客
06-08 614
计数排序
排序---基数排序
sunshine350的博客
06-09 475
排序
有关排序的算法
最新发布
2401_82924480的博客
06-14 661
排序
【数据结构】 -- 堆 （堆排序）（TOP-K问题）
prettyxian的博客
06-09 1048
要学习堆，首先要先简单的了解一下二叉树，二叉树是一种常见的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的应用非常广泛，在后面我会详细介绍。满二叉树：除了叶子结点外，每个结点都有两个子结点一个深度为k的满二叉树有2的k次方减一个节点。完全二叉树：除了最底层可能不是满的外，其它每一层从左到右都是满的。满二叉树是完全二叉树的子集，满二叉树一定是完全二叉树，但完全二叉树不一定是满二叉树。堆就是一种完全二叉树。
数据结构之LinkedList与链表（上）
我要学编程的博客
06-12 1119
手动实现单链表的源码 手动实现双链表的源码 分析LinkedList 的源码 LinkedList的使用：常用方法 ArrayList 和 LinkedList的区别
c语言数据结构与算法 希尔排序算法
12-23
希尔排序是一种插入排序的改进算法，它通过动态定义间隔的方式，对数据进行分组，...总之，希尔排序算法是C语言中常用的排序算法之一，通过动态定义间隔和分组排序的方式，可以提高排序效率，适用于大规模数据的排序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Larissa857

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值