单链表的练习

原创 已于 2024-01-05 15:07:04 修改 · 463 阅读 · 6 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#算法 #c++ #数据结构 #c语言
于 2024-01-04 20:17:52 首次发布

1.递归程序设计方法练习--递归输出单链表：

本题要求用递归方法编写递归函数实现无头结点单链表的输出操作函数。L是一个不带头结点的单链表，函数void ListPrint_L_Rec(LinkList L)要求用递归的方法输出无头结点之单链表中各个元素的值，每个元素的前面都有一个空格（包括首元素）。递归思想可借鉴下述代码中链表创建的递归函数。

函数接口定义：

void ListPrint_L_Rec(LinkList L);

其中 L 是一个不带头结点的单链表。

裁判测试程序样例：

//库函数头文件包含
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//函数状态码定义
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2

typedef int  Status;
typedef int  ElemType; //假设线性表中的元素均为整型

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

Status ListCreate_L_Rec(LinkList &L,int n)
{
//递归边界：创建空表时只需将L赋空即可；
//递归关系：创建非空表时，将链表看做两部分：首元素组成的子表La， 第二个元素及其后元素构成的子表Lb。
//子表La容易创建(只需开辟一个节点)
//子表Lb由于规模小可以递归创建完成（类似数学归纳法的假设，只要小的都可以建设能完成）
//最后将两个子表拼接即可。
  LNode *La, *Lb;
  if(n==0) L=NULL;
  else{
    La=(LNode *)malloc(sizeof(LNode));  //开辟子表La
    if(!La) exit(OVERFLOW);
    scanf("%d",&La->data);
    ListCreate_L_Rec(Lb,n-1 ); //递归创建子表Lb
    La->next = Lb;  //两个子表拼结
    L=La;  //第一个子表的地址赋给L。请思考为什这样处理不会使得主函数中的L取错值？
  }
  return OK;
}
void ListPrint_L_Rec(LinkList L);

int main()
{
    LinkList L;
    int n;
    scanf("%d",&n);
    if(ListCreate_L_Rec(L,n)!= OK) {
          printf("表创建失败！！！\n");
          return -1;
    }
    ListPrint_L_Rec (L);
    return 0;
}
/* 请在这里填写答案 */

答案：

/* 请在这里填写答案 */
void ListPrint_L_Rec(LinkList L){
    if(!L->next)
        printf("%d ",L->data);
    else{
        //printf("%d ",L->data);//正序输出
        ListPrint_L_Rec(L->next);
        printf("%d ",L->data);//逆序输出
    }

}

2.单链表元素定位

本题要求在链表中查找第一个数据域取值为x的节点，返回节点的位序。L是一个带头结点的单链表，函数ListLocate_L(LinkList L, ElemType x)要求在链表中查找第一个数据域取值为x的节点，返回其位序（从1开始），查找不到则返回0。例如，原单链表各个元素节点的元素依次为1,2,3,4，则ListLocate_L(L, 1)返回1，ListLocate_L(L, 3)返回3，而ListLocate_L(L, 100)返回0。

函数接口定义：

int ListLocate_L(LinkList L, ElemType x)；

其中 L 是一个带头节点的单链表。 x 是一个给定的值。函数须在链表中查找第一个数据域取值为x的节点。若找到则返回其位序（从1开始），找不到则返回0。

裁判测试程序样例：


//库函数头文件包含
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//函数状态码定义
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2

typedef int  Status;
typedef int  ElemType; //假设线性表中的元素均为整型

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

Status ListCreate_L(LinkList &L,int n)
{
    LNode *rearPtr,*curPtr;   //一个尾指针，一个指向新节点的指针
    L=(LNode*)malloc(sizeof (LNode));
    if(!L)exit(OVERFLOW);
    L->next=NULL;               //先建立一个带头结点的单链表
    rearPtr=L;  //初始时头结点为尾节点,rearPtr指向尾巴节点
    for (int i=1;i<=n;i++){  //每次循环都开辟一个新节点，并把新节点拼到尾节点后
        curPtr=(LNode*)malloc(sizeof(LNode));//生成新结点
        if(!curPtr)exit(OVERFLOW);
        scanf("%d",&curPtr->data);//输入元素值
        curPtr->next=NULL;  //最后一个节点的next赋空
        rearPtr->next=curPtr;
        rearPtr=curPtr;
    }
    return OK;
}
//下面是需要实现的函数的声明
int ListLocate_L(LinkList L, ElemType x);

