线性表练习之Example007-原地逆置单链表

于 2022-03-27 23:41:45 发布
阅读量696 收藏 6
点赞数
分类专栏： 数据结构 文章标签： java c 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123784531
版权

Example007

原文链接：Example007

题目

有一个线性表，采用带头结点的单链表 L 来存储。设计一个算法将其逆置。要求不能建立新结点，只能通过表中已有结点的重新组合来完成。

分析

本题考查的知识点：

  • 单链表
  • 头插法创建单链表

分析：

  • 本题考查的是不在创建一条新链表的情况下完成链表的逆置，所以要利用原链表的头节点。但仍然会需要额外的空间。
  • 本题涉及建立链表的头插法。头插法完成后，链表中的元素顺序和原数组中元素的顺序相反。
  • 这里可以将 L 中的元素作为逆转后 L 的元素来源，即将 L->next 设置为空，然后将头结点后的一串结点用头插法逐个插入 L 中，这样新的L中的元素顺序正好是逆序的。

图解

请添加图片描述

C实现

核心代码：

/**
 * 逆置单链表
 * @param list 原单链表
 */
void inversion(LNode **list) {
    // 原单链表的第一个节点
    LNode *node = (*list)->next;
    // 重新初始化原链表，即将原链表的头节点的 next 指针指向 null，故称为新链表
    (*list)->next = NULL;
    // 循环遍历原链表，将原链表所有节点使用头插法插入到新链表中
    while (node != NULL) {
        // 保存当前节点的后继节点，如果不保存的话，插入操作会把原链表的节点给覆盖掉
        LNode *temp = node->next;
        // 把当前节点 node 当作一个新节点来插入。将 node 节点的 next 指针指向新链表的第一个节点
        node->next = (*list)->next;
        // 将新链表的头节点的 next 指针指向 node 节点，即让 node 节点成为新链表的第一个节点
        (*list)->next = node;
        // 继续原链表的下一个节点
        node = temp;
    }
}

完整代码：

#include <stdio.h>
#include <malloc.h>

/**
 * 单链表节点
 */
typedef struct LNode {
    /**
     * 单链表节点的数据域
     */
    int data;
    /**
     * 单链表节点的的指针域，指向当前节点的后继节点
     */
    struct LNode *next;
} LNode;

/**
 * 通过尾插法创建单链表
 * @param list 单链表
 * @param nums 创建单链表时插入的数据数组
 * @param n 数组长度
 * @return 创建好的单链表
 */
LNode *createByTail(LNode **list, int nums[], int n) {
    // 1.初始化单链表
    // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
    *list = (LNode *) malloc(sizeof(LNode));
    (*list)->next = NULL;

    // 尾插法，必须知道链表的尾节点（即链表的最后一个节点），初始时，单链表的头结点就是尾节点
    // 因为在单链表中插入节点我们必须知道前驱节点，而头插法中的前驱节点一直是头节点，但尾插法中要在单链表的末尾插入新节点，所以前驱节点一直都是链表的最后一个节点，而链表的最后一个节点由于链表插入新节点会一直变化
    LNode *node = (*list);

    // 2.循环数组，将所有数依次插入到链表的尾部
    for (int i = 0; i < n; i++) {
        // 2.1 创建新节点，并指定数据域和指针域
        // 2.1.1 创建新节点，为其分配空间
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        // 2.1.2 为新节点指定数据域
        newNode->data = nums[i];
        // 2.1.3 为新节点指定指针域，新节点的指针域初始时设置为 null
        newNode->next = NULL;

        // 2.2 将新节点插入到单链表的尾部
        // 2.2.1 将链表原尾节点的 next 指针指向新节点
        node->next = newNode;
        // 2.2.2 将新节点置为新的尾节点
        node = newNode;
    }
    return *list;
}

/**
 * 逆置单链表
 * @param list 原单链表
 */
void inversion(LNode **list) {
    // 原单链表的第一个节点
    LNode *node = (*list)->next;
    // 重新初始化原链表，即将原链表的头节点的 next 指针指向 null，故称为新链表
    (*list)->next = NULL;
    // 循环遍历原链表，将原链表所有节点使用头插法插入到新链表中
    while (node != NULL) {
        // 保存当前节点的后继节点，如果不保存的话，插入操作会把原链表的节点给覆盖掉
        LNode *temp = node->next;
        // 把当前节点 node 当作一个新节点来插入。将 node 节点的 next 指针指向新链表的第一个节点
        node->next = (*list)->next;
        // 将新链表的头节点的 next 指针指向 node 节点，即让 node 节点成为新链表的第一个节点
        (*list)->next = node;
        // 继续原链表的下一个节点
        node = temp;
    }
}

/**
 * 打印链表的所有节点
 * @param list 单链表
 */
