实现链表的逆序的三种方式

最新推荐文章于 2024-02-23 16:03:30 发布
最新推荐文章于 2024-02-23 16:03:30 发布
阅读量1.8w 收藏 87
点赞数 15
分类专栏： 数据结构和算法 文章标签： 链表的逆序 java链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ldxlz224/article/details/101296053
版权

文章目录

问题
  • 给定一个带头节点的单链表，将其逆序。head->1->2->3->4->5->6->7变为 head->7->6->5->4->3->2->1。
分析

单链表与数组不同，单链表中每个节点的地址都存储在其前驱节点的指针域中，因此对链表中任何一个节点的访问只能从链表的头指针开始进行遍历。在修改节点指针域的时候，记录后继节点的地址，以防丢失后继节点。

注：在之前的文章通过java实现了单链表，我们以此具体链表为例，添加倒叙操作。点击此连接跳转查看具体实现

方法一：就地逆序
  • 在遍历列表时，修改当前节点的指针域指向，让其指向它的前驱节点。因此，需要一个变量来记录当前节点，以防后继节点消失，还需要一个变量保存后继节点，除此之外还需要对首位节点进行处理。算法实现如下：逆序是最下面的 reverse() 方法

public class TextLink<T> {

    private class Node {//存储数据和next节点
        private Object data;
        Node next;

        public Node() {
            data = null;
        }

        public Node(T data) {
            this.data = data;
        }
    }

    private Node head;//头指针
    private Node rear;//记录尾指针
    private Node point;//临时指针
    private int length;//链表长度

    public TextLink() {
        head = new Node();
        rear = head;
        length = 0;
    }

    /**
     * 插入数据，从尾部添加
     */
    public void add(T elem) {
        point = new Node(elem);
        rear.next = point;
        rear = point;
        length++;
    }

    public void traverse() {
        point = head;
        if (head != null) {
            while (point.next != null) {
                System.out.print(" [" + point.next.data + "]");
                point = point.next;
            }
        }
    }

    /**
     * 获取链表长度
     */
    public int getLength() {
        return length;
    }

    /**
     * 将元素插入指定位置
     */
    public void insert(int position, T elem) {
        if (position >= 0 && position <= length) {
            point = movePoint(position);
            Node tmp = new Node(elem);
            tmp.next = point.next;
            point.next = tmp;
            length++;
        } else {
            throw new ArrayIndexOutOfBoundsException("insert position is" + position + ",max length is" + length);
        }
    }

    /**
     * 移除指定位置元素
     */
    public void remove(int position) {
        if (position >= 0 && position < length) {
            point = movePoint(position);
            Node tmp = point.next;
            point.next = tmp.next;
            length--;
        } else {
            throw new ArrayIndexOutOfBoundsException("insert position is" + position + ",max length is" + length);
        }
    }

    public void set(int position, T elem) {
        if (position >= 0 && position < length) {
            point = movePoint(position);
            Node tmp = point.next;
            tmp.data = elem;
        } else {
            throw new ArrayIndexOutOfBoundsException("insert position is" + position + ",max length is" + length);
        }
    }

    public T findByPosition(int position) {
        if (position >= 0 && position < length) {
            point = movePoint(position);
            return (T) point.next.data;
        } else {
            throw new ArrayIndexOutOfBoundsException("insert position is" + position + ",max length is" + length);
        }
    }

    /**
     * 通过内容查找下标
     */
    public int findByData(T elem) {
        int index = -1;
        point = head.next;
        while (point != null) {
            index++;
            if (point.data == elem) {
                break;
            }
            point = point.next;
        }
        return index;
    }

