【上机实验】02：链表原地翻转

已于 2023-04-14 11:04:12 修改
阅读量670 收藏 2
点赞数
分类专栏： 数据结构与算法实现C
于 2022-04-18 13:37:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49167174/article/details/124247575
版权

链表 原地翻转 内存管理 C语言 数据结构
关键词由CSDN通过智能技术生成

链表原地翻转

目录

程序内部：在程序中能够看到的部分，链表中指第一个节点的地址（head指针记录整个链表的地址）

内存内部：在程序中不能看到的部分，链表中指的每一个节点（体现在物理内存中）

在这里插入图片描述

1.链表操作
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

typedef struct Node{
    int data;
    struct Node *next;
}Node;

typedef struct LinkList{
    Node head;//head为虚拟头结点
    int length;
}LinkList;

//1.初始化结点
Node *initNode(int val){
    Node *node = (Node *)malloc(sizeof(Node));
    node->data = val;
    node->next = NULL;
    return node;
}

//2.初始化链表
LinkList *initList(){
    LinkList *llst = (LinkList *)malloc(sizeof(LinkList));
    llst->head.next = NULL;
    llst->length = 0;
    return llst;
}

//3.结点的销毁
void DestroyNode(Node *node){
    if(node == NULL) return;
    free(node);
    return;
}

//4.链表的销毁
void DestroyList(LinkList *llst){
    if(llst == NULL) return;
    Node *p = llst->head.next;
    Node *temp;
    while (p != NULL) {
        temp = p->next;
        DestroyNode(p);
        p = temp;
    }
    free(llst);
    return;
}

//5.链表插入
int ListInsert(LinkList *llst, int ind, int val){
    if(llst == NULL) return 0;
    if(ind < 0 || ind > llst->length) return 0;
    Node *p = &(llst->head);//指针p记录虚拟头结点地址
    //(1)初始化一个node结点存入val数据
    Node *node = initNode(val);
    //(2)找到插入位置的前一个位置
    while(ind--) p = p->next;
    //(3)重新建立索引关系,进行结点插入
    node->next = p->next;
    p->next = node;
    llst->length += 1;
    return 1;
}

//6.链表元素的删除操作
int ListDelete(LinkList *llst, int ind) {
    if(llst == NULL) return 0;
    if(ind < 0 || ind >= llst->length) return 0;
    //(1)初始化一个node结点存入val数据
    Node *p = &(llst->head);
    Node *temp;
    //(2)找到插入位置的前一个位置
    while(ind--) p = p->next;
    //(3)temp记录待删除结点位置,进行删除操作
    temp = p->next;
    p->next = p->next->next;
    DestroyNode(temp);
    llst->length -= 1;
    return 1;
}

//7.print链表
void print(LinkList *llst) {
    if(llst == NULL) return;
    printf("LinkList(%d) : ", llst->length);
    //遍历LinkList元素
    for(Node *p = llst->head.next; p != NULL; p = p->next) {
        printf("%d->", p->data);
    }
    printf("NULL\n");
    return;
}

int main(){
    srand(time(0));
    LinkList *llst = initList();
    #define MAX_OP 20
    for(int i = 0; i < MAX_OP; ++i){
        int val = rand() % 100;
        int ind = rand() % (llst->length + 3) - 1;//操作位置随机在范围[-1, sqlst-length + 1]中
        int op = rand() % 4;
        switch (op) {
            case 0:
            case 1:
            case 2: {
                printf("insert %d at %d to List = %d\n", val, ind, ListInsert(llst, ind, val));
            } break;
            case 3: {
                printf("erase a item at %d from List = %d\n", ind, ListDelete(llst, ind));
            } break;
        }
        print(llst);
    }
    #undef MAX_OP
    DestroyList(llst);
    return 0;
}

在这里插入图片描述

注意：对程序内部和内存内部的理解，决定了链表数据结构的定义方式

2.链表原地翻转

思路1：

  1. 新创建一个链表
  2. 遍历已知的链表，将元素不断的插入到新创建的链表中（使用头插法）

思路2：

原地翻转链表，不需要开辟新的空间O(1)，注意内存泄漏问题

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

#define COLOR(a,b) "\033[" #b "m" a "\033[0m"
#define GREEN(a) COLOR(a, 34)

typedef struct Node{
    int data;
    struct Node *next;
}Node;

typedef struct LinkList{
    Node head;//head为虚拟头结点
    int length;
}LinkList;

//1.初始化结点
Node *initNode(int val){
    Node *node = (Node *)malloc(sizeof(Node));
    node->data = val;
    node->next = NULL;
    return node;
}

//2.初始化链表
LinkList *initList(){
    LinkList *llst = (LinkList *)malloc(sizeof(LinkList));
    llst->head.next = NULL;
    llst->length = 0;
    return llst;
}