void print(LNode *list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list->next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    // 声明单链表
    LNode *list;

    // 创建单链表
    int nums[] = {1, 2, 3, 4, 5, 6};
    int n = 6;
    createByTail(&list, nums, n);
    print(list);

    // 逆置链表
    inversion(&list);
    print(list);
}

执行结果：

[1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1]

注意：在数据结构题目中更倾向于使用 *& 引用来修改单链表，而不是使用指向指针的指针 **。尽管那属于 C++ 中的知识。

#include <stdio.h>
#include <malloc.h>

/**
 * 单链表节点
 */
typedef struct LNode {
    /**
     * 单链表节点的数据域
     */
    int data;
    /**
     * 单链表节点的的指针域，指向当前节点的后继节点
     */
    struct LNode *next;
} LNode;

/**
 * 使用尾插法创建单链表
 * @param list 单链表
 * @param nums 待插入到单链表中的数组
 * @param n 数组长度
 */
void createByTail(LNode *&list, int nums[], int n) {
    // 初始化单链表
    list = (LNode *) malloc(sizeof(LNode) * n);
    list->next = NULL;
    // 链表的尾节点，初始时链表的尾节点就是头节点
    LNode *tailNode = list;
    // 循环数组 nums 中所有数据
    for (int i = 0; i < n; i++) {
        // 创建新节点并指定数据域和指针域
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        newNode->data = nums[i];
        newNode->next = NULL;
        // 将新节点插入到链表的尾部
        tailNode->next = newNode;
        tailNode = newNode;
    }
}

/**
 * 逆置单链表
 * @param list 原单链表
 */
void inversion(LNode *&list) {
    // 原单链表的第一个节点
    LNode *node = list->next;
    // 重新初始化原链表，即将原链表的头节点的 next 指针指向 null，故称为新链表
    list->next = NULL;
    // 循环遍历原链表，将原链表所有节点使用头插法插入到新链表中
    while (node != NULL) {
        // 保存当前节点的后继节点，如果不保存的话，插入操作会把原链表的节点给覆盖掉
        LNode *temp = node->next;
        // 把当前节点 node 当作一个新节点来插入。将 node 节点的 next 指针指向新链表的第一个节点
        node->next = list->next;
        // 将新链表的头节点的 next 指针指向 node 节点，即让 node 节点成为新链表的第一个节点
        list->next = node;
        // 继续原链表的下一个节点
        node = temp;
    }
}

/**
 * 打印链表的所有节点
 * @param list 单链表
 */
void print(LNode *list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list->next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    // 声明单链表
    LNode *list;

    // 创建单链表
    int nums[] = {1, 2, 3, 4, 5, 6};
    int n = 6;
    createByTail(list, nums, n);
    print(list);

    // 逆置链表
    inversion(list);
    print(list);
}

Java实现

核心代码：

    /**
     * 逆置单链表
     */
    public void inversion() {
        // 单链表的第一个节点
        LNode node = list.next;
        // 将单链表头节点的 next 指针指向 null，为了在头节点后面插入新节点，相当于重新进行了初始化，此时称 list 为新链表
        list.next = null;
        // 循环遍历原链表所有节点，利用头插法，将节点重新插入，就完成了链表的逆置
        while (node != null) {
            // 临时记录当前节点的后继节点
            LNode temp = node.next;
            // 将当前节点的 next 指向新链表的第一个节点。这里把当前节点 node 当作一个新节点来处理，其实就是头插法
            node.next = list.next;
            // 将新链表头节点的 next 指针指向当前节点
            list.next = node;
            // 继续下一个节点
            node = temp;
        }
    }

完整代码：

/**
 * @author lcl100
 * @desc （带头结点的）单链表
 * @create 2022-03-01 20:58
 */
public class LinkedList {
    /**
     * 单链表
     */
    private LNode list;

    /**
     * 通过尾插法创建单链表
     *
     * @param nums 创建单链表时插入的数据
     * @return 创建好的单链表
     */
    public LNode createByTail(int... nums) {
        // 1.初始化单链表
        // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
        list = new LNode();
        list.next = null;

        // 尾插法，必须知道链表的尾节点（即链表的最后一个节点），初始时，单链表的头结点就是尾节点
        // 因为在单链表中插入节点我们必须知道前驱节点，而头插法中的前驱节点一直是头节点，但尾插法中要在单链表的末尾插入新节点，所以前驱节点一直都是链表的最后一个节点，而链表的最后一个节点由于链表插入新节点会一直变化
        LNode tailNode = list;

        // 2.循环数组，将所有数依次插入到链表的尾部
        for (int i = 0; i < nums.length; i++) {
            // 2.1 创建新节点，并指定数据域和指针域
            // 2.1.1 创建新节点，为其分配空间
            LNode newNode = new LNode();
            // 2.1.2 为新节点指定数据域
            newNode.data = nums[i];
            // 2.1.3 为新节点指定指针域，新节点的指针域初始时设置为 null
            newNode.next = null;

            // 2.2 将新节点插入到单链表的尾部
            // 2.2.1 将链表原尾节点的 next 指针指向新节点
            tailNode.next = newNode;
            // 2.2.2 将新节点置为新的尾节点
            tailNode = newNode;
        }

        return list;
    }

