【严蔚敏数据结构题集】C/C++编程线性表练习题（一）

最新推荐文章于 2022-08-28 18:53:51 发布
最新推荐文章于 2022-08-28 18:53:51 发布
阅读量1.7k 收藏 22
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QianQing_mio/article/details/123295139
版权

都是自己练习的，难免有不对的地方，有错误欢迎纠正

线性表练习题

习题2.11-2.20

2.11设顺序表va中的数据元素递增有序。试写一算法，将x插入到顺序表的适当位置上，以保持该表的有序性。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define MAXSIZE  100

typedef struct {
	int *elem;
	int length;
}SqList;

void PrintList(SqList *L);
void InitList(SqList *L);
int Insert(SqList *L, int x);

void main()
{
	SqList  va;
	InitList(&va);
	PrintList(&va);
	int x;
	printf("Enter a number:");
	scanf("%d", &x);
	Insert(&va, x);
	PrintList(&va); 
	return;
}
int Insert(SqList *L,int x)
{
	if (L->length == MAXSIZE)//顺序表满了，不进行操作
		return -1;
	int i = 0;
	while (x > L->elem[i] && i < L->length)//找出插入位置i
	{
		++i;
	} 
	for (int j = L->length; j > i; --j)//将第length-1到第i个元素都向后移动一个位置
	{
		L->elem[j] = L->elem[j - 1];
	}
	L->elem[i] = x;
	L->length++;
	return 0;
}
void InitList(SqList *L)
{
	L->elem = (int)malloc(MAXSIZE);
	if (!L->elem)
		exit(1);
	L->length = 0;
	//初始化一个20个元素的顺序表，可随意发挥初始化
	for (int i = 0; i < 20; i++)
	{
		L->elem[i] = i * 5;
		L->length++;
	}
}
void PrintList(SqList *L)//打印顺序表
{
	for (int i = 0; i < L->length; ++i)
	{
		printf("%d  ", L->elem[i]);
	}
	printf("\n");
}

运行结果：
在这里插入图片描述
在这里插入图片描述
2.12设A=(a1,…,am)和B=(b1,…,bn)均为顺序表，A’和B’分别为A和B中除去最大共同前缀后的子表（例如，A=（x,y,y,z,x,z）,B=(x,y,y,z,y,x,x,z)）,则两者中最大的共同前缀为(x,y,y,z),在两表中除去最大共同后缀的子表分别为A’=(x,z）和B’=(y,x,x,z))。若A’=B’=空表，则A=B；若A’=空表而B’≠空表，或者两者均不为空表，且A’的首元小于B’的首元，则A<B；否则A>B。试写一个比较A，B大小的算法（请注意：在算法中不要破坏原表A和B，并且，也不一定先求得A’和B’才进行比较）。

#include <stdio.h>
#define MAXSIZE  100
typedef struct {
	char *elem;
	int length;
}SqList;
void InitList(SqList *L);//初始化顺序表
void PrintList(SqList  L);//打印顺序表
void compareList(SqList A, SqList B);//比较A和B
int main()
{
	SqList A, B;
	printf("Enter List A: ");
	InitList(&A);
	PrintList(A);
	printf("Enter List B: ");
	InitList(&B);
	PrintList(B);
	compareList(A, B);
	free(A);
	free(B);
	return;
}
void compareList(SqList A, SqList B)
{
	if (A.length == 0 && B.length == 0)
		printf("A==B");
	else if(A.length == 0){
		printf("A<B");
	}
	else if(B.length==0){
		printf("A>B");
	}
	else {
		int i = 0;
		while (A.elem[i] == B.elem[i])
		{
			++i;
		}
		if (A.elem[i] > B.elem) {
			printf("A>B");
		}
		else
		{
			printf("A<B");
		}
	}
}
void InitList(SqList *L)
{
	L->elem = (char*)malloc(MAXSIZE);
	if (!L->elem)
		exit(1);
	int length=0;
	char inputChar[MAXSIZE];
	char character = ' ';
	while (character != '\n')
	{
		character = getchar();
		if (character != '\n'){
			inputChar[length] = character;
			++length;
		}
		else
			break;
	}	
	L->length = length;
	for (int i = 0; i < length; ++i)
	{
		L->elem[i] = inputChar[i];
	}
}
void PrintList(SqList  L)
{
	for (int i = 0; i < L.length; ++i)
	{
		printf("%c  ", L.elem[i]);
	}
	printf("\n");
}

