2.8 线性表的归并

于 2023-07-21 12:27:34 发布
阅读量761 收藏 9
点赞数 3
分类专栏： # 线性表 文章标签： 数据结构 链表 考研 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oncruise/article/details/131829860
版权

        归并: 把两个表或多个表按照某种策略(规则)合并成一个表. 例如以后要介绍的归并排序就是归并的一个应用. 在线性表这一章, 我们只介绍二路归并. 即把两个线性表合并成一个表. 归并规则是把两个已经有序的线性表给归并成一个更长的线性表, 得到的表也是有序的. 

1. 顺序表归并

        策略: 每次从两个顺序表中挑出最小的元素, 然后把它插入到当前所归并好的那一段的顺序表的末端即可. 两个原始的顺序表均有序, 需要另外开辟存储空间来存储归并后的顺序表. 

 图1. 顺序表的归并

        如图, 上面的顺序表记为a[ ], 长度为m; 下面的顺序表记为b[ ], 长度为n; 用c[ ] 存储归并后的顺序表. k记录c[ ] 中当前要放入的元素的索引. 怎么归并? 需要分别比较a[ i ]和b[ j ]的值, 将较小者放入c[ k ]中, 然后k++; 较小者的索引自增1; 比如若a[ i ] <b[ j ], 则c[ k ] = a[ i ]; k++; i++; 反之则c[ k ] = b[ j ]; k++; j++; 循环的判断条件该怎么写? 每次循环都会导致 i 或者 j 自增1, 这样总会有一个顺序表先遍历完, 需要注意的是, 并不是短的顺序表就一定先遍历结束, 因为 i 或 j 的自增是有条件的. 假如a比较短, 但a中所有的元素都大于b中的元素, 则归并的时候肯定是b中的元素先被归并到c[ ] 中, 也即b[ ] 先被遍历完. 只要有一个表被遍历完, 则说明另一个未遍历完的表中的元素, 全部大于归并好的元素, 这时只需要将未归并的元素依次放入c[ ] 中即可. 

#include <iostream>

/// <summary>
/// 数组最大长度
/// </summary>
const int MAX_SIZE = 10;

/// <summary>
/// 顺序表的归并
/// </summary>
/// <param name="a">有序的顺序表1</param>
/// <param name="m">顺序表1的长度</param>
/// <param name="b">有序的顺序表2</param>
/// <param name="n">顺序表2的长度</param>
/// <param name="c">归并后的顺序表</param>
/// <param name="k">归并后的顺序表的长度</param>
void mergeArray(int* a, int m, int* b, int n, int* c, int& k) {		//假设传入的数组c长度足够大
	int i = 0;
	int j = 0;

	int compTimes = 0;		//比较次数

	while (i < m && j < n) {
		if (a[i] < b[j]) {
			c[k] = a[i];
			k++;
			i++;
		}
		else {
			c[k] = b[j];
			k++;
			j++;
		}
		compTimes++;
	}

	while (i < m) {		//下面这两个循环只会执行其中一个
		c[k] = a[i];
		k++;
		i++;
	}
	while (j < n) {
		c[k] = b[j];
		k++;
		j++;
	}

	printf("比较次数: %d\n", compTimes);
}

int main()
{
	int a[MAX_SIZE] = { 0, 2, 7, 9 };
	int m = 4;

	int b[MAX_SIZE] = { 1, 4, 8, 11, 12, 13, 14 };
	int n = 7;

	int c[MAX_SIZE * 2] = {};
	int k = 0;

	mergeArray(a, m, b, n, c, k);

	printf("归并后的顺序表长度: %d\n", k);
	printf("归并后的顺序表元素: \n");
	for (int i = 0; i < k; i++)
	{
		printf("%d\n", c[i]);
	}
}

