《数据结构》上机实验(第二章)——线性表Ⅰ

最新推荐文章于 2023-08-14 19:04:07 发布
最新推荐文章于 2023-08-14 19:04:07 发布
阅读量1.8k 收藏 19
点赞数 1
分类专栏： 《数据结构》上机实验 文章标签： 数据结构 算法 链表 visual studio c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42071236/article/details/119113531
版权

参考书目：《数据结构教程(第五版)》李春葆 主编
《数据结构》上机实验(第二章) Ⅱ
在这里插入图片描述

1.有一个带头结点的单链表 L = ( a 1 , b 1 , a 2 , b 2 , ⋯   , a n , b n ) L=(a_1,b_1,a_2,b_2,\cdots,a_n,b_n) L=(a1​,b1​,a2​,b2​,⋯,an​,bn​)，将其拆分成两个带头结点的单链表L1和L2，其中 L 1 = ( a 1 , a 2 , ⋯   , a n ) L1=(a_1,a_2,\cdots,a_n) L1=(a1​,a2​,⋯,an​)， L 2 = ( b n , b n − 1 , ⋯   , b 1 ) L2=(b_n,b_{n-1},\cdots,b_1) L2=(bn​,bn−1​,⋯,b1​)。要求L1使用L的头结点。

  • 算法思路：利用原单链表L中的所有结点通过改变指针域重组成两个单链表L1和L2。由于L1中结点的相对顺序与L中的相同，所以直接改变结点的指针域即可建立单链表L1；由于L2中结点的相对顺序与L中的相反，所以采用头插法建立单链表L2。
#include<stdio.h>
#include<malloc.h>
typedef int ElemType;
typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;

void InitList(LinkList &L) //初始化单链表
{
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
}

void CreateList(LinkList &L) //尾插法创建单链表
{
	LNode *p = L,*s;
	for (int i = 0; i < 10; i++)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = i;
		s->next = p->next;
		p->next = s;
		p = p->next;
	}
}

void PrintList(LinkList &L) //输出函数
{
	LNode* p = L->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}

void SplitList(LinkList& L, LinkList& L1, LinkList& L2) //拆分单链表L
{
	LNode* p = L->next, * q, * r1;
	L1 = L; //L1使用L的头结点
	r1 = L1; //r1指向L1
	L2 = (LinkList)malloc(sizeof(LNode*)); //创建L2的头结点
	L2->next = NULL; //置L2的指针域为NULL
	while (p != NULL)
	{
		r1->next = p; //采用尾插法将p插入L1中
		r1 = p;
		q = p->next;
		p = q->next;
		q->next = L2->next; //采用头插法将结点q插入L2中
		L2->next = q;
	}
	r1->next = NULL; //尾结点next置空
}

int main()
{
	LinkList L, L1, L2;
	InitList(L); //初始化单链表
	CreateList(L); //尾插法创建单链表
	printf("L中的值为：");
	PrintList(L); //调用函数，输出单链表L
	printf("\n");
	SplitList(L, L1, L2); //调用函数，拆分单链表L
	printf("L1中的值为：");
	PrintList(L1); //调用函数，输出单链表L1
	printf("\n");	
	printf("L2中的值为：");
	PrintList(L2); //调用函数，输出单链表L2
	printf("\n");
	return 0;
}

程序分析：

  • 由于L2采用尾插法，因此在第一次循环结束时，r1的指针域已经变为NULL。因此指针后移操作应该在r1的指针域变为NULL之前完成，当实现了后移操作后才能将r1的指针域与L2的指针域互换，否则后移操作会指向NULL。
    在这里插入图片描述
  • 运行结果：
    在这里插入图片描述
  • p刚开始指向L链表中的首结点，每一次while循环，p向后移动了两个结点的位置，当q为NULL时修改当前p指向的结点的指针域(置为NULL)，此时再循环已经不满足条件了，循环结束。由于L1使用L的头结点，因此L1不需要开辟新的存储单元，而L2则需要开辟新的存储单元。
  • 时间复杂度： Ｏ ( n 2 ) Ｏ(\frac{n}{2}) Ｏ(2n​)；空间复杂度： O ( n 2 ) O(\frac{n}{2}) O(2n​)