运行结果：
A、B都为空时：
在这里插入图片描述
A不空，B空：
在这里插入图片描述
A空，B不空
在这里插入图片描述
AB都不空：
在这里插入图片描述
2.13试写一算法在带头结点的单链表结构上实现线性表操作LOCATE(L,X)。

#include <stdio.h>
typedef struct LNode {
	char data;						//数据域，这里设为字符型
	struct LNode *next;    //指针域
}LNode, *LinkList;           //LinkLis为指向结构体LNode的指针类型
void PrintList(LNode * L);//打印链表
void  InitList(LNode *L);//尾插法构建单链表
LNode *LocateData(LNode *L, char x);//查值的地址操作

void main()
{
	LinkList L = (LNode *)malloc(sizeof(LNode));//头节点
	if (!L)
		exit(1);
	L->next = NULL;
	InitList(L);//初始化
	PrintList(L);//打印
	printf("Enter the elem that you need：");
	char x=getchar();
	LNode *node=LocateData(L, x);//查询地址
	if (node)
		printf("%c is stored at address of  %u\n", x, node);
	else
		printf("there is no %c on the list\n",x);
	return;
}
LNode *LocateData(LNode* L, char x)
{
	LinkList p=L->next;
	while (p)
	{
		if (p->data == x)//找到了
			break;
		else
			p = p->next;
	}
	return p;//返回地址
}
void InitList(LNode *L)//尾插法初始化单链表
{
	LinkList q = L;//q指向p前面一个节点
	printf("Enter the list's value\n");
	char ch = ' ';
	int len = 0;
	while (ch!='\n')
	{
		ch = getchar();
		if (ch != '\n')
		{
			LinkList p = (LNode *)malloc(sizeof(LNode));
            if (!p)
     		exit(1);
			p->data = ch;
			p->next = NULL;
			q->next = p;
			q = q->next;
			len++;
		}
		else
			break;
	}
}
void PrintList(LNode *L )
{
	LinkList p = L->next;
	while (p)
	{
		printf("%c", p->data);
		p = p->next;
	}
	printf("\n");
}

运行结果：
在这里插入图片描述
2.14试写一算法在带头结点的单链表结构上实现线性表操作LENGTH(L)。

#include <stdio.h>
typedef struct LNode {
	char data;						//数据域，这里设为字符型
	struct LNode *next;    //指针域
}LNode, *LinkList;           //LinkLis为指向结构体LNode的指针类型
void PrintList(LNode * L);//打印链表
void  InitList(LNode *L);//尾插法构建单链表
int ListLength(LNode *L);//返回元素的个数

void main()
{
	LinkList L = (LNode *)malloc(sizeof(LNode));//头节点
	if (!L)
		exit(1);
	L->next = NULL;
	InitList(L);//初始化
	//PrintList(L);//打印
	printf("The list have %d nodes(include the head node) ",ListLength(L));
	return;
}
int ListLength(LNode *L)
{
	int len = 0;
	LinkList p = L;
	while (p)
	{
		++len;
		p = p->next;
	}
	return len;
}
void InitList(LNode *L)//尾插法初始化单链表
{
	LinkList q = L;//q指向p前面一个节点
	printf("Enter the list's value\n");
	char ch = ' ';
	int len = 0;
	while (ch != '\n')
	{
		ch = getchar();
		if (ch != '\n')
		{
			LinkList p = (LNode *)malloc(sizeof(LNode));
			if (!p)
				exit(1);
			p->data = ch;
			p->next = NULL;
			q->next = p;
			q = q->next;
			len++;
		}
		else
			break;
	}
}
void PrintList(LNode *L)
{
	LinkList p = L->next;
	while (p)
	{
		printf("%c", p->data);
		p = p->next;
	}
	printf("\n");
}

