数据结构——双向链表PTA习题

最新推荐文章于 2023-04-01 23:12:56 发布
最新推荐文章于 2023-04-01 23:12:56 发布
阅读量5.8k 收藏 9
点赞数 5
分类专栏： # 算法练习题 文章标签： 数据结构 算法 单链表 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45525272/article/details/111337314
版权

文章目录

单选题

题号题目答案
1设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是： t->next=h; h=t;
2带头结点的单链表h为空的判定条件是： h->next == NULL;
3对于一非空的循环单链表，h和p分别指向链表的头、尾结点，则有： p->next == h
4在双向循环链表结点p之后插入s的语句是： s->prior=p; s->next=p->next; p->next->prior=s; p->next=s;
5在双向链表存储结构中，删除p所指的结点，相应语句为： p->prior->next=p->next; p->next->prior=p->prior;
6已知表头元素为c的单链表在内存中的存储状态如下表所示：在这里插入图片描述
现将f存放于1014H处，并插入到单链表中，若f在逻辑上位于a和e之间，则a、e、f的“链接地址”依次是：		 1014H, 1004H, 1010H
7下列函数中，哪个函数具有最慢的增长速度： NlogN^​2​​
8下列哪个函数是O(N)的？ logN^​2
9下列代码的时间复杂度是：在这里插入图片描述 O(NlogN)
10下列代码的时间复杂度是：在这里插入图片描述 O(n^​1/2​​ )

函数题

6-1 链式表操作集 (20分)

本题要求实现链式表的操作集。

函数接口定义：

Position Find( List L, ElementType X );
List Insert( List L, ElementType X, Position P );

List Delete( List L, Position P );
其中List结构定义如下：


typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

各个操作函数的定义为：

  • Position Find( List L, ElementType X )：返回线性表中首次出现X的位置。若找不到则返回ERROR；
  • List Insert( List L, ElementType X, Position P )：将X插入在位置P指向的结点之前，返回链表的表头。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回ERROR；
  • List Delete( List L, Position P )：将位置P的元素删除并返回链表的表头。若参数P指向非法位置，则打印“Wrong Position for Deletion”并返回ERROR。

输入样例：

6
12 2 4 87 10 2
4
2 12 87 5

输出样例：

2 is found and deleted.
12 is found and deleted.
87 is found and deleted.
Finding Error: 5 is not in.
5 is inserted as the last element.
Wrong Position for Insertion
Wrong Position for Deletion
10 4 2 5

代码

#include <stdio.h>
#include <stdlib.h>

#define ERROR NULL
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

Position Find( List L, ElementType X );
List Insert( List L, ElementType X, Position P );
List Delete( List L, Position P );

int main()
{
    List L;
    ElementType X;
    Position P, tmp;
    int N;

    L = NULL;
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        L = Insert(L, X, L);
        if ( L==ERROR ) printf("Wrong Answer\n");
    }
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        P = Find(L, X);
        if ( P == ERROR )
            printf("Finding Error: %d is not in.\n", X);
        else {
            L = Delete(L, P);
            printf("%d is found and deleted.\n", X);
            if ( L==ERROR )
                printf("Wrong Answer or Empty List.\n");
        }
    }
    L = Insert(L, X, NULL);
    if ( L==ERROR ) printf("Wrong Answer\n");
    else
        printf("%d is inserted as the last element.\n", X);
    P = (Position)malloc(sizeof(struct LNode));
    tmp = Insert(L, X, P);
    if ( tmp!=ERROR ) printf("Wrong Answer\n");
    tmp = Delete(L, P);
    if ( tmp!=ERROR ) printf("Wrong Answer\n");
    for ( P=L; P; P = P->Next ) printf("%d ", P->Data);
    return 0;
}

/* 你的代码将被嵌在这里 */

List Insert(List L, ElementType X, Position P)
{
	List head = L;
	List p = (List)malloc(sizeof(List) );
	p->Next = NULL;
	p->Data = X;
	// 判断插入的是不是空链表
	if (P==L)
	{
		p->Next = L;
		return p;
	}
	// 循环遍历链表
	while (L)
	{
		// 插入条件的筛选
		if (P==L->Next)
		{
			p->Next = L->Next;
			L->Next = p;
			return head;
		}	
		L = L->Next;
	}

	printf("Wrong Position for Insertion\n");
	return ERROR;

}

Position Find(List L, ElementType X)
{
	while (L) 
    {
		if (L->Data == X) 
        {
			return L;
		}
		L = L->Next;
	}
	return ERROR;
}

List Delete(List L, Position P)
{
	//如果是头结点
	if (L == P)
	{
		L =L->Next;
		return L;
	}
	List head = L;
	// 循环遍历链表
	while (L)
	{
		if (L->Next == P) 
		{
			L->Next = P->Next;
			return head;
		}
		L = L->Next;
	}
	printf("Wrong Position for Deletion\n");
	return ERROR;
}

