数据结构 单链表的反转

最新推荐文章于 2024-10-03 21:03:30 发布
最新推荐文章于 2024-10-03 21:03:30 发布
阅读量568 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Alu_em/article/details/107929071
版权

文章目录

数据结构 单链表的反转

在这里插入图片描述

单链表简介

在这里插入图片描述

单链表的反转（Java实现）

定义节点与链表

示意图
节点类

在这里插入图片描述

链表

在这里插入图片描述

实现步骤

  • 思路:
  1. 先定义一个节点 reverseHead = new HeroNode();
  2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端.
  3. 原来的链表的head.next = reverseHead.next

关键部位代码

   //单链表的反转方式二
    public static void reverseList1(HeroNode head) {
        //链表为空或者链表只有一个节点，无需反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        //定义辅助变量
        HeroNode cur = head.next;
        //存放原链表当前节点的下一个节点
        HeroNode next = null;
        //反转列表头节点
        HeroNode reverseHead = new HeroNode();
        while (cur != null) {//遍历原列表将数据根据头插法插入新链表
            //保存原链表当前节点的下一个节点
            next = cur.next;
            //将当前节点插入反转链表
            cur.next = reverseHead.next;
            reverseHead.next = cur;
            //将辅助节点指向原链表下一个节点
            cur = next;
        }
        //将反转链表头节点赋给原头节点
        head.next = reverseHead.next;
    }
内存示意图

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
最终得到：
在这里插入图片描述

易错点

  • 代码实现步骤容易出错误的地方：当我们使用辅助节点遍历原单链表的时候，会忘记保存辅助节点的下一个节点，导致原单链表节点的丢失。
  • 代码如下：

注意：这是错误的代码

   //单链表的反转方式二
    public static void reverseList1(HeroNode head) {
        //链表为空或者链表只有一个节点，无需反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        //定义辅助变量
        HeroNode cur = head.next;
        //反转列表头节点
        HeroNode reverseHead = new HeroNode();
        while (cur != null) {//遍历原列表将数据根据头插法插入新链表
            //将当前节点插入反转链表
            cur.next = reverseHead.next;
            reverseHead.next = cur;
            //错误❌ ：原意为获取原来单链表的下一个节点，但由于该节点指向已经改变，因此发生错误
            cur = cur.next;
            
        }
        //将反转链表头节点赋给原头节点
        head.next = reverseHead.next;
    }
错误代码内存示意图：

在这里插入图片描述

完整代码

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        HeroNode h1 = new HeroNode(1,"宋江", "及时雨");
        HeroNode h2 = new HeroNode(2,"卢俊义", "玉麒麟");
        HeroNode h3 = new HeroNode(3,"吴用", "智多星");
        HeroNode h4 = new HeroNode(4,"林冲", "豹子头");

        //创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        singleLinkedList.addByOrder(h1);
        singleLinkedList.addByOrder(h2);
        singleLinkedList.addByOrder(h4);
        singleLinkedList.addByOrder(h3);

        singleLinkedList.show();
        /*
        HeroNode{no=1, name='宋江', nickName='及时雨'}
        HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
        HeroNode{no=3, name='吴用', nickName='智多星'}
        HeroNode{no=4, name='林冲', nickName='豹子头'}
         */

        System.out.println("****************************");
        //测试单链表反转
//        HeroNode newHead = reverseList(singleLinkedList.getHead());
//        singleLinkedList.setHead(newHead);
//        singleLinkedList.show();
        reverseList1(singleLinkedList.getHead());
        singleLinkedList.show();

    }

    //单链表的反转方式二
    public static void reverseList1(HeroNode head) {
        //链表为空或者链表只有一个节点，无需反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        //定义辅助变量
        HeroNode cur = head.next;
        //存放原链表当前节点的下一个节点
        HeroNode next = null;
        //反转列表头节点
        HeroNode reverseHead = new HeroNode();
        while (cur != null) {//遍历原列表将数据根据头插法插入新链表
            //保存原链表当前节点的下一个节点
            next = cur.next;
            //将当前节点插入反转链表
            cur.next = reverseHead.next;
            reverseHead.next = cur;
            //将辅助节点指向原链表下一个节点
            cur = next;
        }
        //将反转链表头节点赋给原头节点
        head.next = reverseHead.next;
    }

    //单链表的反转【腾讯面试题，有点难度
    public static HeroNode reverseList(HeroNode head) {
        if (head.next == null || head.next.next == null) {
            return head;
        }
        //定义辅助变量，遍历链表
        HeroNode temp = head;
        //新建一个头节点，保存反转链表
        HeroNode newHead = new HeroNode();

        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
            HeroNode newTemp = new HeroNode(temp.no, temp.name, temp.nickName);
            if (newHead.next == null) {
                newHead.next = newTemp;
                newTemp.next = null;
            } else {
                //temp变量指针不能变，定义辅助变量，给新链表赋值
                newTemp.next = newHead.next;
                newHead.next = newTemp;
            }
        }
        return newHead;
    }

 
 

}