//3.结点的销毁
void DestroyNode(Node *node){
    if(node == NULL) return;
    free(node);
    return;
}

//4.链表的销毁
void DestroyList(LinkList *llst){
    if(llst == NULL) return;
    Node *p = llst->head.next;
    Node *temp;
    while (p != NULL) {
        temp = p->next;
        DestroyNode(p);
        p = temp;
    }
    free(llst);
    return;
}

//5.链表插入
int ListInsert(LinkList *llst, int ind, int val){
    if(llst == NULL) return 0;
    if(ind < 0 || ind > llst->length) return 0;
    Node *p = &(llst->head);//指针p记录虚拟头结点地址
    //(1)初始化一个node结点存入val数据
    Node *node = initNode(val);
    //(2)找到插入位置的前一个位置
    while(ind--) p = p->next;
    //(3)重新建立索引关系,进行结点插入
    node->next = p->next;
    p->next = node;
    llst->length += 1;
    return 1;
}

//6.链表元素的删除操作
int ListDelete(LinkList *llst, int ind) {
    if(llst == NULL) return 0;
    if(ind < 0 || ind >= llst->length) return 0;
    //(1)初始化一个node结点存入val数据
    Node *p = &(llst->head);
    Node *temp;
    //(2)找到插入位置的前一个位置
    while(ind--) p = p->next;
    //(3)temp记录待删除结点位置,进行删除操作
    temp = p->next;
    p->next = p->next->next;
    DestroyNode(temp);
    llst->length -= 1;
    return 1;
}

//7.链表原地翻转
void ListReverse(LinkList *llst){
	if(llst == NULL) return;
    Node *p = llst->head.next;
    Node *temp;
    llst->head.next = NULL;
    while(p != NULL){
        temp = p->next;
        p->next = llst->head.next;
        llst->head.next = p;
        p = temp;
    }
    return;
}

//7.print链表
void print(LinkList *llst) {
    if(llst == NULL) return;
    printf("LinkList(%d) : ", llst->length);
    //遍历LinkList元素
    for(Node *p = llst->head.next; p != NULL; p = p->next) {
        printf("%d->", p->data);
    }
    printf("NULL\n");
    return;
}

int main(){
    srand(time(0));
    LinkList *llst = initList();
    #define MAX_OP 20
    for(int i = 0; i < MAX_OP; ++i){
        int val = rand() % 100;
        int ind = rand() % (llst->length + 3) - 1;//操作位置随机在范围[-1, sqlst-length + 1]中
        int op = rand() % 4;
        switch (op) {
            case 0: {
                printf(GREEN("reverse the list!\n"));
                ListReverse(llst);
            } break;
            case 1:
            case 2: {
                printf("insert %d at %d to List = %d\n", val, ind, ListInsert(llst, ind, val));
            } break;
            case 3: {
                printf("erase a item at %d from List = %d\n", ind, ListDelete(llst, ind));
            } break;
        }
        print(llst);
    }
    #undef MAX_OP
    DestroyList(llst);
    return 0;
}

在这里插入图片描述

ListReverse操作：