2.删除一个单链表L中最大的结点(假设这样的结点唯一)。

  • 算法思路：在单链表中删除一个结点先要找到它的前驱结点，用指针p扫描整个单链表，pre指向结点p的前驱结点，在扫描时用max指向data域值最大的结点，mapre指向max所指结点的前驱结点。当单链表扫描完毕后，通过maxpre所指结点删除其后的结点，即删除了结点值最大的结点。
void CreateList(LinkList& L) //尾插法创建单链表
{
	LNode *p = L,*s;
	int num;
	printf("输入：\n");
	scanf("%d ", &num);
	while(num != 999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = num;
		s->next = p->next;
		p->next = s;
		p = p->next;
		scanf("%d", &num);
	}
}

void MaxNum(LinkList &L)
{
	LNode* p = L->next, * pre = L, * max=p, * maxpre=L;
	ElemType maxnum=max->data;
	while (p != NULL)
	{
		if (p->data > maxnum)
		{
			max = p;
			maxnum = max->data;
			maxpre = pre;
		}
		pre = p;
		p = p->next;
	}
	maxpre->next = max->next;
	free(max);
}
CreateList(L);
MaxNum(L);

程序分析：

  • 通过scanf函数来给链表中各结点的数据域赋值，当输入999时，表示结束，不再开辟新的单元。
  • ！要注意最大值在首结点的情况。
    这里是引用
  • 运行结果：
    在这里插入图片描述
  • 时间复杂度： Ｏ ( n ) Ｏ(n) Ｏ(n)；空间复杂度： O ( 1 ) O(1) O(1)

3.有一个带头结点的单链表L(至少有一个数据结点)，使其递增有序排列。

  • 算法思路：由于单链表L中有一个以上的数据结点，首先构造一个只含头结点和首结点的有序单链表(只含一个数据结点的单链表一定是有序的)。然后扫描单链表L余下的结点(由p指向)，有序单链表中通过比较找插入结点p的前驱结点(由pre指向它)，在pre结点之后插入p结点。
void SortNumber(LinkList &L)
{
	LNode* p = L->next->next, * s, * pre;
	L->next->next = NULL;
	while (p != NULL)
	{	
		s = p->next;
		pre = L;
		while (pre->next != NULL && pre->next->data < p->data)
			pre = pre->next;
		p->next = pre->next;
		pre->next = p;
		p = s;
	}
}

程序分析：

在这里插入图片描述

  • 运行结果：
    这里是引用
  • 时间复杂度： Ｏ ( n 2 ) Ｏ(n^2) Ｏ(n2)；空间复杂度： O ( 1 ) O(1) O(1)

4.一个带头结点的双链表L，将其所有元素逆置。

算法思路：先构造只有一个头结点的空双链表L(利用原来的头结点)，用p扫描双链表的所有数据结点，采用头插法将所指结点插入到L中。

void DiverseDList(DLinkList &L)
{
	DNode* p = L->next, * s;
	L->next = NULL;
	int i = 1;
	while (p!=NULL)
	{
		s = p->next;
		p->next = L->next;
		if (L->next != NULL)
			L->next->prior = p;
		p->prior = L;
		L->next = p;
		p = s;
	}
}

程序分析：

  • 运行结果：
    在这里插入图片描述
  • 时间复杂度： Ｏ ( n ) Ｏ(n) Ｏ(n)；空间复杂度： O ( 1 ) O(1) O(1)

5.有一个带头结点的双链表L(至少有一个数据结点)，使其元素递增有序排列。

  • 算法思路：参考第三题。

程序分析：

  • 运行结果：
    在这里插入图片描述
  • 时间复杂度： Ｏ ( n 2 ) Ｏ(n^2) Ｏ(n2)；空间复杂度： O ( 1 ) O(1) O(1)