代码1: 顺序表的归并

        现在我们研究一下顺序表归并的比较次数. 可以看出只有在第一个while循环里面才会进行比较.

        什么情况下比较次数最少? 由于第一个while循环会至少遍历完其中的一个顺序表, 因此比较次数最少为min{m, n}, 这种情况下, 索引 i 和 j 只能有一个发生了移动, 另一个索引始终指向顺序表的第一个元素. 也即当其中一个顺序表的所有元素全部大于另一个顺序表中的所有元素的时候, 比较的次数最少, 为min{m, n}; 

        什么情况下比较次数最多? 显然是遍历过程中, 索引 i 和 j 全部发生了移动, 也即 i 和 j 最后都指向了顺序表的最后一个元素. 若 a = {7, 8, 9, 10}; m为4; b = {1, 2, 3, 4, 5, 6, 9999}; n为7; 则 j 先从0变化到5, 比较了6次, i 再从0变化到3, 比较了4次, 此时a已经遍历完毕, 跳出循环. 共比较了6 + 4 = 10次. 即m + n - 1次. 也即遍历过程中, 其中一个表b的索引先移动到最后一个元素, 此时比较的次数为该表b的表长 - 1, 即n - 1. 然后另外一个表a的索引移动到该表的最后一个元素, 此时又比较了表a的表长的次数, 即m. 此时表a遍历完毕, 跳出循环. 故最坏的情况需要比较m + n - 1次. 

2. 链表归并

1. 尾插法归并链表

 图2. 尾插法归并链表

        如图, 归并A, B两个升序的链表, 将其归并到链表C中. p指向A中待归并的结点, q指向B中待归并的结点, r指向C中已归并的结点. 同时对链表A和链表B进行遍历, 当p != NULL && q != NULL时进行循环, 比较两个链表中结点的值, 若p->data < q->data, 则r->next = p; p = p->next; r = r->next; 反之, 则r->next = q; q = q->next; r = r->next; 循环结束后, 若p != NULL; 则r->next = p; 若q != NULL; 则r->next = q; 尾插法归并链表得到的链表是顺序的. 

#include <iostream>

/// <summary>
/// 链表结点结构体定义
/// </summary>
typedef struct LNode {
	int data;
	struct LNode* next;
}LNode;

/// <summary>
/// 尾插法归并单链表
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
/// <param name="C"></param>
void merge(LNode* A, LNode* B, LNode* C) {	
	LNode* p = A->next;		//p指向A中待归并的结点
	LNode* q = B->next;		//q指向B中待归并的结点
	LNode* r = C;			//r指向C中已归并的结点
	C->next = NULL;
	free(A);
	free(B);

	while (p != NULL && q != NULL)
	{
		if (p->data < q->data) {
			r->next = p;
			p = p->next;
			r = r->next;
		}
		else {
			r->next = q;
			q = q->next;
			r = r->next;
		}
	}

	if (p != NULL) {
		r->next = p;
	}
	if (q != NULL) {
		r->next = q;
	}
}

int main()
{
	LNode* A = (LNode*)malloc(sizeof(LNode));
	LNode* a0 = (LNode*)malloc(sizeof(LNode));
	LNode* a1 = (LNode*)malloc(sizeof(LNode));
	LNode* a2 = (LNode*)malloc(sizeof(LNode));
	LNode* a3 = (LNode*)malloc(sizeof(LNode));

	A->data = NULL;
	a0->data = 0; 
	a1->data = 2;
	a2->data = 7;
	a3->data = 9;

	A->next = a0;
	a0->next = a1;
	a1->next = a2;
	a2->next = a3;
	a3->next = NULL;

	LNode* B = (LNode*)malloc(sizeof(LNode));
	LNode* b0 = (LNode*)malloc(sizeof(LNode));
	LNode* b1 = (LNode*)malloc(sizeof(LNode));
	LNode* b2 = (LNode*)malloc(sizeof(LNode));
	LNode* b3 = (LNode*)malloc(sizeof(LNode));
	LNode* b4 = (LNode*)malloc(sizeof(LNode));
	LNode* b5 = (LNode*)malloc(sizeof(LNode));
	LNode* b6 = (LNode*)malloc(sizeof(LNode));

	B->data = NULL;
	b0->data = 1;
	b1->data = 4;
	b2->data = 8;
	b3->data = 11;
	b4->data = 12;
	b5->data = 13;
	b6->data = 15;

	B->next = b0;
	b0->next = b1;
	b1->next = b2;
	b2->next = b3;
	b3->next = b4;
	b4->next = b5;
	b5->next = b6;
	b6->next = NULL;

	LNode* C = (LNode*)malloc(sizeof(LNode));

	merge(A, B, C);

	LNode* p = C->next;
	printf("归并后的数据: \n");
	while (p != NULL)
	{
		printf("%d\n", p->data);
		p = p->next;
	}
}