int main()
{
    LinkList L;
    int n;
    int x,k;   
    scanf("%d",&n);  //输入链表中元素个数
    if(ListCreate_L(L,n)!= OK) {
          printf("表创建失败！！！\n");
          return -1;
    }
   scanf("%d",&x); //输入待查找元素
   k=ListLocate_L(L,x);
   printf("%d\n",k);
   return 0;
}

/* 请在这里填写答案 */

输入样例：

4
1 2 3 4
1

输出样例：

1

答案一：

int ListLocate_L(LinkList L, ElemType x){
    LinkList p;
    p=L->next;
    int i=1;
    while(p!=NULL){
        if(p->data==x)
            return i;
        p=p->next;
        i++;
    }
    return 0;
}

答案二：

int ListLocate_L(LinkList L, ElemType x){
    LNode *p=L;
    int count=0;
    while(p->next!=NULL&&p->data!=x){
        p=p->next;
        count++;
    }
    if(p->next!=NULL)
        return count;
    else if(p->next==NULL&&p->data!=x)
        return 0;
    else if(p->next==NULL&&p->data==x)
        return count;
        
}

3.删除单链表中最后一个与给定值相等的结点：

本题要求在链表中删除最后一个数据域取值为x的节点。L是一个带头结点的单链表，函数ListLocateAndDel_L(LinkList L, ElemType x)要求在链表中查找最后一个数据域取值为x的节点并将其删除。例如，原单链表各个节点的数据域依次为1 3 1 4 3 5，则ListLocateAndDel_L(L,3)执行后，链表中剩余各个节点的数据域取值依次为1 3 1 4 5。

函数接口定义：

void ListLocateAndDel_L(LinkList L, ElemType x)；

其中 L 是一个带头节点的单链表。 x 是一个给定的值。函数须在链表中定位最后一个数据域取值为x的节点并删除之。

裁判测试程序样例：


//库函数头文件包含
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//函数状态码定义
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2
#define NULL        0

typedef int  Status;
typedef int  ElemType; //假设线性表中的元素均为整型

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//链表创建函数
Status ListCreate_L(LinkList &L,int n)
{
    LNode *rearPtr,*curPtr;
    L=(LNode*)malloc(sizeof (LNode));
    if(!L)exit(OVERFLOW);
    L->next=NULL;
    rearPtr=L;
    for (int i=1;i<=n;i++){
        curPtr=(LNode*)malloc(sizeof(LNode));
        if(!curPtr)exit(OVERFLOW);
        scanf("%d",&curPtr->data);
        curPtr->next=NULL;
        rearPtr->next=curPtr;
        rearPtr=curPtr;
    }
    return OK;
}
//链表输出函数
void ListPrint_L(LinkList L)
{
    LNode *p=L->next;
    if(!p){
        printf("空表");
        return;
    }
    while(p!=NULL)
    {
       if(p->next!=NULL)
           printf("%d ",p->data);
       else
           printf("%d",p->data);
          p=p->next;
    }
}
//下面是需要实现的函数的声明
void ListLocateAndDel_L(LinkList L, ElemType x);

int main()
{
    LinkList L;
    int n;
    int x;
    scanf("%d",&n);  //输入链表中元素个数
    if(ListCreate_L(L,n)!= OK) {
          printf("表创建失败！！！\n");
          return -1;
    }
   scanf("%d",&x); //输入待查找元素
   ListLocateAndDel_L(L,x);
   ListPrint_L(L);
   return 0;
}

/* 请在这里填写答案 */

输入样例：

6
1 3 1 4 3 5
3

输出样例：

1 3 1 4 5

答案：

void ListLocateAndDel_L(LinkList L, ElemType x){
    LinkList p,q=NULL;
    p=L->next;
    while(p!=NULL){
        if(x==p->data)
            q=p;
        p=p->next;
    }
    p=L->next;
    while(p!=NULL){
        if(q==p){
          L->next=p->next;
          free(q);
          break;
        }
        p=p->next;
        L=L->next;
    }
}

4.带头结点的单链表就地逆置：

本题要求编写函数实现带头结点的单链线性表的就地逆置操作函数。L是一个带头结点的单链表，函数ListReverse_L(LinkList &L)要求在不新开辟节点的前提下将单链表中的元素进行逆置，如原单链表元素依次为1,2,3,4，则逆置后为4,3,2,1。

函数接口定义：

void ListReverse_L(LinkList &L);