运行结果：
在这里插入图片描述
2.15已知指针ha和指针hb分别指向两个单链表的头结点，并且已知两个链表的长度分别为m和n。试写一算法将这两个链表连接在一起（即令其中一个表的首元结点连在另一个表的最后一个结点之后），假设指针hc指向连接后的链表的头结点，并要求算法以尽可能短的时间完成运算。请分析你的算法的时间复杂度。

#include <stdio.h>
typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode,*LinkList;
void junction(LNode *ha, LNode *hb);//连接两个单链表
int InitList(LNode *L);//初始化链表
void PrintList(LNode* L);
void main()
{
	int m = 0,n=0;
	LinkList ha = (LNode*)malloc(sizeof(LNode));
	if (!ha)
		return;
	LinkList hb = (LNode*)malloc(sizeof(LNode));
	if (!hb)
		return;
	ha->next = NULL;
	hb->next = NULL;
	m=InitList(ha);
	n=InitList(hb);
	printf("ha list:");
	PrintList(ha);
	printf("hb list:");
	PrintList(hb);
	junction(ha, hb);
	LinkList hc = ha;
	printf("the list after junction:");
	PrintList(hc);
	return;
}
void junction(LNode *ha, LNode *hb)
{
	LinkList p = ha;
	while (p->next)
	{
		p = p->next;
	}
	p->next = hb->next;
}
int InitList(LNode *L)
{
	int num,len=0;
	LinkList q = L;
	printf("Enter the num of the list:\n");
	scanf("%d",&len);
	printf("Enter the value:\n");
	for (int i = 0; i < len; ++i)
	{
		scanf("%d", &num);
		LinkList p = (LNode*)malloc(sizeof(LNode));
		if (!p)
			exit(1);
		p->data = num;
		p->next = NULL;
		q->next = p;
		q = q->next;
	}
	return len;
}
void PrintList(LNode *L)
{
	LinkList p = L->next;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

运行结果：
在这里插入图片描述
在这里插入图片描述
2.16已知指针la和lb分别指向两个无头结点单链表中的首元结点。下列算法是从表la中删除 自第i个元素起共len个元素后，将它们插入到表lb中第j个元素之前，试问此算法是否正确？若有错，则请改之。

Status DeleteAndInsertSub(LinkedList la,LinkedList lb,int i,int j,int len){
	if(i<0||j<0||len<0)return INFEASIBLE;
		p=la;k=1;
		while(k<i){p=p->next;k++;}
		q=p;
		while(k<len){q=q->next;k++;}
		s=lb;k=1;
		while(k<j){s=s->next;k++;}
		s->next=p;q->next=s->next;
		return OK;
}//DeleteAndInsertSub

更改后的算法

Status DeleteAndInsertSub(LinkedList la,LinkedList lb,int i,int j,int len){
	if(i<0||j<0||len<0)return INFEASIBLE;
		p=la;k=1,prev=NULL;
		while(p&&k<i)//找到la表中第i个结点p
		{prev=p;p=p->next;k++;}
		if(!p)return INFEASIBLE;
		q=p;k=1;
		while(q&&k<len)//找到la表中第i+len-1个结点
		{q=q->next;k++}
		if(!q)return INFEASIBLE;
		if(!prev)la=q->next;//i=1的情况
		else prev->next=q->next;//完成删除
		//将从la中删除的结点插入到lb中
		if(j==1){q->next=lb;lb=p}
		else{
			s=lb;k=1;
			while(s&&k<j-1)
			{s=s->next;k++;}//查找lb表中的第j-1个元素
			if(!s)return INFEASIBLE;
			q->next=s->next;
			s->next=p;//完成插入
			return OK;
		}
}//DeleteAndInsertSub

2.17试写一算法，在无头结点的动态单链表上实现线性表操作INSERT(L,i,b),并和在带头结点的动态单链表上实现相同操作的算法进行比较。

（1）无头结点：（比起有头结点的单链表要注意首元结点的插入）

#include <stdio.h>
typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode, *LinkList;
LNode * InitList();
void PrintList(LNode *L);//打印列表
void InsertList(LNode **L, int i, int b);//在第i个位置插入列表

void main()
{
	LinkList L = InitList();
	printf("before:");
	PrintList(L);
	int i,b;
	printf("Enter the location:");//输入待插入元素的位置
	scanf("%d", &i);
	printf("Enter the number you want to insert into the list:");//输入待插入元素的值
	scanf("%d", &b);
	InsertList(&L, i, b);
	printf("after:");
	PrintList(L);
	return;
}
void InsertList(LNode **L, int i, int b)//插入的位置可能是首元结点所以传L的值必须传地址，
{																		//否则会出现无法插入元素到首元结点的现象
	LinkList p = *L;
	LinkList q=*L;
	if (i == 1)//若在插入的位置是首元位置
	{
		LinkList newNode = (LNode *)malloc(sizeof(LNode));//生成新节点
		if (!newNode)
			exit(1);
		newNode->data = b;
		newNode->next =*L;
		*L = newNode;
	}
	else//若在插入的位置不是首元位置
	{
		int j = 1;//从第一个位置开始找
		while (p && (j < i - 1))//找到第i-1的位置，p指向i-1
		{
			p = p->next;
			++j;
		}
		if (!p || j > i)//插入的位置大于列表的长度
		{
			exit(1);
		}
		LinkList newNode = (LNode *)malloc(sizeof(LNode));//生成新节点
		if (!newNode)
			exit(1);
		newNode->data = b;
		newNode->next = p->next;
		p->next = newNode;
	}
}
LNode * InitList()
{
	int num, len = 0;
	LinkList  L=NULL;
	LinkList q = NULL;//q用来保存当前结点的前驱
	printf("Enter the length of the list:\n");
	scanf("%d", &len);
	printf("Enter the value:\n");
	for (int i = 0; i < len; ++i)
	{
		scanf("%d", &num);
		LinkList p = (LNode*)malloc(sizeof(LNode));
		if (!p)
			exit(1);
		p->data = num;
		p->next = NULL;
		if (i == 0) {//i=0时，p是首元结点
			L = p;
			q = p;
		}
		if (q)
		{
			q->next = p;
			q = p;
		}
	}
	return L;
}
void PrintList(LNode *L)
{
	LinkList p = L;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

（2）有头结点单链表插入:

#include <stdio.h>
typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode, *LinkList;
LNode * InitList();
void PrintList(LNode *L);//打印列表
void InsertList(LNode *L, int i, int b);//在第i个位置插入列表
//包含头结点的单链表插入
void main()
{
	LinkList L = InitList();
	printf("before:");
	PrintList(L);
	int i, b;
	printf("Enter the location:");//输入待插入元素的位置
	scanf("%d", &i);
	printf("Enter the number you want to insert into the list:");//输入待插入元素的值
	scanf("%d", &b);
	InsertList(L, i, b);
	printf("after:");
	PrintList(L);
	return;
}
void InsertList(LNode *L, int i, int b)
{
	LinkList p = L;
	int j = 0;
	while (p && (j < i - 1))//找到第i-1的位置，p指向i-1
	{
		p = p->next;
		++j;
	}
	if (!p || j > i - 1)//插入的位置大于列表的长度
	{
		exit(1);
	}
	LinkList newNode = (LNode *)malloc(sizeof(LNode));//生成新节点
	if (!newNode)
		exit(1);
	newNode->data = b;
	newNode->next = p->next;
	p->next = newNode;
}
LNode * InitList()
{
	int num, len = 0;
	LinkList  L = (LNode*)malloc(sizeof(LNode));
	if (!L)
		exit(1);
	LinkList q = L;//q用来保存当前结点的前驱
	printf("Enter the length of the list:\n");
	scanf("%d", &len);
	printf("Enter the value:\n");
	for (int i = 0; i < len; ++i)
	{
		scanf("%d", &num);
		LinkList p = (LNode*)malloc(sizeof(LNode));
		if (!p)
			exit(1);
		p->data = num;
		p->next = NULL;
		q->next = p;
		q = q->next;
	}
	return L;
}
void PrintList(LNode *L)
{
	LinkList p = L->next;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

2.18同2.17要求。试写一算法，实现线性表操作DELETE(L,i)；
（1）不包含头结点单链表的删除指定位置元素

#include <stdio.h>
//不含头结点的单链表删除
typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode, *LinkList;
LNode * InitList();//初始化链表
void PrintList(LNode *L);//打印链表
void DeleteList(LNode **L, int i);// 删除第i个元素
void main()
{
	LinkList L = InitList();
	printf("before:");
	PrintList(L);
	int i;
	printf("Enter the location:");//输入待删除元素的位置i
	scanf("%d", &i);
	DeleteList(&L, i);
	printf("after:");
	PrintList(L);
	return;
}
void DeleteList(LNode **L, int i)
{
	LinkList p = *L;
	LinkList q = p;
	int temp;//记下删除元素的值
	if (i == 1)//如果删除的是首元结点
	{
		temp = p->data;
		p = p->next;
		free(*L);
		(*L) = p;
	}
	else//要删除的不是首元结点
	{
		int j = 1;
		while (p&&j < i-1 )//找到要删除的前一个结点p
		{
			p = p->next;
			++j;
		}
		if (!p || j > i)
		{
			printf("DELETE ERROR\n");
			return;
		}
		q = p->next;//q就是要删除的结点
		temp = q->data;
		p->next = p->next->next;
		free(q);
	}
	printf("成功删除第%d个位置元素：%d\n",i,temp);
}
LNode * InitList()
{
	int num, len = 0;
	LinkList  L=NULL;
	LinkList q = NULL;//q用来保存当前结点的前驱
	printf("Enter the length of the list:\n");
	scanf("%d", &len);
	printf("Enter the value:\n");
	for (int i = 0; i < len; ++i)
	{
		scanf("%d", &num);
		LinkList p = (LNode*)malloc(sizeof(LNode));
		if (!p)
			exit(1);
		p->data = num;
		p->next = NULL;
		if (i == 0) {//i=0时，p是首元结点
			L = p;
			q = p;
		}
		if (q)
		{
			q->next = p;
			q = p;
		}
	}
	return L;
}
void PrintList(LNode *L)
{
	LinkList p = L;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

运行结果：
在这里插入图片描述
（2）包含头结点单链表删除指定位置元素

#include <stdio.h>
//含头结点的单链表删除指定位置的元素
typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode, *LinkList;
LNode * InitList();
void PrintList(LNode *L);//打印列表
void DeleteList(LNode *L, int i);//删除i位置的元素
void main()
{
	LinkList L = InitList();
	printf("before:");
	PrintList(L);
	int i, b;
	printf("Enter the location:");//输入待删除元素的位置
	scanf("%d", &i);
	DeleteList(L, i);
	printf("after:");
	PrintList(L);
	return;
}
void DeleteList(LNode *L, int i)
{
	LinkList q,p = L;
	int temp;//保存被删掉的元素值
	int j = 0;
	while (p && (j < i - 1))//找到第i-1的位置，p指向i-1
	{
		p = p->next;
		++j;
	}
	if (!p || j > i - 1)//i超出指定位置
	{
		printf("DELETE ERROR\n");
		return;
	}
	q = p->next;
	temp = q->data;
	p->next = p->next->next;
	free(q);
	printf("成功删除第%d个元素：%d\n", i, temp);

}
LNode * InitList()
{
	int num, len = 0;
	LinkList  L = (LNode*)malloc(sizeof(LNode));
	if (!L)
		exit(1);
	LinkList q = L;//q用来保存当前结点的前驱
	printf("Enter the length of the list:\n");
	scanf("%d", &len);
	printf("Enter the value:\n");
	for (int i = 0; i < len; ++i)
	{
		scanf("%d", &num);
		LinkList p = (LNode*)malloc(sizeof(LNode));
		if (!p)
			exit(1);
		p->data = num;
		p->next = NULL;
		q->next = p;
		q = q->next;
	}
	return L;
}
void PrintList(LNode *L)
{
	LinkList p = L->next;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

运行结果：
在这里插入图片描述
2.19已知线性表中的元素以值递增有序排列，并以单链表做存储结构。试写一高效的算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素）同时释放被删结点的空间，并分析你的算法的时间复杂度（注意mink和maxk是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）。

#include <stdio.h>
typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode, *LinkList;
LNode * InitList();
void PrintList(LNode *L);//打印列表
void DeleteList(LNode *L,int  mink, int maxk);
void main()
{
	LinkList L = InitList();
	printf("before:");
	PrintList(L);
	int mink,maxk;
	printf("Enter the range:\n");//输入待删除元素的大小范围
	scanf("%d %d", &mink,&maxk);
	if (mink > maxk) {//保证mink<=maxk
		int temp = maxk;
		maxk = mink;
		mink = temp;
	}
	DeleteList(L, mink,maxk);
	printf("after:");
	PrintList(L);
	return;
}
void DeleteList(LNode *L,int  mink, int maxk)
{
	LinkList p1=NULL,p2=NULL;
	LinkList p=L;
	while (p)//找到第一个大于mink结点的前驱p1
	{
		if ((p->next)->data> mink)
		{
			p1 = p;
			break;
		}
		p = p->next;
	}
	p = p1;
	while (p)//找到最后一个小于maxk的结点p2
	{
		if (p->next&&(p->next->data )< maxk)//若当前元素比maxk小，就找下一个
		{
			p = p->next; 
		}
		else
		{
			p2 = p;
			break;
		}
	}

	if (p1&&p2)
	{
		p = p1->next;
		p1->next = p2->next;//从链表中改变结点后继
		
		LinkList temp=NULL;
		while (p)//释放被删除的结点
		{
			temp = p->next;
			free(p);
			p = temp;
			if (p == p2)
				break;
		}
	}
}
LNode * InitList()
{
	int num, len = 0;
	LinkList  L = (LNode*)malloc(sizeof(LNode));
	if (!L)
		exit(1);
	LinkList q = L;//q用来保存当前结点的前驱
	printf("Enter the length of the list:\n");
	scanf("%d", &len);
	if (len == 0)
		return;
	printf("Enter the value:\n");
	for (int i = 0; i < len; ++i)
	{
		scanf("%d", &num);
		LinkList p = (LNode*)malloc(sizeof(LNode));
		if (!p)
			exit(1);
		p->data = num;
		p->next = NULL;
		q->next = p;
		q = q->next;
	}
	return L;
}
void PrintList(LNode *L)//含头结点的单链表输出
{
	LinkList p = L->next;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

2.20同2.19题的条件，试写一高效的算法删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不同），同时释放被删结点空间，并分析你的算法的时间复杂度。

#include <stdio.h>
typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode, *LinkList;
LNode * InitList();//初始化链表
void PrintList(LNode *L);//打印链表
void Removeduplication(LNode *L);//去除链表的重复元素
void main()
{
	LinkList L = InitList();
	printf("before:");
	PrintList(L);
	Removeduplication(L);//去掉重复元素
	printf("after:");
	PrintList(L);
	return;
}
void Removeduplication(LNode *L)
{
	LinkList p = L->next;
	LinkList pre = L;
	LinkList temp;
	while (p)
	{
		while (p&&pre->data == p->data)//有相同元素时，向后找到与pre不同的元素p
		{
			temp = p;
			p = p->next;
			free(temp);//释放重复元素
		}
			pre->next = p;
			pre = p;
			if (p)
			{
				p = p->next;
			}
	}
}
LNode * InitList()
{
	int num, len = 0;
	LinkList  L = (LNode*)malloc(sizeof(LNode));
	if (!L)
		exit(1);
	LinkList q = L;//q用来保存当前结点的前驱
	printf("Enter the length of the list:\n");
	scanf("%d", &len);
	if (len == 0)
		return;
	printf("Enter the value:\n");
	for (int i = 0; i < len; ++i)
	{
		scanf("%d", &num);
		LinkList p = (LNode*)malloc(sizeof(LNode));
		if (!p)
			exit(1);
		p->data = num;
		p->next = NULL;
		q->next = p;
		q = q->next;
	}
	return L;
}
void PrintList(LNode *L)//含头结点的单链表输出
{
	LinkList p = L->next;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

说是山水
关注
  • 2
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
链表学习2-C/C++2019.11.8
记录学习过程所学
11-08 461
数据结构开作业和实验了，我觉得这些题目挺好的，可以加深自己对链表的理解，故整理出来。 编译器说明：Dev-C++5.11 题目来自《数据结构（C语言版）严蔚敏、吴伟民习题集》 /** 题目2.11 * 设顺序表va中的数据元素递增有序。试写一算法，将x插入到顺序表的适当位置上，以保持该表的有序性 */ #include<iostream> #includ...
c语言线性表编程题,数据结构(C语言版)例题（第二章:线性表）
weixin_29972227的博客
05-18 1838
◆2.11②设顺序表L中的数据元素递增有序。试写一算法，将x插入到L的适当位置上，并保持该表的有序性。要求实现下列函数：void InsertOrderList(SqList &L, ElemTypex)顺序表类型定义如下：typedef struct {ElemType*elem;intlength;intlistsize;} SqList;void InsertOrderList(...
2.13√ 试写一算法在带头结点的单链表结构上实现线性表操作LOCATE(L，X)
qq_43661234的博客
09-11 8209
#include<stdio.h> #include<malloc.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode, *LinkList; LinkList creat...
线性表相关编程题练习
一字并肩王的博客
03-23 4408
数据结构复习之线性表
c语言线性表编程题,关于线性表操作 的一道 ACM题
weixin_31955465的博客
05-18 119
求助 关于线性表操作 的一道 ACM题本帖最后由 tall913 于 2011-03-16 22:08:10 编辑题目地址：http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1004描述线性表是n个元素的有序集合(n³0)，n是线性表中元素的个数，称为线性表的长度。可以用一组地址连续的存储单...
【数据结构】线性表相关操作（C++实现）
passer__jw767的博客
08-28 828
线性表相关操作实现：InitList、ListEmpty、ClearList、GetElem、LocateElem、ListInsert、ListDelete、ListLength
数据结构严蔚敏习题集C++实现
12-16
本资源是基于严蔚敏教授的教材，提供了C++语言实现的习题集，涵盖了线性表、栈和队列、树、图、查找和排序等重要数据结构和算法。 1. **线性表**：线性表是最基本的数据结构之一，包括顺序表和链表。顺序表是存储...
严蔚敏数据结构课本源码及习题解析
07-21
《严蔚敏数据结构课本源码及习题解析》是一份宝贵的资源，为学习和深入理解数据结构提供了丰富的素材。严蔚敏教授的《数据结构》是计算机科学领域经典教材，广泛应用于高校教学，这份资源包含了书中源码实现与习题...
严蔚敏数据结构 C源码 C++源码+资料
08-31
严蔚敏教授的《数据结构》一书是中国计算机教育领域的经典教材，其C语言和C++语言的源代码实现为学习者提供了深入理解数据结构的实践机会。 在C语言源码中，严蔚敏教授用简洁而清晰的编程风格展示了各种基础和高级...
数据结构（C语言版（第2版）习题答案
06-30
数据结构（C语言版）（第2版） 课后习题答案第1章 绪论第2章 线性表第3章 栈和队列第4章 串、数组和广义表 第5章 树和二叉树 第6章 图 第7章 查找 第8章 排序 数据：是客观事物的符号表示，指所有能输入到计算机中并...
100个C++实验案例（例题程序+实验案例+作业程序）
05-30
100个C++实验案例（例题程序+实验案例+作业程序）
已知head指向一个带头结点的单向链表
08-19
已知head指向一个带头结点的单向链表， 链表中每个结点包含数据域（data）和指针域（next）。 请编写函数实现如图所示链表逆置
数据结构严蔚敏c习题答案及代码（c++版）
10-10
这个压缩包文件包含了严蔚敏《数据结构》一书的C++版习题答案和代码。以下是各个章节的主要知识点： 1. **ch1：绪论** - 数据结构的基本概念：线性结构、树形结构、图结构和文件。 - 基本术语：数据元素、数据...
单链表实现线性表操作(带头节点)
云杉木屋
10-16 1923
为了学习数据结构我决定在自己跟着书打一遍，跟的是王道考研教材，命名没有严格按照严蔚敏老师的来。所以注意不要学我写的命名。为了加深我对这个板块儿学习的理解，我打算在这里总结一遍，反思教材的同时加入自己的理解。 链式结构和顺序结构 链式结构是一种物理结构，也就是数据在计算机中存储的方式，顺序表采用的是顺序结构。二者不同之处在于顺序结构中每个元素都是紧挨在一起的，书上的说法是“它是用一组连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻”。我们通常用数组来申请一片连.
线性表之顺序表编程题系列复习+834考点复习
wuyaxin
06-06 705
834数据结构 顺序表考纲要求： 线性表的顺序存储结构：静态分配，动态分配 顺序表的插入删除算法，移动元素次数分析 顺序存储结构的优缺点，引出单链表的结构类型定义 1、顺序表采用数组存储元素，静态数组需先指定大小，但也可以动态的分配数组的大小（通过指针来”追踪“数组中的元素），用malloc分配初始空间，用realloc分配后期扩容的空间 2、顺序表的插入算法： 在表L的第...
在无头结点的动态单链表上实现线性表操作Delete(L,i)
积极奋斗的蜗牛
04-09 3968
在无头结点的动态单链表上实现线性表操作DELETE(L,i)
线性表顺序存储代码题C++语言实现(一)
qq_43591406的博客
09-28 423
线性表顺序存储代码题C++语言实现(一) sxcc_13.h文件代码 /* *文件名：sxcc_13.h *作 者：辛伯达 *描 述：线性表顺序存储习题cpp代码实现 * */ #ifndef SXCC_13_H #define SXCC_13_H #include <iostream> #define MaxSize 50 using namespace std; //定义顺序存储的数据结构 typedef struct{ int data[MaxSize];
在无头结点的动态单链表上实现线性表操作DELETE(L, i)，并和在带头结点的动态单链表上实现相同操作的算法进行比较
qq_41109668的博客
02-28 912
题目： 在无头结点的动态单链表上实现线性表操作DELETE(L, i)，并和在带头结点的动态单链表上实现相同操作的算法进行比较 分析： 删除节点的操作一般步骤为：找到该节点的直接前驱，然后使其直接前驱的 next 指向该节点的直接后继 代码： 初始化： #include<stdio.h> #include<stdlib.h> #define OK 1 ty...
在无头结点的动态单链表上实现线性表操作 INSERT(L, i, B)，并和在带头结点的动态单链表上实现相同操作的算法进行比较。
qq_41109668的博客
02-28 2813
题目： 在无头结点的动态单链表上实现线性表操作 INSERT(L, i, B)，并和在带头结点的动态单链表上实现相同操作的算法进行比较。 分析： 首先我们要先初始化一个单链表，接下来要给这个单链表中添加数据元素，最后再在某一位置前插入某一数据元素 代码： 链表初始化： #include<stdio.h> #include<stdlib.h> #define ...
数据结构题集 c语言版 严蔚敏
最新发布
12-19
《数据结构题集 C 语言版》是一本由严蔚敏编著的经典教材，旨在帮助读者通过 C 语言实现数据结构相关算法和数据结构题目的解答。该书以解析数据结构相关问题为主线，结合 C 语言的实现方式进行讲解，涵盖了线性表、栈与队列、串、树和图等多个常见数据结构。此外，书中还包括了各种算法设计思想和解题技巧，能够帮助读者在实际应用中灵活运用不同的数据结构和算法解决问题。 《数据结构题集 C 语言版》不仅适合作为大学数据结构教材的辅助教材，也适合作为数据结构和算法学习者的参考书。通过学习该书，读者可以深入理解数据结构的基本概念和原理，并通过 C 语言的实际编程练习，提高自己的编程能力和问题解决能力。此外，该书题目丰富多样，既有基础的数据结构实现题，也有较难的算法设计题，适合不同水平的读者进行学习和练习。 总之，《数据结构题集 C 语言版》是一本理论与实践相结合的优秀教材，能够帮助读者全面掌握数据结构和算法相关知识，提高编程能力，是学习数据结构和算法的必备参考书之一。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值