//定义SingleLinkedList 管理我们的英雄
class SingleLinkedList {
    //初始化头节点
    private HeroNode head = new HeroNode();

    //返回头节点
    public HeroNode getHead() {
        return head;
    }

    //给头节点赋值
    public void setHead(HeroNode head) {
        this.head = head;
    }

    //添加数据
    // 第一种方法:，直接添加到链表的尾部
    public void add(HeroNode heroNode) {
        //因为head节点不能移动，定义辅助变量
        HeroNode temp = getHead();
        //遍历链表，找到末节点
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = heroNode;

    }
	
    //添加数据
    //第二种方式:根据排名将英雄插入到指定位置
  public void addByOrder(HeroNode heroNode) { 
        //因为head节点不能移动，定义辅助变量
        HeroNode temp = getHead();
        boolean flag = false;// flag标志添加的编号是否存在，默认为false
        //遍历链表，找到相应节点
        while (true) {
            if (temp.next == null) {
                break;
            } else if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;//后移，遍历当前链表
        }
        if (flag) {
            System.out.println("已存在");
        } else {//插入到链表中, temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //遍历链表
    public void show() {
        //判断链表是否为空
        if(head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = getHead();
        //遍历链表，找到末节点
        while (true) {
            if (temp.next == null) {
                break;
            }
            //将temp后移
            temp = temp.next;
            System.out.println(temp);
        }

    }

    //根据编号删除数据
    public void delete(int no) {
        HeroNode temp = getHead();
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no) {
                //找到的待删除节点的前一个节点temp
                temp.next = temp.next.next;
                System.out.println("删除成功");
                return;
            }
            temp = temp.next;
        }
        System.out.println("没有找到相应数据");

    }

    //根据编号修改数据
    public void update(HeroNode heroNode) {
        //判断是否空
        if(head.next == null) {
            System.out.println("链表为空~");
            return;
        }
        //找到需要修改的节点, 根据no编号
        //定义一个辅助变量
        HeroNode temp = getHead();
        boolean flag = false;//表示是否找到该节点
        while (true) {
            if (temp.next == null) {
                break;//已经遍历完链表
            }
            if (temp.no == heroNode.no) {
                temp.name = heroNode.name;
                temp.nickName = heroNode.nickName;
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.println("修改成功");
        } else {
            System.out.println("没有找到数据");
        }
    }

    //根据编号查询数据
    public HeroNode get(int no) {
        //判断是否空
        if(head.next == null) {
            System.out.println("链表为空~");
            return null;
        }
        HeroNode temp = getHead();
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.no == no) {
                return temp;
            }
        }
        return null;
    }

}


//定义HeroNode ， 每个HeroNode 对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;//指向下一个节点

    //构造器
    public HeroNode() {

    }

    public HeroNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    //为了显示方法，我们重新toString
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

链表的详细资料请参考：Java数据结构与算法 day02 链表与栈