6.有一个带头结点的循环单链表L，统计其data域值为x的结点个数。

  • 算法思路：扫描整个循环单链表，用count累计data域值为x的结点个数。
#include<stdio.h>
#include<malloc.h> //用malloc函数开辟新单元时需用此头文件
typedef int ElemType;
typedef struct LNode //定义单链表结点类型
{
	ElemType data; //数据域
	struct LNode* next; //指针域
}LNode, *LinkList;

void InitList(LNode * &L) //初始化线性表
{
	L = (LNode *)malloc(sizeof(LNode)); //创建头结点
	L->next = L; //其next域置为NULL
}

void CreateListR(LinkList &L) //头插法创建单链表
{
	LNode* s;
	int num;
	printf("输入：\n");
	scanf("%d", &num);
	while (num != 999)
	{
		s = (LNode*)malloc(sizeof(LNode)); //分配一个新的结点
		s->data = num;
		s->next = L->next;
		L->next = s;
		scanf("%d", &num);
	}
}

void DispList(LinkList &L) //输出单链表
{
	LNode* p = L->next; //p指向首结点
	while (p->next!=L)
	{
		printf("%d ", p->data); //输出p结点的data域
		p = p->next; //p移向下一个结点
	}
}

int CountNum(LinkList &L, ElemType num)
{
	LNode* p=L->next;
	int count = 0; //用来计数
	while (p != L) //当前结点不是尾结点
	{
		if (p->data == num) count++; //如果data域的值与num相等，计数值+1
		p = p->next; //指针后移
	}
	return count;
}

int main()
{
	LNode* L;
	InitList(L);
	CreateListR(L);
	printf("循环单链表中各元素的值为：");
	DispList(L);
	printf("\n");
	printf("单链表中与该数相等的数有：%d个",CountNum(L, 2));
}

程序分析：

  • 运行结果：
    在这里插入图片描述

7.有一个带头结点的循环双链表L，删除第一个data域值为x的结点。

  • 算法思路：指针扫描整个循环双链表来查找data值为x的结点，找到后删除p结点，并返回true，若未找到这样的结点返回false。
#include<iostream>
using namespace std;
#include<malloc.h> //用malloc函数开辟新单元时需用此头文件
typedef int ElemType;
typedef struct DNode //定义双链表结点类型
{
	ElemType data; //数据域
	struct DNode* prior; //指针域
	struct DNode* next; //指针域
}DNode, *DLinkList;

void InitList(DNode * &L) //初始化线性表
{
	L = (DNode *)malloc(sizeof(DNode)); //创建头结点
	L->prior = L; //其next域置为NULL
	L->next = L; //其next域置为NULL
}

int ListLength(DLinkList &L)
{
	DNode* p = L->next;
	int length = 0;
	while (p != L)
	{
		length++;
		p = p->next;
	}
	return length;
}

void CreateListF(DLinkList &L) //头插法创建双链表
{
	DNode* s;
	int num;
	printf("输入：\n");
	scanf("%d", &num);
	while (num != 999)
	{
		s = (DNode*)malloc(sizeof(DNode));
		s->data = num;
		s->next = L->next;
		s->next->prior = s;
		s->prior = L;
		L->next = s;
		scanf("%d", &num);
	}
}

void DispList(DLinkList &L) //输出双链表
{
	DNode* p = L->next; //p指向首结点
	while (p!=L)
	{
		printf("%d ", p->data); //输出p结点的data域
		p = p->next; //p移向下一个结点
	}
}

bool DeleteElem(DLinkList& L, ElemType num)
{
	DNode* p = L->next;
	while (p != L)
	{
		if (p->data == num)
		{
			p->prior->next = p->next;
			p->next->prior = p->prior;			
			free(p);
			return true;
		}
		p = p->next;
	}
	return false;
}