    /**
     * 查找position位置的元素
     */
    private Node movePoint(int position) {
        if (position >= 0 && position <= length) {
            point = head;
            while (point != null) {
                if (position == 0) {
                    break;
                }
                position--;
                point = point.next;
            }
        }
        return point;
    }
	   /**
     * 倒叙操作
     */
    public void reverse() {
        if (head == null || head.next == null) {
            return;
        }
        Node pre = null; // 前驱节点
        Node cur = null; // 当前节点
        Node next = null; // 后继节点

        // 把链表首节点变为尾节点
        cur = head.next;
        next = cur.next;
        cur.next = null;
        pre = cur;
        cur = next;
        // 使当前遍历到的节点 cur 指向前驱节点
        while (cur.next != null) {
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        cur.next = pre;
        head.next = cur;
    }
}

上面代码中 reverse() 为添加的倒序方法。假设当前已经遍历到了 cur 节点，由于它所有的前驱节点都已经完成了逆序操作，因此只需要使 cur.next = pre; 即可完成逆序操作。再此之前，为了记录当前节点的后继节点地址，需要用一个 next 的额外指针来保存后继节点信息。当前节点完成逆序后，通过后移指针来对后续节点用同样的方法进行逆序操作。

程序运行如下：

 public static void main(String[] args) {
        TextLink<String> link = new TextLink<>();
        link.add("1");
        link.add("2");
        link.add("3");
        link.add("4");
        link.add("5");
        link.add("6");
        link.add("7");
        link.traverse();

        link.reverse();
        System.out.println();
        link.traverse();
    }

输出如下：

 [1] [2] [3] [4] [5] [6] [7]
 [7] [6] [5] [4] [3] [2] [1]
  • 此方法性能分析

此方法只需要对链表进行一次遍历，因此时间复杂度为O(N)。 其中，N为链表的长度，但是需要额外的变量来保存当前节点的前驱节点和后驱节点因此控件复杂度为O(1)。

方法二：递归法

  • 根据递归的特性。先把 1-2-3-4-5-6-7 变为 1-7-6-5-4-3-2 然后把 1 放到最后。2 3 4 也是同样的操作，下面是代码：

  • 自定义了一个简单 Node类 并且创建链表

   private static class Node {
        private Object data;
        Node next;

        public Node() {
            data = null;
        }

        public Node(Object data) {
            this.data = data;
        }
    }
	// 创建链表
    private Node createLink() {
        // 构造链表
        Node head = new Node();
        Node temp = null;
        Node cur = head;

        for (int i = 0; i < 10; i++) {
            temp = new Node();
            temp.data = i;
            temp.next = null;
            cur.next = temp;
            cur = temp;
        }
        return head;
    }
  • 逆序带头节点的链表
	// 此方法对不带头的节点进行逆序
    private Node recursiveReverse(Node head) {
        if (head == null || head.next == null) {
            return head;
        } else {
            Node newHead = recursiveReverse(head.next);
            head.next.next = head;
            head.next = null;
            return newHead;
        }
    }
	// 对带头的节点进行逆序
    private void reverse2(Node head){
        if (head == null){
            return;
        }
        Node firstNode = head.next;
        Node newHead = recursiveReverse(firstNode);
        head.next = newHead;
    }
  • 调用
	@Test
    public void test() {
        // 新建链表
        Node head = createLink();
        // 逆序
        reverse2(head);
    }
  • 跟上边就地逆序的相比，虽然不需要保存前驱地址等，但是需要不断的方法压栈出栈，所以效率略低。并且需要申请新的存储空间。时间复杂度也是 O(N) N为链表长度。
方法三：插入法（推荐）

主要思路：先输出除了当前节点外的节点，然后输出当前节点。
1-2-3-4-5-6-7 输出为 2-3-4-5-6-7 然后输出 1。同理 2-3-4-5-6-7 输出 3-4-5-6-7 然后输出2.
与方法1比不需要保存前驱地址，也不需要递归。效率更高。

