C语言|线性表的排序算法|简单插入排序、简单选择排序、冒泡排序|未完待续

最新推荐文章于 2023-12-21 23:52:59 发布
最新推荐文章于 2023-12-21 23:52:59 发布
阅读量5.4k 收藏 45
点赞数 7
分类专栏： C&C++学习 文章标签： 算法 数据结构 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48709737/article/details/109173461
版权

线性表的排序算法

排序相关的几个基本概念

  1. 排序依据是指数据元素的关键字，若关键字是主关键字，即关键字值不重复，则无论采用何种排序方法，排出的结果都是唯一的，若关键字是次关键字，即关键字值可以重复，则排出的结果可能不唯一，即相同关键字的数据在排序前后的相对位置发生了变化。
  2. 稳定排序：对于任意的数据元素序列，在排序前后相同关键字数据的相对位置都保持不变。
    不稳定排序：存在一组数据序列，在排序前后，相同关键字数据的相对位置发生了变化。
  3. 算法效率评价：主要从两个方面进行考察：算法的空间复杂度、算法的时间复杂度。算法的执行时间一般分为最好情况下的时间复杂度、最差情况下的时间复杂度和平均情况下的时间复杂度。
  4. 排序方法：内部排序是指无须借助外存，直接在内存中完成的排序；外部排序是指数据量巨大，必须借助外存的帮助才能完成的排序。

直接插入排序（简单插入排序）

基本思想

将序列分成两部分，左边按关键字有序排列，右边无序排列。先将左边序列中第一个数据元素作为左边有序部分的第一个数据元素，然后将右边第一个记录插入到左边序列的适当位置，使得左边部分仍按关键字有序排列，重复下去，指导右边序列长度为0。
例：将[9,5,6,4,2]升序排序
9,5,6,4,2,1
5,9,6,4,2,1
5,6,9,4,2,1
4,5,6,9,2,1
2,4,5,6,9,1
1,2,4,5,6,9

代码示例

typedef int DataType;
typedef struct
{
	DataType key;
	float info;
}JD;
void Straisort(JD S[], int n)
{
	int i, j;
	JD media;
	for (i = 0; i < n; i++)
	{
		media = S[i];
		for (j = i - 1; media.key < S[j].key; j--)
		{
			S[j + 1] = S[j];
		}
		S[j + 1] = media;
	}
}

性能分析

空间复杂度

直接插入排序在排序过程中，需要一个辅助空间S[0]。复杂度为O(1).

时间复杂度

  1. 最好情况。序列本身有序，每次排序过程只需1次比较，0次移动，整个排序过程共需要n-1次比较，0次数据移动。复杂度为O(n).
  2. 一般情况。第i趟排序操作需要和前面有序部分大约一半的记录进行比较，即大约比较 i 2 \frac{i}{2} 2i​次，需要移动的数据量也大约为 i 2 \frac{i}{2} 2i​次。时间复杂度为O(n2).
  3. 最坏情况。序列本身反序，因此
    总的比较次数 = ∑ i = 2 n \sum_{i=2}^n ∑i=2n​ ( i - 1) = n ( n − 2 ) 2 \frac{n(n-2)}{2} 2n(n−2)​
    总的移动次数 = ∑ i = 2 n \sum_{i=2}^n ∑i=2n​ ( i - 1) = ( n + 2 ) ( n + 1 ) − 2 2 \frac{(n+2)(n+1)-2}{2} 2(n+2)(n+1)−2​

由此可知，直接插入排序的时间复杂度在平均情况和最坏情况下都为O(n2).

简单选择排序

基本思想

从无序子序列中选择关键字最小（或最大）的记录，并将它加入到有序子序列中，以此增加记录的有序子序列的长度。

  1. 首先通过n-1次关键字比较，从n个记录中找出关键字最小的记录，将它与第一个记录交换
  2. 再通过n-2次比较，从剩余的n-1个记录中找出关键字次小的记录，将它与第二个记录交换
  3. 重复上述操作，共进行n-1趟排序后，排序结束。
    例：对{49,38,65,97,76,13,27}进行升序排序
    第一趟 13, {38,65,97,76,49,27}
    第二趟 13,27, {65,97,76,49,38}
    第三趟 13,27,38, {97,76,49,65}
    第四趟 13,27,38,49, {76,97,65}
    第五趟 13,27,38,49,65, {97,76}
    第六趟 13,27,38,49,65,76, {97}
    排序结束 13,27,38,49,65,76,97

代码示例