int main()
{
	DNode* L;
	InitList(L);
	CreateListF(L);

	printf("循环单链表中各元素的值为：");
	DispList(L);
	printf("\n");

	printf("当前循环双链表的长度为：%d",ListLength(L));
	printf("\n");

	cout << boolalpha << "删除成功了吗？——" << DeleteElem(L, 2) << endl;
	printf("当前循环双链表的长度为：%d", ListLength(L));
	printf("\n");
	printf("循环单链表中各元素的值为：");
	DispList(L);
	printf("\n");
}

程序分析：

  • 该算法利用循环双链表L的特点，通过L->prior直接找到尾结点，然后进行结点值的比较，从而判断L的数据结点是否对称。如果是非循环双链表，需要通过遍历查找尾结点，显然不如循环链表的性能好。
  • 运行结果：
    在这里插入图片描述

8. 判断带头结点的循环双链表L(含两个以上的结点)中的数据结点是否对称。

  • 算法思路：用p从左向右扫描L，q从右向左扫描L，然后循环。若p、q所指结点的data域不相等，则退出循环，返回false；否则继续比较，直到p==q(数据结点个数为奇数的情况)或者p.next==q(数据结点个数为偶数的情况)为止，这时返回true。
bool SymmElem(DLinkList& L)
{
	DNode* p = L->next, * q = L->prior;
	bool same = true;
	while (same)
	{
		if (p->data != q->data) same = false;
		else 
		{
			if (p == q || p->next == q) break;
			p = p->next;
			q = q->prior;
		}
	}
	return same;
}

程序分析：

  • 运行结果：
    在这里插入图片描述

9. 假设有两个表A和B，分别是 m 1 m_1 m1​行、 n 1 n_1 n1​列和 m 2 m_2 m2​行、 n 2 n_2 n2​列，它们简单自然连接结果C=A(自然链接i=j)B，其中i表示表A中列号，j表示表B中的列号，C为A和B的笛卡儿积中满足指定连接条件的所有记录组，该连接条件为表A的第i列与表B的第j列相等。

#include<stdio.h>
#include<malloc.h>
#define MaxCol 10 //最大列数
typedef int ElemType;
typedef struct Nodel //定义数据结点类型
{
	ElemType data[MaxCol]; //存放一行的数据
	struct Nodel* next; //指向后继数据节点
}DList; //行结点类型

typedef struct Node2
{
	int Row, Col; //行数和列数
	DList* next; //指向第一个数据结点
}HList; //头结点的类型

void CreateTable(HList* &h) //采用交互式方式建立单链表
{
	int i, j;
	DList * r, * s;
	h = (HList *)malloc(sizeof(HList)); //创建头结点
	h->next = NULL;
	printf("表的行数、列数：");
	scanf("%d%d", &h->Row, &h->Col); //输入表的行数和列数
	for (i = 0; i < h->Row; i++) //输入所以行的数据
	{
		printf("第%d行：", i + 1);
		s = (DList*)malloc(sizeof(DList));
		for (j = 0; j < h->Col; j++) //创建数据结点s
			scanf("%d", &s->data[j]); //输入一行的数据
		if (h->next == NULL) h->next = s; //插入第一个数据结点的情况
		else r->next = s; //插入其他数据结点的情况
		r = s; //r始终指向尾结点
	}
	r->next = NULL; //尾结点的next域置空
}

void DispTable(HList*& h)//输出单链表
{
	int j = 0;
	DList* p = h->next; //p指向开始行结点
	while (p != NULL) //扫描所有行
	{
		for (j = 0; j < h->Col; j++) //输出一行的数据
			printf("%4d", p->data[j]);
		printf("\n");
		p = p->next; //p指向下一个行节点
	}
}

void DestroyTable(HList*& h) //销毁单链表
{
	DList* pre = h->next, * p = pre->next;
	while (p != NULL)
	{
		free(pre);
		pre = p;
		p = p->next;
	}
	free(pre);
	free(h);
}

