数据结构1-1，重拾链表。

最新推荐文章于 2023-04-01 23:12:56 发布
最新推荐文章于 2023-04-01 23:12:56 发布
阅读量253 收藏
点赞数 2
文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xianqiuyigedao/article/details/108818350
版权 
           ## 此文章仅用来记录🍎🍚的做题笔记，起备忘作用。
    （如有路人看到并认为有用，这边建议点赞呢。
    如果您觉得这个人菜的一，可以提出不当之处，我会诚恳地改正。）           
                      
                    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 Read(); /* 细节在此不表 /
void Print( List L ); / 细节在此不表 */

List Reverse( List L );

int main()
{
List L1, L2;
L1 = Read();
L2 = Reverse(L1);
Print(L1);
Print(L2);
return 0;
}

/* 你的代码将被嵌在这里 */
输入样例：
5
1 3 4 5 2
输出样例：
1
2 5 4 3 1

全部代码
//以下是调试代码：

 

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

typedef int ElementType;
typedef struct Node *PtrToNode;
struct Node {
    ElementType Data;
   PtrToNode Next;
};
typedef PtrToNode List;

List Read(); /* 细节在此不表 */
void Print( List L ); /* 细节在此不表 */

List Reverse( List L );

int main()
{
    List L1, L2;
   L1 = Read();
   L2 = Reverse(L1);
   Print(L1);
   Print(L2);
  return 0;
}


List Read()
{
   int n,i;
  scanf("%d",&n);
  struct Node *head=NULL,*s,*r=NULL;
  head=(List)malloc(sizeof(struct Node));
  if(head==NULL)
{
   exit(1);
}
  r=head;
  s=(List)malloc(sizeof(struct Node));

  if(s==NULL)
{
   exit(1);
}
for(i=0;i<n;i++)
{
   s=(List)malloc(sizeof(struct Node));
   scanf("%d",&s->Data);
  if(s==NULL)
 {
  exit(1);
 }
  r->Next=s;
  r=r->Next;
 }

  r->Next=NULL;
  return head->Next;//返回的是一个不带头结点的链表

  }
void Print( List L )//输出不带头结点的链表
{
   struct Node *p;
  p=L;
  while(p)
{
  printf("%d ",p->Data);
  p=p->Next;
}
   printf("\n");
}

 

	
                  *逆转函数*
List Reverse( List L )
{
	if(!L)
	return L;
	List p=NULL;
	List ptemp=NULL;
	//p:新链表，ptemp：记住位置，工具人。 
	//逆置：用一个临时结点，记住L指的结点。然后把L这个结点掰出去，放到另一个链表，相当于头插法。 
	while(L)
	{
	ptemp=L->Next; //ptemp记住L的下一个结点。 
	L->Next=p;     //L指向p（新链表的头结点，初始为空） 
	p=L;           //L指谁p就指谁，所以原L变成P（新链表的表头）。
	L=ptemp;       //ptemp指谁L就指谁，原L的下一个结点作为新的头再次循环。	 
	//如此循环，直到把整个链表逆转。 
    }
    return p ;
}

首先，让
哇这图大的一。首先，让ptemp（工具人指针）指向L->next，即记录L的下一个结点。

在这里插入图片描述
然后让L指向p（p为新链表的表头，初始为NULL）。那么就是L->next是NULL。接下来我们只需要把L赋值为p，那么p就指向了原本链表的第一个结点代表的内容，且next域为NULL。简而言之，就是p就是从原链表中掰出来的第一个结点。之后再循环再循环，p就指向原链表的第二个结点，且其next域是以前的p（即原链表的第一个结点），一直到原链表的最后一个元素，新的逆转的链表就得到了。
在这里插入图片描述
这里，为了循环的继续进行。要把ptemp赋值给L，即ptemp指谁、L就指谁。这样L就指向了原来链表的第二个结点，下次循环就把L也就是第二个结点掰出去放到新链表。

                        6-5 链式表操作集 (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。

裁判测试程序样例：

#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;
}

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

输入样例：
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