//7.链表原地翻转
void ListReverse(LinkList *llst){
    if(llst == null) return;
    Node *p = head->next;
    Node *temp;
    head->next = NULL;
    while(p != NULL){
        temp = p->next;
        p->next = head->next;
        head->next = p;
        p = temp;
    }
    return;
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

hello world 999
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
原地逆转链表
weixin_46503238的博客
05-08 739
头插法原地逆转链表 根据头插法特性,将原来链表断开,重新使用头插法,新建 //头插法逆转链表 LinkList Reverse_List(LinkList L) { LNode *p,*r; p=L->next; L->next=NULL;//将L置空,重新开始 while(p!=NULL) { r=p->next; p->next=L->next; L->next=p;
《数据结构》实验报告：链表与二叉树
07-15
这份实验报告的代码部分应包含用C语言实现的链表和二叉树操作，这对于理解和掌握这些概念至关重要。通过实际编程，学生不仅能理论联系实际，还能提高解决问题的能力。最后，实验报告的完整性和优等成绩表明，这份...
原地排序与链表翻转
whinah的专栏
04-11 139
有这样一个问题： 有个长度为 n 的 (key,val) 数组 a，其中 key 是 int 类型，并且其值在 [0, n) 之间（前闭后开，包括 0 不包括 n），该数组按 key 是乱序的，但没有重复 key。 要求：对 a 原地按 key 排序，可以使用常数个临时变量，不允许使用其它额外空间，时间复杂度必须是O(n) 我曾经写过另外一个问题：排列的分解（必须看），与此有点类似：但其实不...
原地翻转链表
wangche320的专栏
06-28 666
public class ReverseList { public static Element reverse(Element head){ if(head == null){ return null; } if(head.next == null){ return head; } Element p1 = null; Element p2 = head;
链表原地反转（链表)
weixin_51034073的博客
04-16 353
题目描述 按数字输入顺序创建单链表。不可借助数组、容器，不可开辟新结点空间。编写函数，在原链表上实现单链表的反转。例如单链表10->20->30，反转后变为单链表30->20->10。 注：不符合题目要求，使用上题逆序输出不计分。 输入 测试次数t 每组测试数据一行，格式如下： 数据个数n，后跟n个整数 输出 对每组测试数据，输出反转后的单链表。 示例输入 2 10 1 2 3 4 5 6 7 8 9 10 4 19 20 15 -10 示例输出1 10 9 8 7 6 5 4 3
链表原地反转
qq_35637534的博客
01-28 368
链表原地反转 链表头节点有数据。否则反转后头结点有数据，而尾节点没有数据。 思路很简单： 假如原来的链表是：1->2->3->4->5->null 第一个节点插入第二个节点之后：2->1->3->4->5->null 再将2->1当做整体插入3之后：3->2->1->4->5->null . . . 最后得到5->4->3->2->1->null 返回结果的头结点指针 复杂度是O（n
C++(数据结构)：链表
最新发布
08-03
C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 ...
c语言作业：链表的操作.zip
03-19
c语言作业：链表的操作.zipc语言作业：链表的操作.zipc语言作业：链表的操作.zipc语言作业：链表的操作.zipc语言作业：链表的操作.zipc语言作业：链表的操作.zipc语言作业：链表的操作.zipc语言作业：链表的操作....
C++实验报告：链表应用
01-15
在C++中，链表通过节点结构来表示，每个节点包含实际的数据（在这个实验中是学生信息）和一个指针，用于链接到下一个节点。本实验报告关注的是一个链表应用，具体是一个学生信息管理系统的实现，其中每个学生信息...
实验二：链表的基本操作的实验报告
12-04
通过这个实验，学生能够深入理解链表的存储结构，掌握链表操作的实现，并提升问题解决和程序设计的能力。同时，实验还强调了独立完成和分析程序的重要性，这有助于培养学生的自主学习和思考能力。
单链表的反转（原地反转法 && 新建链表插入法）
12-19
c++ 实现单链表的反转（原地反转法 && 新建链表插入法）
单链表的转置
09-30
线性表有很多作用，如何学好它也是很多人头痛的事情，这里给大家介绍一下单链表的转置
原地反转链表（空间复杂度为O（1））
haust_允谦的博客
11-11 2239
链表原地翻转 链表原地翻转的意思是指针p->next是要指向它的前一个结点 因此有一个结点pre一直在p的前面 由于当前p这个结点翻转后，还需要指向下一个结点继续重复“翻转”操作，因此还需要一个指针记录p后面的结点 指针 用途 p 当前翻转 rear 指向p后面的那个结点 pre 指向p前面的那个结点 //设计一个算法，将链表所有结点的链接方向原地宣战，即要求利用原表的存储空间，换句话说，要求算法的空间复杂度为O(1) #include <bits/stdc++.h> using nam
链表原地翻转|数据结构
资资的博客
12-16 313
p原地翻转的意思是p->next是要指向它的前一个结点 因此有一个结点pre一直在p的前面 由于当前p这个结点翻转后，还需要指向下一个结点继续重复“翻转”操作，因此还需要一个指针记录p后面的结点 指针 用途 p 当前翻转 rear 指向p后面的那个结点 pre 指向p前面的那个结点 void Reverse(linklist *head) { linklis...
单向链表原地反转
weixin_34038293的博客
06-09 140
如果不要求“原地”，正向遍历原链表，头插法建立一个新的单向链表，它就是原链表的逆序。 下面利用递归的方法将单向链表原地逆序。 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; typedef struct node{ int data; struct node *...
两种链表反转的方法（头插法和原地反转法，图解清晰，一看就会）
zhang050118的博客
03-02 1520
关于链表反转的方法，包含原地反转和头插法反转
链表原地反转Demo
bandilan2400的博客
06-04 129
　　现在就是Qt开发和给师弟师妹讲下数据结构吧，感觉还挺漫长的，上个Qt帖子等我把成品做出来再更。 1 //Convert_plug.h 2 3 #ifndef CONVERT 4 #define CONVERT 5 6 #define MAX 81 7 typedef char NmaeType; 8 typedef struct _name_...
【数据结构】单链表中，如何实现 将链表中所有结点的链接方向“原地”逆转
m0_71071692的博客
03-11 2090
如何实现：将链表中所有结点的链接方向“原地”逆转，即要求仅利用原表的存储空间，换句话说，要求空间复杂度为O（1）
数据结构上机实验指南：单链表操作
"《数据结构》实验指导书旨在帮助学生通过上机实习加深对课程内容的理解，特别是关于数据结构如单链表、二叉树、图以及排序和查找等核心概念。实习要求学生编写能够正确运行的程序，并提交包含需求分析、概要设计、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值