6-2 带头结点的链式表操作集 (20分)

本题要求实现带头结点的链式表操作集。

函数接口定义：

List MakeEmpty(); 
Position Find( List L, ElementType X );
bool Insert( List L, ElementType X, Position P );
bool Delete( List L, Position P );

其中List结构定义如下：

typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

各个操作函数的定义为：

  • List MakeEmpty()：创建并返回一个空的线性表；

  • Position Find( List L, ElementType X )：返回线性表中X的位置。若找不到则返回ERROR；

  • bool Insert( List L, ElementType X, Position P )：将X插入在位置P指向的结点之前，返回true。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回false；

  • bool Delete( List L, Position P )：将位置P的元素删除并返回true。若参数P指向非法位置，则打印“Wrong Position for Deletion”并返回false。

输入样例：

6
12 2 4 87 10 2
4
2 12 87 5

输出样例：

2 is found and deleted.
12 is found and deleted.
87 is found and deleted.
Finding Error: 5 is not in.
5 is inserted as the last element.
Wrong Position for Insertion
Wrong Position for Deletion
10 4 2 5

代码

#include <stdio.h>
#include <stdlib.h>

#define ERROR NULL
typedef enum {false, true} bool;
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

List MakeEmpty(); 
Position Find( List L, ElementType X );
bool Insert( List L, ElementType X, Position P );
bool Delete( List L, Position P );

int main()
{
    List L;
    ElementType X;
    Position P;
    int N;
    bool flag;

    L = MakeEmpty();
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        flag = Insert(L, X, L->Next);
        if ( flag==false ) printf("Wrong Answer\n");
    }
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        P = Find(L, X);
        if ( P == ERROR )
            printf("Finding Error: %d is not in.\n", X);
        else {
            flag = Delete(L, P);
            printf("%d is found and deleted.\n", X);
            if ( flag==false )
                printf("Wrong Answer.\n");
        }
    }
    flag = Insert(L, X, NULL);
    if ( flag==false ) printf("Wrong Answer\n");
    else
        printf("%d is inserted as the last element.\n", X);
    P = (Position)malloc(sizeof(struct LNode));
    flag = Insert(L, X, P);
    if ( flag==true ) printf("Wrong Answer\n");
    flag = Delete(L, P);
    if ( flag==true ) printf("Wrong Answer\n");
    for ( P=L->Next; P; P = P->Next ) printf("%d ", P->Data);
    return 0;
}
/* 你的代码将被嵌在这里 */
/* 你的代码将被嵌在这里 */
List MakeEmpty()
{
	List L = (List)malloc(sizeof(List));
	L->Next = NULL;
	return L;
}
Position Find(List L, ElementType X)
{
	L = L->Next;
	while (L != NULL) {
		if (L->Data == X) {
			return L;
		}
		L = L->Next;
	}

	return ERROR;
}
bool Insert(List L, ElementType X, Position P)
{
	// 这个传入的是头结点的下一个，所以不用检验是否为头结点
	List q = (List)malloc(sizeof(struct LNode));
	q->Data = X;
	q->Next = P;
	while (L != NULL) {
		if (L->Next == P) {
			L->Next = q;
			return true;
		}
		L = L->Next;
	}
	printf("Wrong Position for Insertion\n");
	return false;

}
bool Delete(List L, Position P)
{
	while (L != NULL) {
		if (L->Next == P) {
			L->Next = P->Next;
			return true;
		}
		L = L->Next;
	}
	printf("Wrong Position for Deletion\n");
	return false;

}

6-4 共享后缀的链表 (25分)

有一种存储英文单词的方法，是把单词的所有字母串在一个单链表上。为了节省一点空间，如果有两个单词有同样的后缀，就让它们共享这个后缀。下图给出了单词“loading”和“being”的存储形式。本题要求你找出两个链表的公共后缀。
在这里插入图片描述

函数接口定义：

PtrToNode Suffix( List L1, List L2 );

其中List结构定义如下：