/* 你的代码将不会被嵌在这里 */
Position Find( List L, ElementType X )
{
	List head=L;
	while(head)
	{
		if(head->Data==X)
		{
			return head;
		}
		head = head->Next;
	}
	return ERROR;
}
List CreatCode(ElementType X)  //强哥之加函数 
{
	List t=(List)malloc(sizeof(struct LNode));
	t->Data = X;
	t->Next = NULL;
	return t;
}
List Insert( List L, ElementType X, Position P )
{
	List ptemp = CreatCode(X);
	if(L==P)  //插入到表头
	{
		ptemp->Next=L;
		L = ptemp;
		return L;
	}
	else    //插入到中间位置
	{
		List head = L;
		while(head)
		{
			if(head->Next==P)
			{
				ptemp->Next = P; //先栓新绳 
				head->Next = ptemp; //后栓旧绳 
				return L;
			}
			head=head->Next;
		}
		
	}
	printf("Wrong Position for Insertion\n");
	return ERROR;
}
List Delete( List L, Position P )
{
	List head = L;
	if(L==P)  //删除表头结点
	{
		L = L->Next;
		free(P);
		return L;
	}
	else   //删除中间结点
	{
		
		while(head)
		{
			if(head->Next==P)
			{
				head->Next =P->Next;
				free(P);
				return L;
			}
			head=head->Next;
		}
		
	}
	printf("Wrong Position for Deletion\n");
	return ERROR;
}

     6-6 带头结点的链式表操作集 (20分)
      本题要求实现带头结点的链式表操作集。
      本题与上一题的差别在于这次有空头，就因为有空头，这两个函数测试了好多次。
      我认为我lao的一，有时间就写一下注释，没时间就不写了。

函数接口定义：
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。

裁判测试程序样例：

#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;
}
/* 你的代码将被嵌在这里 */

输入样例：
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