代码2: 链表的尾插法归并

/// <summary>
/// 尾插法归并单链表
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
/// <param name="C"></param>
void merge(LNode* A, LNode* B, LNode* C) {	
	LNode* p = A->next;		//p指向A中待归并的结点
	LNode* q = B->next;		//q指向B中待归并的结点
	LNode* r = C;			//r指向C中已归并的结点
	C->next = NULL;
	free(A);
	free(B);

	while (p != NULL && q != NULL)
	{
		if (p->data < q->data) {
			r->next = p;
			p = p->next;
			r = r->next;
		}
		else {
			r->next = q;
			q = q->next;
			r = r->next;
		}
	}

	if (p != NULL) {
		r->next = p;
	}
	if (q != NULL) {
		r->next = q;
	}
}

代码3: 尾插法归并链表核心代码

2. 头插法归并链表

 图3. 头插法归并链表

        如图, 归并A, B两个升序的链表, 将其归并到链表C中. p指向A中待归并的结点, q指向B中待归并的结点. C作为头结点, 接收插入的元素, 将插入的元素放在C的后面. s指向当前取出的最小值结点. 同时对链表A和链表B进行遍历, 当p != NULL && q != NULL时进行循环, 若p->data < q->data; 则s = p; p = p->next; s->next = C->next; C->next = s; 反之, 则s = q; q = q->next; s->next = C->next; C->next = s; 循环结束后, 当p != NULL时; 则重复之前的操作, 即s = p; p = p->next; s->next = C->next; C->next = s; 当q != NULL时; 则重复之前的操作, 即s = q; q = q->next; s->next = C->next; C->next = s; 头插法归并链表得到的链表是顺序的. 

#include <iostream>

/// <summary>
/// 链表结点结构体定义
/// </summary>
typedef struct LNode {
	int data;
	struct LNode* next;
}LNode;

/// <summary>
/// 头插法归并单链表
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
/// <param name="C"></param>
void merge(LNode* A, LNode* B, LNode* C) {	
	LNode* p = A->next;		//p指向A中待归并的结点
	LNode* q = B->next;		//q指向B中待归并的结点
	LNode* s;				//s指向当前取出的最小值结点
	C->next = NULL;
	free(A);
	free(B);

	while (p != NULL && q != NULL)
	{
		if (p->data < q->data) {
			s = p;
			p = p->next;
			s->next = C->next;
			C->next = s;
		}
		else {
			s = q;
			q = q->next;
			s->next = C->next;
			C->next = s;
		}
	}

	while (p != NULL) {
		s = p;
		p = p->next;
		s->next = C->next;
		C->next = s;
	}
	while (q != NULL)
	{
		s = q;
		q = q->next;
		s->next = C->next;
		C->next = s;
	}
}

int main()
{
	LNode* A = (LNode*)malloc(sizeof(LNode));
	LNode* a0 = (LNode*)malloc(sizeof(LNode));
	LNode* a1 = (LNode*)malloc(sizeof(LNode));
	LNode* a2 = (LNode*)malloc(sizeof(LNode));
	LNode* a3 = (LNode*)malloc(sizeof(LNode));

	A->data = NULL;
	a0->data = 0; 
	a1->data = 2;
	a2->data = 7;
	a3->data = 9;

	A->next = a0;
	a0->next = a1;
	a1->next = a2;
	a2->next = a3;
	a3->next = NULL;

	LNode* B = (LNode*)malloc(sizeof(LNode));
	LNode* b0 = (LNode*)malloc(sizeof(LNode));
	LNode* b1 = (LNode*)malloc(sizeof(LNode));
	LNode* b2 = (LNode*)malloc(sizeof(LNode));
	LNode* b3 = (LNode*)malloc(sizeof(LNode));
	LNode* b4 = (LNode*)malloc(sizeof(LNode));
	LNode* b5 = (LNode*)malloc(sizeof(LNode));
	LNode* b6 = (LNode*)malloc(sizeof(LNode));

	B->data = NULL;
	b0->data = 1;
	b1->data = 4;
	b2->data = 8;
	b3->data = 11;
	b4->data = 12;
	b5->data = 13;
	b6->data = 15;

	B->next = b0;
	b0->next = b1;
	b1->next = b2;
	b2->next = b3;
	b3->next = b4;
	b4->next = b5;
	b5->next = b6;
	b6->next = NULL;

	LNode* C = (LNode*)malloc(sizeof(LNode));

	merge(A, B, C);

	LNode* p = C->next;
	printf("归并后的数据: \n");
	while (p != NULL)
	{
		printf("%d\n", p->data);
		p = p->next;
	}
}