typedef int DataType;
typedef struct
{
	DataType key;
	float info;
}JD;
void Smp_Selesort(JD S[], int n)
{
	int i, j, k;
	JD media;
	for (i = 0; i < n; i++)
	{
		k = i;
		for (j = i + 1; j < n; j++)//找出关键字小的记录，然后进行交换
		{
			if (S[j].key < S[k].key)k = j;
		}
		if (i != k)
		{
			media = S[i];
			S[i] = S[k];
			S[k] = media;
		}
	}
}

性能分析

空间复杂度

简单选择排序算法需要一个额外的辅助存储单元，因此空间复杂度为O(1).

时间复杂度

  1. 最好的情况
    第i趟选择需要进行比较n-i次，需要进行交换的次数为0，
    总的比较次数 = ∑ i = 1 ( n − 1 ) \sum_{i=1}^{(n-1)} ∑i=1(n−1)​ ( n - i ) = n ( n − 1 ) 2 \frac{n(n-1)}{2} 2n(n−1)​
    总共需要的交换次数为0.
  2. 最坏的情况
    第i趟选择需要进行比较的次数为n-i，需要进行交换的次数为1，
    总的比较次数 = ∑ i = 1 ( n − 1 ) \sum_{i=1}^{(n-1)} ∑i=1(n−1)​ ( n - i ) = n ( n − 1 ) 2 \frac{n(n-1)}{2} 2n(n−1)​
    总共需要的交换次数为n-1.

因此简单选择排序的时间复杂度为O(n2).

冒泡排序

基本思想

冒泡排序是一种交换排序，将元素进行两两比较和交换。
例：对序列{12,34,20,15,9}进行冒泡排序
第一趟
12,34,20,15,9
12,20,34,15,9
12,20,15,34,9
12,20,15,9,34 ←第一趟的结果
第二趟的结果
12,15,9,20,34
第三趟的结果
12,9,15,20,34
第四趟的结果
9,12,15,20,34
排序完成

代码示例（升序排序）

typedef int DataType;
typedef struct
{
	DataType key;
	float info;
}JD;
void Bubble_Sort(JD S[], int n)
{
	int flag = 1;
	JD media;
	for (int i = 0; i < n - 1; ++i)
	{
		flag = 0;//用于判断是否发生交换
		for (int j = 0; j < n - i - 1; ++j)
		{
			if (S[j].key > S[j + 1].key)
			{
				media = S[j];
				S[j] = S[j + 1];
				S[j + 1] = media;
				flag = 1;
			}
		}
		if (flag == 0)break;//此趟冒泡没有发生交换，排序结束
	}
}

性能分析

空间复杂度

冒泡排序需要一个辅助存储单元，空间复杂度为O(1).

时间复杂度

  1. 最好的情况：序列本身就是排好序的，那么排序时一次交换都未发生，时间复杂度为O(n).
  2. 最坏的情况：序列本身是反序的，那么每趟冒泡都是必须的，共需要进行n-1趟冒泡，第i趟冒泡中比较的次数为n-i，数据交换n-i次
    总的比较次数 = ∑ i = 1 ( n − 1 ) \sum_{i=1}^{(n-1)} ∑i=1(n−1)​ ( n - i ) = n ( n − 1 ) 2 \frac{n(n-1)}{2} 2n(n−1)​
    总的交换次数 = ∑ i = 1 ( n − 1 ) \sum_{i=1}^{(n-1)} ∑i=1(n−1)​ ( n - i ) = n ( n − 1 ) 2 \frac{n(n-1)}{2} 2n(n−1)​
    时间复杂度为O(n2).

冒泡算法的改进

对长度为n的序列S进行升序排序，若后面的一部分数已经是排好序的，则这部分数据就不需要再参与冒泡，从而一定程度上节省时间

代码示例