//你的代码不会镶嵌在这里
List MakeEmpty()  //空表
{
List t = (List ) malloc(sizeof(struct LNode));
	t->Next = NULL;
	return t;
}
Position Find( List L, ElementType X ) 
{
	L=L->Next;  //有空投 
	if(L==NULL)
	{
		return ERROR;
	}
	else 
	{
		List head = L;  //要返回表头，用另一个变量去遍历。
		while(head)
	     {
	     	if(head->Data == X)
	     	{
	     		return head;
			}
			head = head->Next;
		 }
		 return ERROR;
	}
}
List CreatCode(ElementType X)  //强哥之加函数 
{
	List t=(List)malloc(sizeof(struct LNode));
	t->Data = X;
	t->Next = NULL;
	return t;
}
bool Insert( List L, ElementType X, Position P ) 
{
	List ptemp = CreatCode(X);
	if(P==NULL) //特例，如果P是NULL，而链表尾的next域为NULL，所以插入到表尾。
	{
		while(L->Next)
		{
			L=L->Next;
		}
	   L->Next = ptemp;
	   return true;
	}
	else if(L->Next==NULL)   //空表
	{
		return false;
	}
	else     //注意用L->next遍历,插入到P之前，即L->next的内容为P。
	{
		while(L->Next)
		{
			if(L->Next==P)
			{
				ptemp->Next = P;
				L->Next = ptemp;
				return true;
			}
			L=L->Next;
		}
	}
	printf("Wrong Position for Insertion\n");
	return false;
}
bool Delete( List L, Position P )
{
	if(L->Next==NULL)  //空表
	{
		return false;
	}
	
		while(L->Next)  
		{
			if(L->Next==P)
			{
				L->Next=P->Next;  //跨过删除元素。
				free(P);   //释放内存
				return true;
			}
			L=L->Next;
		}
		printf("Wrong Position for Deletion\n");
	return false;
}
想出成果的acmer
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构期末复习
weixin_44857642的博客
12-07 4638
## 链表 2-11 (neuDS)在单链表中，增加一个头结点的最终目的是为了(2 )。 使单链表至少有一个结点 方便运算的实现 标识表结点中首结点的位置 说明单链表是线性表的链式存储 2-10 将长度为n的单链表连接在长度为m的单链表之后的算法的时间复杂度为（ 2）。 O(1) O(m) O(n) O(n+m) 要插入到长度为m的单链表，需要找到表尾，这个过程的时间复杂...
数据结构1——链表
hwf1877655的博客
04-18 318
双向循环链表 [Double Circular Linked List] : 由各个内存结构通过指针 Next 和指针 Prev 链接在一起组成，每一个内存结构都存在前驱内存结构和后继内存结构，内存结构由数据域、Prev 指针域和 Next 指针域组成。双向链表的遍历是双向的，即如果把从链头的 Next 一直到链尾的[NULL] 遍历方向定义为正向，那么从链尾的 Prev 一直到链头 [NULL ]遍历方向就是反向；单向的实现就是在单链表的基础上，把链尾的 Next 指针直接指向链头，形成一个闭环；
数据结构作业2-链式存储结构及其操作（选择题）
banya1999的博客
12-10 6717
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所...
【C语言】顺序表操作集
m0_47352999的博客
04-01 215
其中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 2024
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...
第二章作业题2-链表-计算机17级（期末复习带详解版）
markconca的博客
10-18 5574
解析在后面  这次的题关于循环链表和双向链表的部分真的很难，不会的不少，我再想想吧     p1-1： 链表访问节点的时间复杂度为O(N) p1-3： 时间复杂度为O(1)，如果是两个链表都是有序的，合成一个有序链表的时间复杂度为O(M + N) x2-3： 带了头结点，那么就是B x2-4： 最小肯定是N，最大应该是2N（N+N）...
数据结构学习（1）-链表
sun_boy_01的博客
11-03 201
最近在学习数据结构，最先看了几天书，啥的没看懂，什么链表，堆栈，树，一塌糊涂。没办法把书丢一边，过了一段时间，又看了一点清华大学的严蔚敏的数据结构，恍然大悟。原来链表就是用指针把他们给串起来。早说啊，搞得我这么暝是苦想这么久。 那我就先贴个代码，(先声明代码不是我原创，是一位叫Kyle Loudon的大神写的)是单向链表的代码​ 先是​list.c #include #i
链表_数据结构--链表_
10-01
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。与数组不同，链表的元素不是在内存中连续存储，而是通过节点之间的引用连接起来。每个节点通常包含两个部分：数据...
数据结构实验-1客房管理（链表应用实验）
08-03
定义客房链表结点结构HLink (1)实现创建客房信息链表函数void Build(HLink &H)，输入（客房名称、标准价格、床位数），同时修改入住价格、入住状态为默认值，即入住价格=标准价格*80%，入住状态为”空闲”（提示：用...
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
数据结构学习--线性表及其应用--链表
06-25
线性表是一种基础的数据结构，它是由n（n>=0）个相同类型元素构成的有限...此外，了解链表的优缺点有助于在实际问题中选择合适的数据结构，例如在需要高效插入和删除但不关心随机访问的情景下，链表是一个很好的选择。
数据结构-图书管理系统-链表
11-11
数据结构——图书管理系统
【数据结构】某双向链表中，结点结构为【 prior , data , next 】。那么删除 p 指针所指结点时，需要执行语句： p -＞ next -＞ prior - p -＞ prior ；(
lethegods的博客
03-05 3884
链表不具有的特点是（A) A.可随机访问任一元素 B.不必实现估计存储空间 C.插入、删除元素不需要移动元素 D.所需存储空间与线性表的长度成正比 在一单链表中，删除指针 p 所指的后继结点，以下语句正确的是（D) A . free ( p -> next ); p -> next = p -> next -> next B . p -> next = p -> next -> next ; free ( p -> next ) C
Round4—链表（2）（双链表与循环链表）
你倒是敲代码鸭.
09-16 1405
声明：本博客的图片来自百度，如果侵权请联系我，我删掉。 知识点： 先顾名思义，自己理解一下双链表与循环链表吧，具体的知识点有点碎，下面咱们就题说。 练习题： 选择题： 2-1对于一非空的循环单链表，h和p分别指向链表的头、尾结点，则有：(2分) p->next == h p->next == NULL p == NULL p == h 解析： 单循环链表就是单向的循...
作业5--单链表
sususuyesylvia的博客
12-18 8638
2-1 设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是：(2分) h=t; t->next=h->next;t->next=h->next; h=t;h=t; t->next=h;t->next=h; h=t; 2-2 在单链表中，若p所指的结点不是最后结点，在p之后插入s所指结点，则执行 (2分) s->next=p;
6-2 顺序表操作集 (20分)（附样例和代码解释）
xxxibgdrgn博客
06-22 2839
本题要求实现顺序表的操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef int Position; typedef struct LNode List; struct LNode { ElementTy
双向链表练习题（Splay 区间翻转）
jkchen's Haven
10-01 586
original link - https://ac.nowcoder.com/acm/contest/1099/K 题意： 有nnn个链表，第iii个开始时只有iii一个数。 然后操作a,ba,ba,b，将bbb链表合并到aaa后面，然后翻转aaa链表。操作后bbb为空。求最后的第一个链表。 解析： 区间翻转等于SplaySplaySplay。先开nnn棵SplaySplaySplay树，用rt...
数据结构与算法作业2——双向链表
Mike峰
09-27 454
第二次作业： 习题1 双向链表 双向链表的知识点： 同单链表相比，双链表仅是各节点多了一个用于指向直接前驱的指针域。因此，我们可以在单链表的基础轻松实现对双链表的创建。 与单链表不同，双链表创建过程中，每创建一个新节点，都要与其前驱节点建立两次联系，分别是： 将新节点的 prior 指针指向直接前驱节点； 将直接前驱节点的 next 指针指向新节点。 双向链表的创建 2021/9/26 Doubly Linked List | Set 1 (Introduction and Inser.
机器学习模型评估与优化：常用方法与实践技巧.md
最新发布
08-15
机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值