其中 L 是一个带头结点的单链表。

裁判测试程序样例：

//库函数头文件包含
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//函数状态码定义
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2

typedef int  Status;
typedef int  ElemType; //假设线性表中的元素均为整型

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

Status ListCreate_L(LinkList &L,int n)
{
    LNode *rearPtr,*curPtr;   //一个尾指针，一个指向新节点的指针
    L=(LNode*)malloc(sizeof (LNode));
    if(!L)exit(OVERFLOW);
    L->next=NULL;               //先建立一个带头结点的单链表
    rearPtr=L;  //初始时头结点为尾节点,rearPtr指向尾巴节点
    for (int i=1;i<=n;i++){  //每次循环都开辟一个新节点，并把新节点拼到尾节点后
        curPtr=(LNode*)malloc(sizeof(LNode));//生成新结点
        if(!curPtr)exit(OVERFLOW);
        scanf("%d",&curPtr->data);//输入元素值
        curPtr->next=NULL;  //最后一个节点的next赋空
        rearPtr->next=curPtr;
        rearPtr=curPtr;
    }
    return OK;
}
void ListReverse_L(LinkList &L);
void ListPrint_L(LinkList &L){
//输出单链表
    LNode *p=L->next;  //p指向第一个元素结点
    while(p!=NULL)
    {
          if(p->next!=NULL)
               printf("%d ",p->data);
          else
               printf("%d",p->data);
          p=p->next;
    }
}
int main()
{
    LinkList L;
    int n;
    scanf("%d",&n);
    if(ListCreate_L(L,n)!= OK) {
          printf("表创建失败！！！\n");
          return -1;
    }
    ListReverse_L(L);
    ListPrint_L(L);
    return 0;
}
/* 请在这里填写答案 */

输入格式：

第一行输入一个整数n，表示单链表中元素个数，接下来一行共n个整数，中间用空格隔开。

输出格式：

输出逆置后顺序表的各个元素，两个元素之间用空格隔开，最后一个元素后面没有空格。

输入样例：

4
1 2 3 4

输出样例：

4 3 2 1

答案：

void ListReverse_L(LinkList &L)//数组就地逆置
{//从第二个元素开始往前拿
    LinkList p,q,t;
    p=L->next->next;
    int flag=0;
    while(p)
    {
 
        t=p;//定义t由t存住当前结点
        p=p->next;//p后移
        t->next=L->next;//把t放到L后面
        L->next=t;
        if(!flag)//重点来了
        {
            L->next->next->next=NULL;//移动完一个数之后，因为要保证要在
            //最后一个结点的后面是NULL，所以只在第一次让L后面的后面的后面的结点为NULL
            flag=1;
 
        }
    }
}

5.链表的删除算法:

本题要求实现一个函数，实现删除链表llist中的指定元素deldata。

函数接口定义：

void DelNode_Link(head, deldata);

其中head是操作的链表表头结点，deldata是待删除的元素。

裁判测试程序样例：


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

typedef int DataType;
struct Node {
    DataType      data;
    struct Node*  next;
};
typedef struct Node  *PNode;
typedef struct Node  *LinkList;

LinkList SetNullList_Link()
{
    LinkList head = (LinkList)malloc(sizeof(struct Node));
    if (head != NULL) head->next = NULL;
    else printf("alloc failure");
    return head;
}

int IsNull_Link(LinkList llist)
{
    return(llist->next == NULL);
}

void CreateList(struct Node* head)
{
    PNode p = NULL; 
    PNode q = head; int data;
    scanf("%d", &data);
    while (data != -1) 
    {   
        p = (struct Node*)malloc(sizeof(struct Node));
        p->data = data;
        p->next = NULL;
        q->next = p;
        q = p;
        scanf("%d", &data);
    }
}

void DelNode_Link(head, deldata)
{
    @@
}

void print(LinkList head)
{
    PNode  p = head->next;
    while (p) {
        printf("%d ", p->data); 
        p = p->next;
    }
}
void DestoryList_Link(LinkList head)
{
    PNode  pre = head; 
    PNode p = pre->next;
    while (p) 
    {
        free(pre);
        pre = p;
        p = pre->next;
    }
    free(pre);
}

int main()
{
    LinkList head = NULL;
    PNode p = NULL;
    int deldata;
    head = SetNullList_Link();
    CreateList(head);
    scanf("%d", &deldata);
    DelNode_Link(head, deldata);
    print(head);
    DestoryList_Link(head);
    return 0;
}