 	/**
     * 插入法 逆序
     */
    private void reverse3(Node head) {
        if (head == null || head.next == null) {
            return;
        }
        Node cur = null;
        Node next = null;
        // 当前从第二个开始 2
        cur = head.next.next;
        // 第一个节点变为尾
        head.next.next = null;
        while (cur != null) {
            next = cur.next;
            cur.next = head.next;
            head.next = cur;
            cur = next;
        }
    }
Lud_
关注
  • 15
    点赞
  • 踩
  • 87
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
将一个链表逆序
hanpingxue的专栏
07-03 694
面试题： 实现一个链表逆序，加入输入A->B->C->D->
链表逆序
fangyang_000的博客
11-22 2164
链表逆序的思想： 1）遍历链表中的节点，放入栈中，然后进行出栈的操作，即可得到逆序的链表； 2）思想和1）相同，将链表中的元素，存入数组或者队列或者有序集合中，然后逆序去除元素，重新链接成链表； 3）通过交换链表中的元素，从而实现逆序。可以这么理解，顺序取出链表中的根元素，放入新的链表中。 代码如下： step1，构建节点 class Note { p...
四种方式实现从尾到头输出链表[zz]
haluomao18的专栏
07-09 768
http://www.e800.com.cn/articles/2011/0802/492531.shtml 转 本文介绍四种方式实现从尾到头输出链表，方法一：借用栈倒序输出链表。方法二：先翻转链表，再顺序输出。方法三：递归实现，一个字妙，两个字很妙，三个字太妙了。方法四：用数组实现。 　　四种方式实现倒序输出链表 　　方法一：借用栈倒序输出链表 　　方法二：先翻
经典笔试题——单向链表的倒序
皮皮不调皮的博客
03-23 1195
题目：有一个单向链表，将链表倒序 解决方案： 单向链表的特点：链表节点只能从前往后遍历（不能从后往前遍历），那么在遍历链表时，必须从前往后处理这些数据。 方案1： 链表节点添加：头插、尾插 头插法：先插入数据，会被放在链表的后边，后插入的数据会被放在链表的前面。 实现步骤：新建一个新的链表，对旧的链表节点中的数据头插法插入到新的链表，旧的链表遍历完成后，新的链表也就创建完成，新的链表就跟旧的链表刚好是倒序的。 方案2： 直接在链表上进行操作，对链表节点进行遍历，把每一个节点都采用头插法插入到链表中。
单链表逆序（三种方式）
节至
05-20 8327
三种方式实现单链表的逆序，分别是头结点插入，对称交换和利用堆栈来实现。三种方式分别是出于空间和时间的考虑来实现的，详见注释。public class LinkedList { class Node { private Node next; private Object data; public Node() { super(
链表反向 node_reverse()
最新发布
wf132948085的博客
02-23 178
链表反向
java实现单链表之逆序
09-03
3. 使用迭代法实现链表逆序，通过三个指针调整节点之间的连接关系。 4. 测试逆序方法，输出逆序后的链表。 理解并掌握这一过程，有助于提升对数据结构和算法的理解，对于Java程序员来说是非常基础且重要的技能。
C语言实现单链表逆序与逆序输出实例
09-04
在这个函数中，我们需要考虑三种基本情况：空链表、只有一个节点的链表以及多于一个节点的链表。对于多于一个节点的情况，我们将链表的剩余部分反转，并将原头节点连接到新头节点的末尾。 在`main`函数中，我们创建...
C语言数据结构实现链表逆序并输出
08-30
ion is wrong!\n"); return; } ptr_node=(Node *)malloc(sizeof(Node)); //生成插入结点 if(!ptr_node) { printf("allocation failed.\n"); } else { ptr_node->value=... //链表长度加1 } } void DeleteListHead(ptr
算法实现：Java单链表逆序
09-01
有一次，我去陆家嘴一家银行面试，面试官给我出了一道算法编程题，用Java实现单链表逆序，不到10分钟，我就写出来了，拿到了offer。 但是当时是写在纸上的，我用手机拍了下来，然后回去又在电脑上把代码敲了下来，...
大厂面试算法系列-如何实现链表的逆序(二)-递归法
初学者
12-26 2071
导语   接着上次的内容，上次博客中展示了原地进行单链表的逆序操作，当然除了原地逆序还可以通过递归的方式进行调用操作。下面就来看看通过递归的方式如何进行单链表的逆序操作。 递归法逆序链表   假定原来的链表为1->2->3->5->4->7,递归的思路，首先就是将除了第一个节点以外的节点先进行逆序，然后将第一个节点添加到逆序的子链表后面。同理要逆序第二个节点，就需要将除了第一个节点以外的链表先进行逆序。通过这种方式就可以实现链表的完全逆序了。 第一次递归 第二次递归  .
逆序建立链表
qq_45666654的博客
03-21 5653
数据结构实验之链表二：逆序建立链表 Description 输入整数个数N，再输入N个整数，按照这些整数输入的相反顺序建立单链表，并依次遍历输出单链表的数据。 Input 第一行输入整数N;； 第二行依次输入N个整数，逆序建立单链表。 Output 依次输出单链表所存放的数据。 Sample Input 10 11 3 5 27 9 12 43 16 84 22 Output 22 84 16 4...
链表逆序算法
__七把刀__
07-17 7143
问题： 给定一个链表，请将其逆序。即如果链表原来为1->2->3->4->5->null，逆序后为5->4->3->2->1->null. 解法1：迭代算法 迭代算法效率较高，但是代码比递归算法略长。递归算法虽然代码量更少，但是难度也稍大，不细心容易写错。 迭代算法的思想就是遍历链表，改变链表节点next指向，遍历完成，链表逆序也就完成了。代码如下： struct node {
单链表逆序
yhcs1213的专栏
02-17 762
单链表反转/逆序的两种方法  比较两种思路的差异 在 2012年07月05日 那天写的     已经有 57642 次阅读了 感谢 参考或原文 服务器君一共花费了96.662 ms进行了3次数据库查询，努力地为您提供了这个页面。 http://www.nowamagic.net/librarys/veda/detail/2241
c语言链表逆序排列,C语言课程设计---将一个链表按逆序排列.docx
weixin_34365042的博客
05-21 506
C语言课程设计---将一个链表按逆序排列.docx下载提示(请认真阅读)1.请仔细阅读文档，确保文档完整性，对于不预览、不比对内容而直接下载带来的问题本站不予受理。2.下载的文档，不会出现我们的网址水印。3、该文档所得收入(下载+内容+预览)归上传者、原创作者；如果您是本文档原作者，请点此认领！既往收益都归您。文档包含非法信息？点此举报后获取现金奖励！下载文档到电脑，查找使用更方便9积分还剩页未读...
将链表的结构逆序、将链表以逆序的形式输出
jw903的专栏
09-02 1109
1.将链表逆序：
编程算法 - 链表逆序 代码(C)
Mystra
09-16 3238
链表逆序 代码(C)本文地址: http://blog.csdn.net/caroline_wendy链表逆序, 作为链表操作的基础必须要熟练手写.主要包含3个部分, 一个指针记录后面节点, 一个指针记录前面节点, 把当前节点指到前面节点, 移动到后面节点, 前后指针依次移动.非递归链表逆序算法的核心代码只有10行.代码:/* * main.cpp * * Created on: 2014
将一个链表倒序输出
我的酒馆，名叫夜未央
05-17 821
思路一：遍历所有节点，将所有节点的值按顺序存入List，从尾部开始遍历这个list，将遍历值按顺序存入一个list2，返回list2，实现代码如下： import java.util.ArrayList; public class Solution { public ArrayList printListFromTailToHead(ListNode listNode) {
逆序遍历链表--递归与非递归方法
王温暖的博客
11-15 1043
package 链表上; import java.util.Stack; /** * 初始化链表节点 * @author buder_cp * * @param */ class ListNode { public T value; public ListNode next; public ListNode(){} public ListNode(T value, L
c语言如何实现链表逆序输出
09-19
要实现链表逆序输出，可以使用递归或者迭代的方式。以下是分别使用这两种方法的示例代码。 递归方法： ```c #include struct Node { int data; struct Node* next; }; void reversePrint(struct Node* head) {...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值