void LinkTable(HList *h1,HList* h2, HList*& h) //表连接
{
	int i, j, k;
	DList* p = h1->next, * q, * s, * r;
	printf("连接字段是：第1个表序号,第2个表序号：");
	scanf("%d%d", &i, &j);
	h = (HList*)malloc(sizeof(HList)); //创建结果表头结点
	h->Row = 0; //置行数为0
	h->Col = h1->Col + h2->Col; //置列数为表1和表2的列数和]
	h->next = NULL; //置next域为NULL
	while (p != NULL) //扫描表1
	{
		q = h2->next; //q指向表2的首结点
		while (q != NULL) //扫描表2
		{
			if (p->data[i - 1] == q->data[j - 1]) //对应字段值相等
			{
				s = (DList*)malloc(sizeof(DList)); //创建一个数据结点s
				for (k = 0; k < h1->Col; k++) //复制表1的当前行
					s->data[k] = p->data[k];
				for (k = 0; k < h2->Col; k++)
					s->data[h1->Col + k] = q->data[k]; //复制表2的当前行
				if (h->next == NULL) //若插入的是第一个数据结点
					h->next = s; //将s结点插入到头结点之后将s结点插入到结点r之后
				else
					r->next = s; //若插人其他数据结点
				r = s; //r始终指向尾结点
				h->Row++; //表行数增1
			}
			q = q->next; //表2后移一个结点
		}
		p = p->next; //表1后移一个结点
	}
	r->next = NULL; //表尾结点的next域置空				
}


int main()
{
	HList* h1, * h2, * h; 
	printf("表1：\n");
	CreateTable(h1); //创建表1
	printf("表2：\n");
	CreateTable(h2); //创建表2
	LinkTable(h1, h2, h); //连接两个表
	printf("连接结果表：\n");
	DispTable(h); //输出连接结果
	DestroyTable(h1); //销毁单链表h1
	DestroyTable(h2); //销毁单链表h2
	DestroyTable(h); //销毁单链表h
	return 0;
}

程序分析：

  • 建立单链表的时间复杂度为 O ( m × n ) O(m×n) O(m×n)，其中m为表的行数、n为表的列数。
  • 销毁单链表的时间复杂度为 O ( m ) O(m) O(m)，其中m为表的行数。
  • 输出单链表的时间复杂度为 O ( m × n ) O(m×n) O(m×n)，其中m为表的行数、n为表的列数。
    在这里插入图片描述
  • 运行结果：
    在这里插入图片描述

10. 已知3个带头结点的单链表LA、LB和LC中的结点均依元素值递增排列(假设每个单链表不存在数据值相同的结点，但3个单链表中可能存在数据值相同的结点)，设计一个算法对LA链表进行如下操作：使操作后的链表LA中仅留下3个表中均包含的数据元素的结点，且没有数据值相同的结点，并释放LA中所有的无用结点。

  • 算法思想：先以单链表LA的头结点作为一个空表，r指向这个新建单链表的尾结点。以pa扫描单链表LA的数据结点，判断它是否在单链表LB和LC中，若同时在LB和LC中，表示pa所指结点是公共元素，则将其链接到r所指结点之后，否则删除之。
void CommNode(LinkList& LA, LinkList& LB, LinkList& LC)
{
	LNode* pa = LA->next, * pb = LB->next, * pc = LC->next, * r = LA, * p ; 
	LA->next = NULL; //此时LA作为新建单链表的头结点
	while (pa != NULL)
	{
		while (pb != NULL && pa->data > pb->data) //pa结点与LB中的pb结点进行比较
			pb = pb->next;
		while (pc != NULL && pa->data > pc->data) //pa结点与LC中的pc结点进行比较
			pc = pc->next;
		if (pb != NULL && pc != NULL &&
			pa->data == pb->data && pa->data == pc->data) //若pa是公共结点
		{
			r->next = pa; //将pa结点插入到LA中
			r = pa;
			pa = pa->next; //pa移向下一个结点
		}
		else //若pa结点不是公共结点，则删除
		{
			p = pa;
			pa = pa->next; //pa移向下一个结点
			free(p); //释放非公共结点
		}
	}
	r->next = NULL;
}