输入样例：

1 5 10 15 20 -1
5

输出样例：

1 10 15 20

输入样例：

1 5 10 15 20 -1
2

输出样例：

not exist 2
1 5 10 15 20

答案：

void DelNode_Link(LinkList head, DataType deldata)
{
    PNode p=head->next;
    PNode beforeP=head;
    while(p!=NULL)
    {
        if(p->data==deldata)
        {
            beforeP->next=p->next;
            free(p);
            return 0;
        }
        else
        {
            beforeP=p;
            p=p->next;
        }
    }
    printf("not exist %d\n",deldata);
}

 6.求链式线性表的倒数第K项:

给定一系列正整数，请设计一个尽可能高效的算法，查找倒数第K个位置上的数字。

输入格式:

输入首先给出一个正整数K，随后是若干非负整数，最后以一个负整数表示结尾（该负数不算在序列内，不要处理）。

输出格式:

输出倒数第K个位置上的数据。如果这个位置不存在，输出错误信息NULL。

输入样例:

4 1 2 3 4 5 6 7 8 9 0 -1

输出样例:

7

答案：

 

#include <stdio.h>
#include <stdlib.h>
typedef struct ListNode {
	int data;
	struct ListNode *next;
}ListNode;
ListNode *createlist()//建立链表
{
	ListNode *l,*p;
	int num;
	while(1)
	{
		scanf("%d",&num);
		if(num<0)
			return l;
		p=(ListNode*)malloc(sizeof(ListNode));
		p->data=num;
		p->next=l;
		l=p;//后插法，这样相当于输入的数字直接倒序输入在该链表中
	}
}
int Find(ListNode *L,int K)
{
	int i;
	ListNode *p;
	p=L;
	if(L==NULL)
		return -1;
	if(K<=0)
	    return -1;
	for(i=1;i<K;i++)
	{
		if(p->next==NULL)
			break;
        p=p->next;
	}
	if(i<K)
		return -1;
	else
		return p->data;//找到需要输出的那个值返回
}
int main()
{
	ListNode *l = NULL;
	int k,num;
	scanf("%d",&k);
	l=createlist();
	num=Find(l,k);
	if(num==-1)
		 printf("NULL");
	else
         printf("%d",num);
    return 0;
}