代码4: 链表的头插法归并

/// <summary>
/// 头插法归并单链表
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
/// <param name="C"></param>
void merge(LNode* A, LNode* B, LNode* C) {	
	LNode* p = A->next;		//p指向A中待归并的结点
	LNode* q = B->next;		//q指向B中待归并的结点
	LNode* s;				//s指向当前取出的最小值结点
	C->next = NULL;
	free(A);
	free(B);

	while (p != NULL && q != NULL)
	{
		if (p->data < q->data) {
			s = p;
			p = p->next;
			s->next = C->next;
			C->next = s;
		}
		else {
			s = q;
			q = q->next;
			s->next = C->next;
			C->next = s;
		}
	}

	while (p != NULL) {
		s = p;
		p = p->next;
		s->next = C->next;
		C->next = s;
	}
	while (q != NULL)
	{
		s = q;
		q = q->next;
		s->next = C->next;
		C->next = s;
	}
}

代码5: 头插法归并链表核心代码

oncruise
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
西南交通大学数据结构实验之有序线性表的归并参考实验报告
02-03
《西南交通大学数据结构实验之有序线性表的归并参考实验报告》 该实验报告主要涉及数据结构中的线性表和归并操作，是西南交通大学数据结构课程的一部分。实验的目标是掌握两个有序线性表的归并算法，分为顺序存储...
基于c语言+严蔚敏——线性表的合并（union）
geroci
03-22 4900
【注解】这里面用到的LocateItem(List L,int e)参数与LocateElem(List L,int e,compare())形式不同，没有用到caompare()函数，也算形式上稍有改变。关于我自定义的LocateItem函数参见基本操作文章里的定义。#include&lt;stdlib.h&gt;#include&lt;stdio.h&gt;#include&lt;malloc...
[数据结构]线性表合并
weixin_34218890的博客
02-09 3844
一、问题描述 线性表合并是程序设计语言编译中的一个最基本的问题，现在有两个线性表LA和LB，其中的元素都是按照非递减有序排列的，要将两个LA和LB归并为一个新的线性表LC，使得LC中的元素仍然是非递减有序的。 本实验的合并方式有两种。第一种是分别取LA和LB的第一个元素，即各自的最小的元素进行比较，选择较小的元素加入LC尾部，然后重复以上步骤；当LA表空了或者LB表空了的时候，将另一个表剩下的...
线性表的合并C/C++代码实现
热门推荐
Ycy的博客
06-02 1万+
1，无序线性表的合并 只要从B中依次取得每个数据元素， 并依值在A中进行查访， 若不存在， 则插入。 代码如下： #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAXSIZE 100 #define ElemType int #define Status int //顺序表的数据结构 typedef struct { ElemType *data; int length; }SqL
12.线性表的合并详解
YZSS17的博客
12-05 6243
线性表的合并 问题描述：假设利用两个线性表La和Lb分别表示两个集合A,B，现要求一个新的集合A=A∪B La=(7,5,3,11)Lb=(2,6,3)A=(7,5,3,11,2,6) 算法步骤：(A既是参数又是操作的结果) 依次(需要循环)取出Lb中的每个元素 在La中查找该元素如果没有插入到La表尾 这里的算法是通用的与La Lb的具体存储方式无关(不关心他们是用顺序表还是链表) 算法复杂度是两线性表表长的乘积 有序表的合并 问题描述：已知线性表La和Lb中的数据元素按值非递减有序排列，现要求
数据结构—一般线性表的合并
小虾米编程
06-21 1万+
1.一般线性表的合并 问题描述：假设利用两个线性表La和Lb分别表示两个集合A和B,现要求一个新的集合 A=A∪B。 La=(7, 5, 3, 11) Lb=(2, 6, 3) La=(7, 5, 3, 11, 2, 6) 算法步骤： 依次取出Lb中的每个元素，执行以下操作： 在La中查找该元素 如果找不到，则将其插入La的最后 2.顺序表实现 //合并 void...
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
将这两个有序线性表归并为一个有序线性表；输出归并后的有序线性表。 从键盘实现数据输入与输出的格式自拟；要求完成两个同样功能的程序，一个程序采用顺序存储结构，另一个程序采用链表实现线性表的存储。其中链表...
两个非递减存储顺序线性表归并为非递减顺序线性表
11-01
数据结构线性表的实现和归并 本文主要介绍数据结构中线性表的实现和归并，通过编写程序，建立两个非递减存储的顺序线性表，并将其归并为一个非递减顺序的线性表。 线性表的定义和实现 线性表是一种基本的数据结构...
数据结构实验1线性表归并及附加题详解
08-25
数据结构实验旨在让学生深入理解线性表的基本操作和高级操作，如归并和特定条件下的节点删除。实验涉及两个核心任务：一是两个有序线性表的归并，二是双向循环链表中满足条件节点的删除。 在归并有序线性表的实验中...
线性表合并
11-08
线性表是计算机科学中数据结构的一种基本形式，它是由n（n≥0）个相同类型元素构成的有限序列。线性表的操作在许多实际应用中都有广泛的应用，例如数据库索引、数组处理等。本资源"线性表合并.rar"提供的是关于...
线性表的应用——线性表的合并
菜菜的博客
04-15 3327
线性表的合并 初始条件：线性表la和lb 算法： 依次从lb中取出元素，查看是否存在la中，不存在则插入 顺序线性表的实现： //线性表的合并 void unionList(SqList* &la,SqList* &lb){ //从一个表中获取元素，再和另一个表中的数据进行比较 int lena,lenb; lena=GetLength(la); lenb=GetLength(lb); for(int i=1;i<=lena;i++){
线性表的合并
m0_55859452的博客
04-21 1298
C语言 数据结构
数据结构
Hao_Zhen的博客
10-31 405
数据结构： Data Structure = (D,L,S,O) D : Data数据 L：逻辑关系 S: 存储结构 O：规定的结构 存储结构： 1）顺序存储 2）链式存储 抽象数据结构： (D,L,O) 没有存储结构 算法分析： 时间复杂度：需要的时间资源 空间复杂度：需要的空间 ...
【数据结构】线性表的合并
lsj的博客
01-13 3009
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、问题解读二、无序集合求并集1.用顺序表描述2.用链表描述三、有序集合求并集1.用顺序表描述2.用链表描述总结 前言 数据结构线性表可以用来模拟集合，通过线性表的各种操作实现集合的基本运算。例如已知集合A和B，求A和B的并集A∪B。 一、问题解读 这里分无序集和有序集分别讨论。无论无序集和有序集，都可以用顺序表或者链表描述。下面是详细讨论。 二、无序集合求并集 1.用顺序表描述 /*-----合并顺序表La Lb----
合并两个线性表
09-22 970
指针自 #include    using namespace std;   typedef int element;   #define maxsize 100   typedef struct   {     element aa[maxsize];     int last;   }sqlist;   int compare(sqlist *la,int 
数据结构中线性表的合并（顺序表实现）
m0_62024160的博客
10-13 868
【代码】数据结构中线性表的合并（顺序表实现）
数据结构之线性表的应用——完整代码实现
weixin_64618739的博客
11-15 1345
数据结构之线性表的应用——完整代码实现
利用c语言将两个有序线性表归并为一个有序线性表。
最新发布
04-06
以下是一个简单的C语言程序，将两个有序线性表合并为一个有序线性表： ``` #include void merge(int arr1[], int m, int arr2[], int n, int result[]) { int i = 0, j = 0, k = 0; while (i ) { if (arr1[i] ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值