typedef struct Node *PtrToNode;
struct Node {
    ElementType Data; /* 存储结点数据 */
    PtrToNode   Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

L1和L2都是给定的带头结点的单链表。函数Suffix应返回L1和L2的公共后缀的起点位置。

输入样例：

如图存储的链表
在这里插入图片描述

输出样例：

ing

代码

#include <stdio.h>
#include <stdlib.h>

typedef char ElementType;

typedef struct Node *PtrToNode;
struct Node {
    ElementType Data; /* 存储结点数据 */
    PtrToNode   Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

void ReadInput( List L1, List L2 ); /* 裁判实现，细节不表 */
void PrintSublist( PtrToNode StartP ); /* 裁判实现，细节不表 */
PtrToNode Suffix( List L1, List L2 );

int main()
{
    List L1, L2;
    PtrToNode P;

    L1 = (List)malloc(sizeof(struct Node));
    L2 = (List)malloc(sizeof(struct Node));
    L1->Next = L2->Next = NULL;
    ReadInput( L1, L2 );
    P = Suffix( L1, L2 );
    PrintSublist( P );

    return 0;
}
/* 你的代码将被嵌在这里 */
PtrToNode Suffix(List L1, List L2)
{
	int num1 = 0, num2 = 0;
	List t = L1->Next, a = L1->Next, b = L2->Next;
	// 先算出两条链表的长度
	while (t) {
		num1++;
		t = t->Next;
	}
	t = L2->Next;
	while (t) {
		num2++;
		t = t->Next;
	}
	while (num1 > num2) {
		num1--;
		a = a->Next;
	}
	while (num2 > num1) {
		num2--;
		b = b->Next;
	}
	while (a) {
		// 如果一样a后面的都是  返回a就行
		if (a == b)
			return a;
		a = a->Next;
		b = b->Next;
	}
	return NULL;
}
呆萌宝儿姐
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构期末复习
weixin_44857642的博客
12-07 4593
## 链表 2-11 (neuDS)在单链表中，增加一个头结点的最终目的是为了(2 )。 使单链表至少有一个结点 方便运算的实现 标识表结点中首结点的位置 说明单链表是线性表的链式存储 2-10 将长度为n的单链表连接在长度为m的单链表之后的算法的时间复杂度为（ 2）。 O(1) O(m) O(n) O(n+m) 要插入到长度为m的单链表，需要找到表尾，这个过程的时间复杂...
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
C语言实现数据结构和双向链表操作
01-21
数据结构  双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef int ElemType; typedef struct node{ ElemType data; struct node *prior,*next; }DuLNode,*DuLinkList;     其中，prior域存放的是其前驱结点的存储地址，next域存放的是其后继结点的存储地址。 双向链表有两个特点： 一是可以从两个方向搜索某个结点，这使得链表的某些操作（如插
双链表的基本操作与习题练习
weixin_56169816的博客
05-09 1682
一、双链表的定义 双向链表也是链表的一种，有一个数据域data,它是用来存放数据的，有两个指针域，分别指向直接前驱pre和直接后继next。 从任意一个节点开始，都可以很方便的访问它的前驱节点和后继节点。使用这种方式解决了单链表中不能使用反向遍历的问题。 二、双链表的结构 双向链表也是采用的链式存储结构 ，因此它的结构图为： 双链表节点类型D_LinkList的声明如下： typedef int ElemType; typedef int Status; typedef struct D_LinkLis
【基础算法训练】—— 双向链表
weixin_52621323的博客
05-13 513
双向链表总结
Round4—链表（2）（双链表与循环链表）
你倒是敲代码鸭.
09-16 1334
声明：本博客的图片来自百度，如果侵权请联系我，我删掉。 知识点： 先顾名思义，自己理解一下双链表与循环链表吧，具体的知识点有点碎，下面咱们就题说。 练习题： 选择题： 2-1对于一非空的循环单链表，h和p分别指向链表的头、尾结点，则有：(2分) p->next == h p->next == NULL p == NULL p == h 解析： 单循环链表就是单向的循...
数据结构与算法作业2——双向链表
Mike峰
09-27 406
第二次作业： 习题1 双向链表 双向链表的知识点： 同单链表相比，双链表仅是各节点多了一个用于指向直接前驱的指针域。因此，我们可以在单链表的基础轻松实现对双链表的创建。 与单链表不同，双链表创建过程中，每创建一个新节点，都要与其前驱节点建立两次联系，分别是： 将新节点的 prior 指针指向直接前驱节点； 将直接前驱节点的 next 指针指向新节点。 双向链表的创建 2021/9/26 Doubly Linked List | Set 1 (Introduction and Inser.
数据结构作业2-链式存储结构及其操作（选择题）
banya1999的博客
12-10 6551
2-1设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是：(1分) A.t-&gt;next=h-&gt;next; h=t; B.t-&gt;next=h; h=t; C.h=t; t-&gt;next=h; D.h=t; t-&gt;next=h-&gt;next; 作者: DS课程组 单位: 浙江大学 2-2在单链表中，若p所指的结点不是最后结点，在p之后插入s所...
数据结构1-1，重拾链表。
xianqiuyigedao的博客
09-27 243
6-1 单链表逆转 (20分) 本题要求实现一个函数，将给定的单链表逆转。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typedef int ElementType; typedef struct Node *PtrToNode; struct Node { ElementType Data; PtrToNode Next; }; typedef PtrToNode List; List Re...
【C语言】顺序表操作集
m0_47352999的博客
04-01 174
其中List/* 保存线性表中最后一个元素的位置 */：创建并返回一个空的线性表；：返回线性表中X的位置。若找不到则返回ERROR；：将X插入在位置P并返回true。若空间已满，则打印“FULL”并返回false；如果参数P指向非法位置，则打印“ILLEGAL POSITION”并返回false；：将位置P的元素删除并返回true。若参数P指向非法位置，则打印“POSITION P EMPTY”（其中P是参数值）并返回false。
6-2 顺序表操作集(PTA)
purpleai的博客
04-28 1522
6-2 顺序表操作集 本题要求实现顺序表的操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef i...
C#数据结构之双向链表(DbLinkList)实例详解
09-03
主要介绍了C#数据结构之双向链表(DbLinkList),结合实例形式较为详细的讲解了双向链表的概念及C#实现双向链表的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。 1.双向链表的建立 双向链表在初始...
数据结构 双向链表（C++）
06-07
数据结构　双向链表的实现
7-16 三天打鱼两天晒网 (15分) 中国有句俗语叫“三天打鱼两天晒网”。假设某人从某天起，开始“三天打鱼两天晒网”，问这个人在以后的第N天中是“打鱼”还是“晒网”？
热门推荐
流楚丶格念的博客
04-22 4万+
7-16 三天打鱼两天晒网 (15分) 中国有句俗语叫“三天打鱼两天晒网”。假设某人从某天起，开始“三天打鱼两天晒网”，问这个人在以后的第N天中是“打鱼”还是“晒网”？ 输入格式： 输入在一行中给出一个不超过1000的正整数N。 输出格式： 在一行中输出此人在第N天中是“Fishing”（即“打鱼”）还是“Drying”（即“晒网”），并且输出“in day N”。 输入样例1： 103 ...
7-2 比较大小 本题要求将输入的任意3个整数从小到大输出。输入格式: 输入在一行中给出3个整数，其间以空格分隔。
流楚丶格念的博客
04-29 3万+
7-2 比较大小 本题要求将输入的任意3个整数从小到大输出。 输入格式: 输入在一行中给出3个整数，其间以空格分隔。 输出格式: 在一行中将3个整数从小到大输出，其间以“->”相连。 输入样例: 4 2 8 输出样例: 2->4->8 /*#include<iostream> using namespace std; int main() { ...
7-5 计算阶乘和 对于给定的正整数N，需要你计算 S=1!+2!+3!+...+N!。
流楚丶格念的博客
04-29 3万+
7-5 计算阶乘和 对于给定的正整数N，需要你计算 S=1!+2!+3!+…+N!。 输入格式： 输入在一行中给出一个不超过10的正整数N。 输出格式： 在一行中输出S的值。 输入样例： 3 输出样例： 9 #include<iostream> using namespace std; int J(int n) { int jie=1; for (int i...
L1-028 判断素数 (10分) 本题的目标很简单，就是判断一个给定的正整数是否素数。 输入格式： 输入在第一行给出一个正整数N（≤ 10），随后N行，每行给出一个小于2 ​31 ​​ 的需要判断
流楚丶格念的博客
09-25 3万+
L1-028 判断素数 (10分) 本题的目标很简单，就是判断一个给定的正整数是否素数。 输入格式： 输入在第一行给出一个正整数N（≤ 10），随后N行，每行给出一个小于2 ​31 ​​ 的需要判断的正整数。 输出格式： 对每个需要判断的正整数，如果它是素数，则在一行中输出Yes，否则输出No。 输入样例： 2 11 111 输出样例： Yes No 代码 #include <stdio.h> #include <stdlib.h> #include <math.h>
7-1 求奇数分之一序列前N项和 (20分) 本题要求编写程序，计算序列 1 + 1/3 + 1/5 + ... 的前N项之和。
流楚丶格念的博客
04-22 2万+
7-1 求奇数分之一序列前N项和 (20分) 本题要求编写程序，计算序列 1 + 1/3 + 1/5 + … 的前N项之和。 输入格式: 输入在一行中给出一个正整数N。 输出格式: 在一行中按照“sum = S”的格式输出部分和的值S，精确到小数点后6位。题目保证计算结果不超过双精度范围。 输入样例: 23 输出样例: sum = 2.549541 #include<io...
头歌实践教学平台数据结构线性表双向链表
最新发布
10-20
数据结构是计算机科学中的一个重要领域，线性表和双向链表是其中的两个基本概念。线性表是一种数据结构，其中数据元素按照线性顺序排列，每个元素都有一个前驱和一个后继。双向链表是一种特殊的线性表，每个节点都有...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

呆萌宝儿姐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值