单链表逆转（数据结构）C语言
amicoyuan的博客
05-07 1621
单链表逆转（数据结构） 此题是参考了很多博主总结了一下自己觉得最好理解的 本题要求实现一个函数，将给定的单链表逆转。 函数接口定义 List Reverse( List L ); 其中List结构定义如下： typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode ...
2.C语言数据结构 单链表反转
Scroll_C的博客
11-25 1416
单链表反转（4 种算法实现） 已经对单链表以及它的用法有了一个完整的了解。在此基础上，本节再带领大家研究一个和单链表有关的问题，即如何实 现单链表的反转。 反转链表，又可以称为翻转或逆置链表，它们表达的是同一个意思。以图 1 所示的链表为例： 图 1 未反转的链表 图 1 未反转的链表 经过反转（翻转、逆置）后，得到的新链表如图 2 所示：...
反转单链表
XDarker的博客
10-14 213
package algorithm.linkedlist; /** * @Created by XDarker * @Description 反转单链表 * @Date 2019/10/13 16:41 */ public class ReverseLinkedList { public static void main(String[] args) { ...
数据结构之单链表的反转
红莲灭的博客
08-22 326
文章目录链表反转原理分析代码实现测试 链表反转 单链表的反转，是面试中一个高频题目 原理分析 使用递归完成反转，递归反转其实就是从原链表的第一个存数据的结点开始，一次递归调用反转每一个结点，知道把最后一个结点反转完毕，整个链表就反转完毕。 1.调用reverse（Node curr）方法反转每一个结点，从元素1结点开始 2.如果发现curr还有下一个节点，则递归调用reverse（curr.next）对下一个节点进行反转 3.最终递归的出口是，next为null，让head节点指向最后一个元素节点 4.递
【数据结构】单链表反转
日拱一卒，功不唐捐。
12-28 277
链表反转一般有两种解法：递归和迭代。首先给出链表的定义 typedef struct tagLNode {//带头结点的单链表 int data; struct tagLNode *next;//尾结点为0表示结束。若尾结点指向头结点则为循环单链表 }LinkList; 假设链表为head->1->2->3->4->5->NULL。 递归法 L...
数据结构之单链表反转
Evelyn_Liu的博客
03-03 230
单链表反转的非递归方法：首先是结点的定义：public class Node { //数据域 int value; //结点域 Node next; public Node(int value){ this.value = value; this.next = null; } }使用非递归方法反转单链表，需要设置两个N...
单链表实现反转的3种方法示例代码
08-26
单链表是一种常见的数据结构，它在计算机科学和软件工程中广泛应用。单链表的反转是面试中经常会遇到的问题，本文将为大家介绍单链表实现反转的3种方法，并通过示例代码进行详细的介绍。 单链表反转的定义 单链表...
数据结构————单链表
m0_66847953的博客
09-09 7108
单链表（Singly Linked List）是一种基本的数据结构，它由一系列节点组成，每个节点包含两部分：数据域和指针域。数据域用于存储实际的数据，而指针域则存储指向链表中下一个节点的地址。在单链表中，除了最后一个节点外，每个节点的指针域都指向下一个节点，最后一个节点的指针域通常设置为NULL，以标识链表的结束。单链表的特点是其存储不需要连续的内存空间，节点可以分散在内存中的任意位置，通过指针连接形成线性结构。头插法指的是在单链表的头部插入节点。新节点的指针将指向当前的头节点，然后更新头指针以指向新节点。
数据结构单链表（带图详解）
10-06
单链表作为最基础的数据结构之一，对于理解和掌握高级数据结构至关重要。在本文中，我们将深入探讨单链表的概念、特点、操作以及实际应用。 首先，单链表是一种线性数据结构，它的每个元素称为节点，每个节点包含两...
数据结构-单链表的反转
最新发布
pyc68的博客
10-03 748
本篇文章介绍反转单链表的三种方法，分别为普通方法、头插法、递归法。
数据结构：单向链表的反转
又蠢又笨的懒羊羊程序猿的博客
08-03 1378
文章目录单链表的反转1.头插法1.1思路1.2代码实现2.就地逆置法2.1思路2.2代码实现 单链表的反转 本文主要介绍头插法逆置和就地逆置法实现链表的反转 1.头插法 1.1思路 迭代方式的链表反转操作核心是从链表头到链表尾 首先让创建一个temp指针使其指向头节点的下一个节点，并将其取出 取出之后让新创建的reverseNode节点指向刚取出的节点，反复进行上述操作。需要注意的是每次取出节点之前，需要用另外一个指针暂存temp指向的节点的下一个节点，防止temp指针变化后找不到新的节点。 最后让初
数据结构中-实现单链表的反转
weixin_42030357的博客
06-18 525
　　1. //实现单链表的反转 public void reverseList(HeroNode head){ if(head.next==null||head.next.next==null){ return; } HeroNode reserveHead = new HeroNode(0,"",""); ...
_数据结构_单链表反转
MPF1230的博客
02-10 180
单链表逆置是数据结构中经常容易考到，也是一个重要的问题 这里采用从前往后，一个一个逆置的方法实现单链表的整个反转 源代码获取： https://github.com/akh5/C-/tree/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/%E5%8D%95%E9%93%BE%E8%A1%A8 思路： 这里head指针是为了保证有一个结点一直指向表头 ol...
《数据结构》单链表反转
千言万语ROOM
03-02 550
单链表反转 题目描述： /* 设计一个算法，通过一趟遍历，将链表中所有的链接方向反转， 仍利用原表的空间  */ 思想： 先将链表的头结点指针域置空，p指向链表的第一个结点； q指向*p的后继,然后将*p插入到头结点的后面。 void TurnList(LinkList &L){ struct LNode *p; p=L->next; L->next=NUL
数据结构-单链表反转
cowoa1961331326
05-02 310
#include #include typedef struct Node {     int data;     struct Node *next; }List; List *Creat() {     int i,m;     scanf("%d",&m);     List *head;     List *p1,*p2;     p1=p2=(List *)ma
5.数据结构单链表之链表反转
Jeremy_Ren的博客
12-22 318
所谓链表反转就是将头指针指向的第一个元素所指向的元素为NULL，即Head->next->next = NULL.将头指针指向原来最后的一个成员，其他的元素都按照相反的方向指。这篇文章主要转载一篇讲的不错的文章 看图理解单链表的反转
数据结构实现单链表反转
10-16
单链表反转可以通过遍历链表，将每个节点的指针指向其前驱节点来实现。具体实现步骤如下： 1. 定义三个指针：pre、cur、next，分别表示当前节点的前驱节点、当前节点和后继节点。 2. 将 cur 指向链表的头节点。 3. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值