    /**
     * 逆置单链表
     */
    public void inversion() {
        // 单链表的第一个节点
        LNode node = list.next;
        // 将单链表头节点的 next 指针指向 null，为了在头节点后面插入新节点，相当于重新进行了初始化，此时称 list 为新链表
        list.next = null;
        // 循环遍历原链表所有节点，利用头插法，将节点重新插入，就完成了链表的逆置
        while (node != null) {
            // 临时记录当前节点的后继节点
            LNode temp = node.next;
            // 将当前节点的 next 指向新链表的第一个节点。这里把当前节点 node 当作一个新节点来处理，其实就是头插法
            node.next = list.next;
            // 将新链表头节点的 next 指针指向当前节点
            list.next = node;
            // 继续下一个节点
            node = temp;
        }
    }

    /**
     * 打印单链表所有节点
     */
    public void print() {
        // 链表的第一个节点
        LNode node = list.next;
        // 循环打印
        String str = "[";
        while (node != null) {
            // 拼接节点的数据域
            str += node.data;
            // 只要不是最后一个节点，那么就在每个节点的数据域后面添加一个分号，用于分隔字符串
            if (node.next != null) {
                str += ", ";
            }
            // 继续链表的下一个节点
            node = node.next;
        }
        str += "]";
        // 打印链表
        System.out.println(str);
    }
}

/**
 * 单链表的节点
 */
class LNode {
    /**
     * 链表的数据域，暂时指定为 int 类型，因为 Java 支持泛型，可以指定为泛型，就能支持更多的类型了
     */
    int data;
    /**
     * 链表的指针域，指向该节点的下一个节点
     */
    LNode next;
}

测试代码：

/**
 * @author lcl100
 * @desc 单链表测试类
 * @create 2022-03-01 20:59
 */
public class LinkedListTest {
    public static void main(String[] args) throws Exception {
        // 创建单链表
        LinkedList list = new LinkedList();
        list.createByTail(1, 2, 3, 4, 5, 6);
        list.print();

        // 将单链表逆置
        list.inversion();
        list.print();
    }
}

执行结果：