程序分析：

  • 在上述算法中，指向LA、LB、LC单链表的指针pa、pb、pc都没有出现回溯过程，即每个单链表均只扫描一遍，所以算法的时间复杂度为O(m+n+p)，空间复杂度O(1)。其中m、n、p分别是3个表的长度。在这里插入图片描述
  • 运行结果：
    在这里插入图片描述
—Miss. Z—
关注
  • 1
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lesson19-2 《数据结构与算法》P35Q36拆分单链表
csdner1998的博客
08-23 813
题目描述： 编写算法将单链表L1拆成两个表，其中以L1为头的链表保持原来向后的链接，另一个以L2为头的链表，其链接方向与L1相反，L1包含原链表的奇数序号结点，L2包含原链表的偶数序号结点。 思路： 对一个链表进行部分逆置或其他操作时，可以用 i 来保存结点的序号，更简便。 代码： void breakList(LNode *L1){ int i=0;//i表示结点序号 LNode *L2=new LNode();//L2为偶数序号链表，L1为奇序号链表 L2->next=NULL;
《数据结构》实验二： 线性表综合实验——（1）顺序表
hpnynljy的博客
03-20 1867
《数据结构》实验二：                线性表综合实验一．实验目的     巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二．实验时间   准备时间为第3周到第4周，具体集中实验时间为第4周第2次课。2个学时。 三．.实验内容1.建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入...
单链表的基本操作之部分习题的讲解
weixin_56169816的博客
05-05 1482
单链表的基本操作之习题篇 1、有一个线性表（a1,a2,a3,…an），n>=2，采用带头结点的单链表L存储，设计一个算法将其就地逆置，空间复杂度为O（1） 解题思路1： ​ 用指针p遍历原单链表，先将头节点L的next域置为NULL而变成一个空链表，然后节点采用头插法插入L中。 示例图： 对应算法如下： void ReverseLinkList(LinkList& L) { LNode* p = L->next, * q; L->next = NULL; //将L
单链表的拆分
最新发布
qq_64296768的博客
08-14 291
注意：由于L1是继承L的头结点，故不需要对L1使用malloc，而L2没有头结点，则需要对其采用malloc创建一个头结点，头插法尤其要注意提前保留其插入或者删除结点的下一个结点的位置，避免链表之后的数据结点信息的丢失。
数据结构线性表课后习题（数据结构考试重点）
热门推荐
kaakllhjkhjalv的博客
07-08 1万+
1. 简述线性表两种存储结构各自的主要特点。 答：线性表的两种存储结构分别是顺序存储结构和链式存储结构。顺序存储结构的主 要特点如下： ① 数据元素中只有自身的数据域，没有关联指针域。因此，顺序存储结构的存储密度 较大。 ② 顺序存储结构需要分配一整块比较大存储空间，所以存储空间利用率较低。 ③ 逻辑上相邻的两个元素在物理上也是相邻的，通过元素的逻辑序号可以直接其元素 值，即具有随机存取特性。 ④ 插入和删除操作会引起大量元素的移动。 链式存储结构的主要特点如下： ① 数据结点中除自身的数据域，还有表示逻辑
【Dev-c++】C语言数据结构实验——线性表
m0_52474147的博客
07-24 6894
基本原理在顺序表的第i个位置上插入一个元素时，必须先将线性表的第i个元素之后的所有元素依次后移一个位置，以便腾空一个位置，在把新元素插入到该位置。如，在第2个位置上插入元素43，然后输出顺序表。基本原理在带头结点的单链表中第i（从1开始计数）个位置之后插入元素、创建带头结点的单链表、在带头结点的单链表中删除第i个位置的元素等，最后输出单链表的内容。3）将未完成的代码补充完整，然后选择菜单中的“组建”下拉菜单中的“执行”，或者直接点击工具栏中的“”进行连接，调试和运行。...
C++与数据结构 第一次上机实验——线性表.pdf
11-07
本文主要讨论了C++编程中关于数据结构中的线性表，包括线性表的定义、顺序存储结构和链式存储结构的特点，以及如何通过C++实现线性表的相关操作，如插入、删除和查找等。 线性表是一种数据结构，其中的元素之间存在...
C++与数据结构 第一次上机实验——线性表.docx
11-07
【线性表】是计算机科学中一种基本的数据结构，它由有限个相同类型元素构成的序列，元素之间存在一对一的线性关系。线性表可以采用两种主要的存储方式：顺序存储结构和链式存储结构。 **顺序存储结构**是指用一组...
《数据结构》第二章线性表习题.doc
12-01
"《数据结构》第二章线性表习题" 本资源摘要信息对应的知识点主要涉及到数据结构的第二章线性表习题，包括线性表的定义、链式存储、顺序存储、单链表、双向循环链表、栈和队列等概念。 一、线性表的定义 线性表是...
数据结构实验——线性表子系统
07-31
线性表是数据结构中最基础且重要的概念之一，它是由n(n≥0)个相同类型元素组成的有限序列。在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和...
数据结构上机实验答案
12-08
数据结构上机实验答案，调试好的，线性表，队列，冒泡排序，希尔排序，快速排序，哈夫曼树相关实验．有详细的程序注释．
数据结构作业：第2章-线性表作业答案.docx
12-16
数据结构作业：第2章-线性表作业答案 本文将详细解释数据结构中的线性表概念，並通過多个选择题和问题，帮助读者深入理解线性表的存储方式、操作和特点。 一、线性表的定义 线性表是一种具有n个有限序列（n>0）的...
数据结构:线性表的基本操作小实验
m0_63464778的博客
01-01 1618
本文将通过完成以下内容来展示在数据结构中线性表的一些基本操作，代码解释标注全面而且清晰，代码书写也按照规范，适合初学者进行学习，前期的细节准备能够为后期建立属于自己的数据结构库打下坚实基础，本篇文章算是本人的一些学习记录分享，希望对有需要的小伙伴提供一些帮助~
数据结构 线性表实验（stl vector实现）
Flame__Yan的博客
10-03 1753
记录一次数据结构实验作业
数据结构 线性表实验
sinb妃的博客
09-11 6725
实验目的： 1、掌握线性表的定义； 2、掌握线性表的基本操作，如建立、查找、插入和删除等。 实验内容： 定义一个包含学生信息（学号，姓名，成绩）的的顺序表和链表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； (5) ...
【实验一】数据结构：线性表
weixin_49003900的博客
11-06 2696
数据结构，实验一，线性表，内容：递增有序顺序表的插入、两个有序链表序列的交集、简单计算器、银行业务队列简单模拟
数据结构实验——线性表
weixin_45823684的博客
01-03 753
线性表比较，返回子表
数据结构教程（第五版 李春葆 上机实验题2 前七题）
L093117l的博客
09-26 4771
数据结构教程（第五版 李春葆 上机实验题2 前七题）
数据结构 第二章 线性表(1)
weixin_62917800的博客
04-04 3175
目录 2.1 线性表的定义和特点 2.2 案例引入 2.3 线性表的类型定义 2.4 线性表的顺序表示和实现 2.4.1线性表的顺序存储表示 2.4.2 顺序表中基本操作的实现 线性结构的基本特点是除第一个元素无直接前驱，最后一个元素无直接后继之外，其他每个数据元素都有一个前驱和后继。线性表是最基本且最常用的一种线性结构，同时也是其他数据结构的基础，尤其单链表，是贯穿整个数据结构课程的基本技术。本章将讨论线性表的逻辑结构、存储结构和相关运算，以及线性...
数据结构各个实验指导书.pdf
07-12
"这是一本数据结构的实验指导书，主要涵盖了数据结构中的核心概念和算法，包括线性表、栈、队列、串、二叉树、图、哈希表以及排序算法的实践操作。这本书是针对南京工程学院通信工程学院的信息工程和计算机通信专业...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值