单链表递归输出
01-06
实现单链表的递归输出，逆置输出等 有用哦
C++递归实现不带头节点的单链表操作
henry594xiaoli的博客
07-17 4011
有一个不带头结点的单链表： 递归实现以下操作(强调：所有操作必须用递归完成）。 1，插入数据：13，15，8，4，8，3，4，8(可以用递归一次完成，也可以用递归将一个一维数组一个一个的尾部插入) 2，正向输出所有节点值 3，逆向输出所有节点值 4，输出单链表中数据结点个数 5，输出第k个节点的值（k由用户输入，要能给出错误情况） 6，在第k个位置上插入e元素。（k和e由用户输入，要能给出错误情况）...
6-3 递归程序设计方法练习--递归输出单链表
2203_75646004的博客
10-28 356
其中L是一个不带头结点的单链表。
递归实现不带头结点的单链表逆置
m0_51310361的博客
03-12 4592
递归实现不带头结点的单链表逆置
2.6-12对于不带头结点的单链表 L，设计一个递归算法逆序输出所有结点值
热门推荐
qq_43192537的博客
10-10 1万+
对于不带头结点的单链表 L，设计一个递归算法逆序输出所有结点值 #include "LinkList.cpp" #include <bits/stdc++.h> void Revdisp(LinkNode *L) { // 逆序输出 if(L == NULL) return ; else{ Revdisp(L->next); cout <<"...
对于不带头结点的单链表L，设计一个递归算法逆序输出所有结点的值
m0_64621282的博客
07-12 1150
【代码】对于不带头结点的单链表L，设计一个递归算法逆序输出所有结点的值。
单链表练习
最新发布
dasq11的博客
04-16 167
【代码】单链表练习。
C++ 单链表代码练习
qq_43355454的博客
02-11 241
对应杭电OJ中的：数列有序！
C++单链表的一些小练习
choery45的博客
11-26 348
#include <stdio.h> #include <iostream> using namespace std; typedef struct LNode{ int data; struct LNode *next; }LNode,*SingleLinklist; //递归函数 删除单链表中所有值为x的节点 void Del_X(SingleLinklist &L,int x); //函数能使单链表从尾到头反向输出 void R_Printf(Sing.
单链表基础练习题
qq_51569907的博客
05-18 459
Java、数据结构、算法、链表、题库
单链表后续--＞练习题
m0_67910625的博客
05-01 878
203. 移除链表元素 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; t...
递归算法
＃两个西柚
08-04 1666
递归算法 一、思维导图概要 二、递归算法的执行过程 在执行递归函数时会直接调用自身，但仅仅有这种操作，将会出现无休止地调用而陷入死循环。因此，一个正确的递归函数虽然每次调用的是相同的代码，但它的参数、输入数据等均有变化，并且在正常情况下随着调用的不断深入必定会出现调用到某一层的函数时不再执行递归调用而终止函数的执行，即遇到递归出口。 递归函数可以看成是一种特殊的函数，递归函数调用是函数调用的一种特殊情况，即它是调用自身代码，因此也可以把每一次递归调用理解成调用自身代码的一个复制件。由于每次调用它的参数和局
递归求单链表最大值 (10 分)
Qmmm5的博客
04-03 4373
本题要求实现一个函数，返回不带头结点的单链表中最大元素的地址。 函数接口定义： LinkList MaxP( LinkList L); L是不带头结点的单链表的头指针，函数MaxP返回表中最大元素的地址。如果单链表为空，返回空指针。 其中LinkList结构定义如下： typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; 裁判测试程序样例： #include <stdi
数据结构之单链表插入，遍历（递归实现）
weixin_44027897的博客
11-30 2345
单链表插入，遍历 单链表的插入简单来说就是找到位置，然后将元素插入。 如何找？ 循环遍历找位置，因为链表的每个节点在内存中的存储位置是非连续的，所以不能像数组那样通过下标位移找到每个元素，而是需要借助元素的 next 域挨个找到目标位置。 数据结构中的遍历分为两种，一种是循环，比如 while（…）,for (…)，一种是递归，没错，递归就是一种遍历。 递归法插入代码如下： void Link::insert(int value, int location) { insert(value, loc
反转单链表（递归和遍历）
向高手学习
05-19 446
要求很简单，输入一个链表，反转链表后，输出新链表的表头。   反转链表是有2种方法(递归法，遍历法)实现的，面试官最爱考察的算法无非是斐波那契数列和单链表反转，递归方法实现链表反转比较优雅，但是对于不了解递归的同学来说还是有理解难度的。 1|1递归法 总体来说，递归法是从最后一个Node开始，在弹栈的过程中将指针顺序置换的。 为了方便理解，我们以 1->2->3->4这个链表来做演示。输出的效果是4->3->2->1 首先定义Node： ...
[原创] 算法之递归（2）- 链表遍历
weixin_30740581的博客
02-05 357
算法之递归（2）- 链表遍历 在递归（1）中，简单的介绍了递归的思想，并且通过一个例子简单阐述了递归是如何工作的，并且递归的实现是以线性结构来表示的。之所以用线性的，是因为其易于理解；如果使用树结构，将加大对问题的难度，不利于初学者理解递归的思想。 为什么用递归 关 于为什么用递归，我个人的理解是递归不要违背算法的初衷，即期待传入xxx值，加工后返回xxx值。不要为了递归而递归，容易...
通过递归的方式打印链表
Abcd_cnom的博客
10-03 426
这里我们还是使用头插法：插入的数据如下，链表的结构为{4,3,2,1}在执行到p->next=NULL时就会一步一步出栈，
5.链表：递归打印链表
weixin_51437378的博客
09-08 601
1.递归是时间换空间，要额外创建栈帧，消耗栈空间。递归次数过多会栈溢出程序崩溃。2.所以一般是使用普通函数遍历，在单个栈帧上操作3.为什么使用递归？简化代码，苦逼机器。
数据结构作业：递归实现链表操作集
wzc200406的博客
04-09 1018
复习，深入理解递归、单链表操作
递归程序设计方法练习--递归输出单链表
刘二狗的博客
09-28 5439
6-2 递归程序设计方法练习--递归输出单链表 （10 分） 本题要求用递归方法编写递归函数实现无头结点单链表的输出操作函数。L是一个不带头结点的单链表，函数void ListPrint_L_Rec(LinkList L)要求用递归的方法输出无头结点之单链表中各个元素的值，每个元素的前面都有一个空格（包括首元素）。递归思想可借鉴下述代码中链表创建的递归函数。 函数接口定义： void Li...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值