typedef int DataType;
typedef struct
{
	DataType key;
	float info;
}JD;
void Bubble_Modified_Sort(JD S[], int n)
{
	int LastExchangeIndex;
	JD media;
	int i = n;
	while(i>1)
	{
		LastExchangeIndex = 1;
		for (int j = 0; j < i - 1; ++j)
		{
			if (S[j].key > S[j + 1].key)
			{
				media = S[j];
				S[j] = S[j + 1];
				S[j + 1] = media;
				LastExchangeIndex = j + 1;//记录交换的位置
			}
		}
		i = LastExchangeIndex;//本趟最后一次交换的位置
	}
}
弦上有春秋儿
关注
  • 7
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
算法与数据结构（基于C语言）中线性表的快速排序&快速查找
LWanTao的博客
12-14 2074
引言：最近学习了基于C语言指针知识点的快速排序与快速查找，老师建议我们学习完数组形式后，将其与线性表结合起来，故有以下的知识与代码总结。鉴于本人还是算法新手，若有错误，望指正，谢谢！ 在我的理解中，无论是数组还是线性表，其排序与搜索都是基于指针，所以从数组转化为线性表并不是难事，只是换个壳罢了… 数组的快速排序与快速查找是参考站内前辈zhengqijun_的这篇文章,前辈的代码结构是我在有限的时间内发现的最简洁与美妙的版本，故偷懒的我便基于前辈的代码基础上修改啦：） 以下是包含的头文件 & 线性.
C语言算法----常用三大排序+交换排序（冒泡、选择、插入）
qq_48434912的博客
03-26 2627
一、冒泡排序 从第一个数值开始，每相邻的两个数值排序与我们希望的排序位置不同时，将两个数的位置进行交换。如果一致，则不交换。每排一次会把最大或最小的数放到最后，重复上述操作，直到排序完成。 3,2,5,8,1,9,7,4,0,6 第一轮排序：2351874069 第二轮排序：2315740689 第三轮排序：2135406789 第四轮排序：1234056789 第五轮排序：1230456789 第六轮排序：1203456789 第七轮排序：1023456789 第八轮排序：0123456789 …… 代码
C语言（插入、选择、冒泡、快速）排序
番茄的博客
04-25 902
目录 前言一、插入排序二.选择排序三.冒泡排序四、快速排序hoare版本(左右指针法)时间复杂度、稳定性表这里实现几种常见的排序算法：步骤：1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5动图演示如下：思路：   在待排序的元素中，假设前
线性表之C语言实现(顺序表)
最新发布
get_p_c_j的博客
12-21 1502
1、线性表是包含若干数据元素的一个线性序列。La0​......ai−1​ai​ai1​......an−1​L为表名，ai​0≤i≤n−1为数据元素；n为表长，n≥0时，线性表L为非空表，否则为空表。线性表L可用二元组形式描述：L=(D,R)；即Data，Relation。即线性表L包含数据元素集合D和关系集合R。
实验6：排序
cai_4的博客
06-09 1469
基本内容： 采用顺序存储结构，完成顺序表的创建，实现对顺序表的直接插入排序、冒泡排序。并在此基本内容的基础上，实现对顺序表的快速排序或别的排序。 实验原理 （1）直接插入排序的基本思想是：通过一趟排序将待排序的当前记录插入到前面已经排好序的有序序列中，从而得到一个新的、记录数增1的有序序列。整个排序过程可简述为：先将序列中的第一个记录看成是一个有序的子序列，然后从第二个记录起逐个插入，直至整个序列有序。 （2）快速排序是对起泡排序的一种改进，其基本思想是：通过一趟排序将带排记录分割成独立的两部分，其中一部分
c语言5个常用的排序算法实例代码
08-28
插入排序是一种简单的排序算法，它的基本思想是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。插入排序的实现代码如下所示： ```c void insertSort(vector<int>& nums) { ...
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
c++实现多种线性表排序的算法（插入排序，希尔，冒泡，快速，堆排序，归并排序）
07-05
本篇将详细阐述标题和描述中提到的几种线性表排序算法，包括插入排序、希尔排序、冒泡排序、快速排序、堆排序以及归并排序。 1. **插入排序**： 插入排序是一种简单直观的排序算法，它的工作原理是通过构造一个...
插入，选择排序的链表实现及快速，希尔，冒泡排序算法实现合集
05-02
这里我们主要探讨的是五种不同的排序算法：插入排序、选择排序、快速排序、希尔排序以及冒泡排序，它们都有对应的链表实现。让我们逐一深入理解这些算法。 1. 插入排序（Insertion Sort） 插入排序是一种简单直观...
java线性表排序示例分享
09-04
同时，在对大规模数据进行排序时，需要考虑性能问题，选择合适的排序算法和数据结构。 Java线性表排序是一种常见的数据排序方式，可以根据需要定义自定义的比较规则，具有广泛的应用场景。但需要注意Comparator对象...
线性表的建立、查找、排序C语言设计
11-27
程序模块化，控制背景色设计，与用户进行交互的模式
数据结构（第二课）--线性表
Jensen
11-05 618
数据结构，之前感觉不到其重要性，线性表对我们以后的编程会有什么帮助呢，今天看到关于一个java方面的问题才发现其重要性，在java中，我们所用到的集合list等，都是通过线性表来实现的，了解了线性表，我们对这些的理解会更深入，用起来会更加的得心应手，程序中的数据大致分为四种姐帮你的逻辑结构，集合，线性结构，树形结构，图状结构或网状结构，对于数据的不同逻辑结构，计算机在物理磁盘上通常有点2中方式，一
Python语言实现：排序算法之冒泡、选择、插入排序的总结
weixin_43726471的博客
11-06 1046
开始正题之前，先啰嗦两句，讲到算法，一定离不开数据结构，算法与数据结构是分不开的。我们知道程序执行，最终的执行者是计算机，一个程序执行需要有数据，有执行动作，以及执行动作的流程。一句话总结：告诉计算机你的数据是什么，计算机会给你放内存中，告诉计算机你要怎么来操作数据，以及步骤是什么，这一套动作的步骤就是算法的具体实现。算法只是一种思想。 数据在计算机的存储，数据对于计算机来说没有什么区别，表现都为二进制数0和1，计算机拿到数据就会放在内存中，内存是连续的，固定不变的，被使用之后就不能用了，除非这块内存被释放
数据结构---排序算法总结（C语言）
Mj_yong的博客
01-20 577
编写有八种常用排序算法的基本思想、实现核心代码、其他知识点等，算法包括直接插入算法、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序。关于排序算法的完整代码在另一篇博客中展现。
数据结构实验1：线性表应用之顺序表
qtL0ng的博客
06-22 3526
顺序表 目的要求 1．掌握线性表顺序存储结构的特点。 2．掌握线性表顺序存储结构的常见算法。 实验内容 1．输入一组整型元素序列（不少于 10 个），建立顺序表。 2．在该顺序表中进行顺序查找某一元素，查找成功返回 1，否则返回 0。 3．判断该顺序表中元素是否对称，对称返回 1，否则返回 0。 4．实现把该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数。 5．输入整型元素序列（不少于 10 个），利用有序表插入算法建立一个有序表。 6．利用算法 5 建立两个非递减有序表，并把它们合并成一个非递减有
数据结构顺序表实现冒泡排序，简单选择，直接插入，快速排序。
美柚明治
07-17 4124
#include <iostream> using namespace std; #define MAXSIZE 100 //顺序表的最大长度 typedef struct { int key; char *otherinfo; }ElemType; //顺序表的存储结构 typedef st...
线性表的顺序实现--C语言版
qq_63911745的博客
01-13 362
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<errno.h> #define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量 #define LISTINCREMENT 10 //线性表存储空间的分配增量 //操作算法中用到的预定义常量和类型 //函数结果状态代码 #define T.
【排序算法】冒泡排序、简单选择排序、直接插入排序比较和分析
热门推荐
baidu_33146219的博客
08-08 2万+
本文简单介绍了冒泡排序、简单选择排序、直接插入排序，并对这三种排序进行比较，入参都是80000个随机数，比较算法耗时。进一步，我们通过代码分析三种排序算法的性能。
c语言——线性表之顺序结构
LIUZHIOJ的博客
12-07 451
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;conio.h&gt; //线性表——顺序存储 #define LIST_INIT_SIZE 10 #define LISTINCREMENT 10 #define ERROR 0 #define OK 1 #define OVERFLOW -2 typedef st...
编写算法建立线性表或二叉排序树并完成相应查找算法： 1. 先依次输入元素为简单类型（int、char）或自定义结构体类型（如订单信息或学生信息或员工信息）的数个数据元素建立顺序存储的线性表，然后①以该线性表为查找表进行顺序查找；②用冒泡排序对该线性表按某个关键字值进行排序，在排序之后的线性表之上进行折半查找。
06-10
以下是使用 C++ 实现的线性表和二叉排序树，并完成相应的查找算法： ```c++ #include <iostream> #include <vector> #include <algorithm> using namespace std; // 定义订单信息结构体 struct Order { int id; string name; double price; }; // 定义学生信息结构体 struct Student { int id; string name; int age; double score; }; // 定义员工信息结构体 struct Employee { int id; string name; string department; double salary; }; // 定义简单类型元素的线性表类 template <typename T> class LinearList { public: // 构造函数 LinearList() { size = 0; capacity = 10; data = new T[capacity]; } // 析构函数 ~LinearList() { delete[] data; } // 在线性表尾部插入元素 void push_back(T element) { if (size == capacity) { capacity *= 2; T* new_data = new T[capacity]; for (int i = 0; i < size; i++) { new_data[i] = data[i]; } delete[] data; data = new_data; } data[size++] = element; } // 顺序查找元素 int sequential_search(T element) { for (int i = 0; i < size; i++) { if (data[i] == element) { return i; } } return -1; // 没有找到 } // 冒泡排序 void bubble_sort() { for (int i = 0; i < size - 1; i++) { for (int j = 0; j < size - i - 1; j++) { if (data[j] > data[j + 1]) { swap(data[j], data[j + 1]); } } } } // 折半查找元素 int binary_search(T element) { int left = 0, right = size - 1; while (left <= right) { int mid = (left + right) / 2; if (data[mid] == element) { return mid; } else if (data[mid] < element) { left = mid + 1; } else { right = mid - 1; } } return -1; // 没有找到 } // 打印线性表元素 void print() { for (int i = 0; i < size; i++) { cout << data[i] << " "; } cout << endl; } private: T* data; // 数据存储区 int size; // 当前元素个数 int capacity; // 容量 }; // 定义二叉排序树节点类 template <typename T> class BSTNode { public: T data; // 数据 BSTNode<T>* left; // 左子树指针 BSTNode<T>* right; // 右子树指针 // 构造函数 BSTNode(T data) { this->data = data; left = nullptr; right = nullptr; } }; // 定义二叉排序树类 template <typename T> class BinarySearchTree { public: // 构造函数 BinarySearchTree() { root = nullptr; } // 析构函数 ~BinarySearchTree() { destroy(root); } // 在二叉排序树中插入元素 void insert(T data) { insert_helper(root, data); } // 中序遍历二叉排序树，输出排序后的结果 void inorder_traversal() { inorder_traversal_helper(root); cout << endl; } // 折半查找元素 int binary_search(T element) { return binary_search_helper(root, element); } private: BSTNode<T>* root; // 根节点 // 销毁二叉排序树 void destroy(BSTNode<T>* node) { if (node != nullptr) { destroy(node->left); destroy(node->right); delete node; } } // 插入元素辅助函数 void insert_helper(BSTNode<T>*& node, T data) { if (node == nullptr) { node = new BSTNode<T>(data); } else { if (data < node->data) { insert_helper(node->left, data); } else { insert_helper(node->right, data); } } } // 中序遍历二叉排序树辅助函数 void inorder_traversal_helper(BSTNode<T>* node) { if (node != nullptr) { inorder_traversal_helper(node->left); cout << node->data << " "; inorder_traversal_helper(node->right); } } // 折半查找元素辅助函数 int binary_search_helper(BSTNode<T>* node, T element) { if (node == nullptr) { return -1; // 没有找到 } else { if (node->data == element) { return 0; } else if (node->data < element) { int result = binary_search_helper(node->right, element); return result == -1 ? -1 : result + 1 + binary_search_helper(node->left, element); } else { int result = binary_search_helper(node->left, element); return result == -1 ? -1 : result + 1 + binary_search_helper(node->right, element); } } } }; int main() { // 测试简单类型元素的线性表 LinearList<int> list1; list1.push_back(5); list1.push_back(2); list1.push_back(4); list1.push_back(6); list1.push_back(1); list1.push_back(3); list1.print(); cout << "Sequential search: " << list1.sequential_search(4) << endl; list1.bubble_sort(); list1.print(); cout << "Binary search: " << list1.binary_search(4) << endl; // 测试自定义结构体类型的线性表 LinearList<Order> list2; list2.push_back({1, "book", 29.99}); list2.push_back({2, "pen", 3.99}); list2.push_back({3, "bag", 59.99}); list2.push_back({4, "notebook", 9.99}); list2.print(); cout << "Sequential search: " << list2.sequential_search({3, "bag", 59.99}) << endl; list2.bubble_sort(); list2.print(); cout << "Binary search: " << list2.binary_search({3, "bag", 59.99}) << endl; // 测试二叉排序树 BinarySearchTree<int> bst; bst.insert(5); bst.insert(2); bst.insert(4); bst.insert(6); bst.insert(1); bst.insert(3); bst.inorder_traversal(); cout << "Binary search: " << bst.binary_search(4) << endl; return 0; } ``` 需要注意的是，在二叉排序树中进行折半查找时，要统计节点的左子树和右子树中小于或等于或大于查找元素的节点个数，具体实现可以参考上面的代码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值