[1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1]
二木成林
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向链表和单向链表的原地逆置(反向) 头插法 C语言
桑秋斯的博客
03-22 848
双向链表 和 单向链表的原地逆置(反向) 使用头插法 C语言
Vijos数据结构基础C++实验整理（四）——链式描述线性表
SunnySantino的博客
01-15 1569
实验内容： 1、链表实现 （一）封装链表类，链表迭代器类 （二）链表类需提供操作：在指定位置插入元素，删除指定元素，搜索链表中是否有指定元素，原地逆置链表，输出链表 2、链表合并 使用题目链表实现中实现的链表类、迭代器类完成 样例： 1、 输入 10 10 6863 35084 11427 53377 34937 14116 5000 49692 70281 73704 4 6863 1 2 44199 5 4 21466 1 6 11483 5 4 34937 5 4 6863 1 10 18635 输出
561-单链表刷题(1)
LINZEYU666的博客
09-15 210
单链表逆序（原地逆置） 单链表的逆序后的结果就是：当我们现在去访问单链表的头节点，然后访问的节点的顺序是：18,32,67,25 数据结构跟算法是永远离不开复杂度概念的 算法执行所耗费的时间，算法执行所占用的内存空间 复杂度越小越好，意味着性能越高，占用的内存空间越小，处理的速度越快。 我们要想到：头插法插出来的链表刚好和输入的是相反的 我们可以定义1个指针p指向第一个有效节点， 我们要把p前面的箭头去掉，这个头节点的next域不再记录第一个有效节点的地址，把头节点的next域置为空 现在这个h.
单链表的逆置
liuhuiyi的专栏
03-31 4938
单链表的逆置，心中永远的记忆。 单链表的逆置可以有多种实现方法，本文算是对逆置问题的一个总结： 首先是使用三指针方法实现。三指针就是使用三个指针分别记录操作每个结点的前驱结点，本身结点，后驱结点。通过while循环不断的调整顺序，然后逐点后移进行操作。这中国三指针的方式应该是最简单的方式，也应该优先考虑的。 LNode* ReverseList(LNode* head) { if (
逆置线性表(线性表)
u014371381的专栏
04-02 802
#include using namespace std; struct number { int num; number *next; }; void print(number *head,int n); int main() { int a,i,j=0; number *head,*s,*p; head=NULL; p=head; s=new numbe
线性表的链式实现-----单链表
07-02
LinkList.h与LinkList.c。使用c语言实现单链表数据结构。注释详细。
数据结构---线性表之单链表（C语言）
03-28
数据结构---线性表之单链表，包括单链表的创建、插入、删除等，C语言编写
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
数据结构c版（1）-线性表之单链表代码
最新发布
11-19
单链表代码
线性表的逆置（使用一维数组存储）
qq_46896305的博客
04-22 722
#include <stdio.h> #include<stdlib.h> #define OK 1 #define ERROR -1 #define MAX_SIZE 100 typedef int Status; typedef int ElemType; typedef struct sqlist{ ElemType Elem[MAX_SIZE]; int last; //last代表最后一个数数组下标 }Sqlist; //打印函数 void P
【8559】设有一个线性表存放在一个一维数组中的前n个数组元素位置。请编写一个顺序表的程序，将这个线性表原地逆置
Codes
09-24 3621
设有一个线性表存放在一个一维数组中的前n个数组元素位置。请编写一个顺序表的程序，将这个线性表原地逆置 输入 6 3 2 1 5 3 4 输出 3 2 1 6 3 4 4 3 6 1 2 3 #include<bits/stdc++.h> using namespace std; int main() { int n; while(cin>>n){ ...
设计一个算法,将链表中所有结点的链接方向“原地”逆转,即要求仅利用原表的存储空间, 换句话说,要求算法的空间复杂度为o(1).
热门推荐
JxufeCarol的博客
10-09 1万+
/*数据结构与算法-第二章线性表课后习题 *课本第53页2.7 *题目:设计一个算法,将链表中所有结点的链接方向“原地”逆转,即要求仅利用原表的存储空间, * 换句话说,要求算法的空间复杂度为o(1). *编译环境:VC 6.0 */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define ERROR -1 #define OK...
链式线性表的就地逆置
认真你就输了
03-27 1648
#include #include #include 采用单链表就地逆置的思想大概是这样： 1.断开单链表的头结点与第一个节点，这样头结点就变成了一个新的空链表； 2.然后从第一个结点开始，每次都取下原有链表的一个结点，插入到新链表表头(注意是从第一个结点开始 ，并不是第二个结点开始^-^)； 3.然后到最后一个结点，就完事了。循环为:
单链表基本操作在主函数中的实现
weixin_46803686的博客
11-05 5737
#include <iostream> #define OK 1 #define ERROR 0 #define VOERFLOE -2 using namespace std; typedef int Status; typedef struct LNode { int date; struct LNode *next; } LNode,*LinkList; //构造一个空的顺序表L Status InitList(LinkList &L) { L=new
Leetcode每日一题：面试题02.02.kth-node-from-end-of-list-lcci（返回倒数第k个节点）
CodeLuweir 的博客
09-28 3114
思路：典型得快慢指针问题，快指针与慢指针中间隔着k-2个节点，那么同时++快慢指针，当快指针指向链表结尾节点时，慢指针指向倒数第k个节点； struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; int kthToLast(ListNode *head, int k) { ListNode *left = head, *right = head; int count = 1; .
设计一个算法，借助栈实现单链表链接顺序的逆转
weixin_45963815的博客
04-12 7654
设计一个算法，借助栈实现单链表链接顺序的逆转： 程序思路：题目要求为借助栈将单链表中的数据逆置输出，栈的特点就是先进后出，只 需要将单链表中的数据依次存储在栈中，然后将栈中的元素依次取出即可。关键代码： while§//将链表结点数据入栈 { Push(S,p); p=p->next; }while(!Empty(S))//将栈中的数据取出并输出 { x=Pup(S,&x); pri...
考研数据结构之查找（9.8）——练习题之将关键字序列{7,8,30,11,18,9,14}散列存储到散列表中（C表示）
二木成林
06-09 1万+
题目 将关键字序列{7,8,30,11,18,9,14}散列存储到散列表中,散列表的存储空间是一个下标从0开始的一维数组，散列函数为H(key)=(key*3) Mod 7，处理冲突采用线性探测再散列法，要求装填因子为0.7. （1）请画出所构造的散列表。 （2）分别计算等概率情况下，查找成功和查找不成功时的平均查找长度。 分析 ...
线性表顺序存储 ------手机通讯录，c语言数据结构代码实现
09-17
为了实现手机通讯录的顺序存储，可以使用数组来存储联系人信息。以下是一个简单的C语言代码示例： ```c #include #include #define MAX_SIZE 100 // 最大存储容量 // 联系人结构体 typedef struct { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值