Skip to content
百科百科
操作系统
设计模式
算法
题解
java
leetcode
  • 题解
    • 10.1 斐波那契数列
      • 10.2 矩形覆盖
        • 10.3 跳台阶
          • 10.4 变态跳台阶
            • 11. 旋转数组的最小数字
              • 12. 矩阵中的路径
                • 13. 机器人的运动范围
                  • 14. 剪绳子
                    • 15. 二进制中 1 的个数
                      • 16. 数值的整数次方
                        • 17. 打印从 1 到最大的 n 位数
                          • 18.1 在 O(1) 时间内删除链表节点
                            • 18.2 删除链表中重复的结点
                              • 19. 正则表达式匹配
                                • 20. 表示数值的字符串
                                  • 21. 调整数组顺序使奇数位于偶数前面
                                    • 22. 链表中倒数第 K 个结点
                                      • 23. 链表中环的入口结点
                                        • 24. 反转链表
                                          • 25. 合并两个排序的链表
                                            • 26. 树的子结构
                                              • 27. 二叉树的镜像
                                                • 28. 对称的二叉树
                                                  • 29. 顺时针打印矩阵
                                                    • 3. 数组中重复的数字
                                                      • 30. 包含 min 函数的栈
                                                        • 31. 栈的压入、弹出序列
                                                          • 32.1 从上往下打印二叉树
                                                            • 32.2 把二叉树打印成多行
                                                              • 32.3 按之字形顺序打印二叉树
                                                                • 33. 二叉搜索树的后序遍历序列
                                                                  • 34. 二叉树中和为某一值的路径
                                                                    • 35. 复杂链表的复制
                                                                      • 36. 二叉搜索树与双向链表
                                                                        • 37. 序列化二叉树
                                                                          • 38. 字符串的排列
                                                                            • 39. 数组中出现次数超过一半的数字
                                                                              • 4. 二维数组中的查找
                                                                                • 40. 最小的 K 个数
                                                                                  • 41.1 数据流中的中位数
                                                                                    • 41.2 字符流中第一个不重复的字符
                                                                                      • 42. 连续子数组的最大和
                                                                                        • 43. 从 1 到 n 整数中 1 出现的次数
                                                                                          • 44. 数字序列中的某一位数字
                                                                                            • 45. 把数组排成最小的数
                                                                                              • 46. 把数字翻译成字符串
                                                                                                • 47. 礼物的最大价值
                                                                                                  • 48. 最长不含重复字符的子字符串
                                                                                                    • 49. 丑数
                                                                                                      • 5. 替换空格
                                                                                                        • 50. 第一个只出现一次的字符位置
                                                                                                          • 51. 数组中的逆序对
                                                                                                            • 52. 两个链表的第一个公共结点
                                                                                                              • 53. 数字在排序数组中出现的次数
                                                                                                                • 54. 二叉查找树的第 K 个结点
                                                                                                                  • 55.1 二叉树的深度
                                                                                                                    • 55.2 平衡二叉树
                                                                                                                      • 56. 数组中只出现一次的数字
                                                                                                                        • 57.1 和为 S 的两个数字
                                                                                                                          • 57.2 和为 S 的连续正数序列
                                                                                                                            • 58.1 翻转单词顺序列
                                                                                                                              • 58.2 左旋转字符串
                                                                                                                                • 59. 滑动窗口的最大值
                                                                                                                                  • 6. 从尾到头打印链表
                                                                                                                                    • 题目链接
                                                                                                                                      • 题目描述
                                                                                                                                        • 解题思路
                                                                                                                                          • 1. 使用递归
                                                                                                                                            • 2. 使用头插法
                                                                                                                                              • 3. 使用栈
                                                                                                                                            • 60. n 个骰子的点数
                                                                                                                                              • 61. 扑克牌顺子
                                                                                                                                                • 62. 圆圈中最后剩下的数
                                                                                                                                                  • 63. 股票的最大利润
                                                                                                                                                    • 64. 求 1+2+3+...+n
                                                                                                                                                      • 65. 不用加减乘除做加法
                                                                                                                                                        • 66. 构建乘积数组
                                                                                                                                                          • 67. 把字符串转换成整数
                                                                                                                                                            • 68. 树中两个节点的最低公共祖先
                                                                                                                                                              • 7. 重建二叉树
                                                                                                                                                                • 8. 二叉树的下一个结点
                                                                                                                                                                  • 9. 用两个栈实现队列

                                                                                                                                                                    6. 从尾到头打印链表

                                                                                                                                                                    2022年5月21日大约 2 分钟

                                                                                                                                                                    此页内容
                                                                                                                                                                    • 题目链接
                                                                                                                                                                    • 题目描述
                                                                                                                                                                    • 解题思路
                                                                                                                                                                      • 1. 使用递归
                                                                                                                                                                      • 2. 使用头插法
                                                                                                                                                                      • 3. 使用栈

                                                                                                                                                                    # 6. 从尾到头打印链表

                                                                                                                                                                    # 题目链接

                                                                                                                                                                    牛客网open in new window

                                                                                                                                                                    # 题目描述

                                                                                                                                                                    从尾到头反过来打印出每个结点的值。

                                                                                                                                                                    ![img](https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/f5792051-d9b2-4ca4-a234-a4a2de3d5a57.png" width="300px">

                                                                                                                                                                    # 解题思路

                                                                                                                                                                    # 1. 使用递归

                                                                                                                                                                    要逆序打印链表 1->2->3(3,2,1),可以先逆序打印链表 2->3(3,2),最后再打印第一个节点 1。而链表 2->3 可以看成一个新的链表,要逆序打印该链表可以继续使用求解函数,也就是在求解函数中调用自己,这就是递归函数。

                                                                                                                                                                    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
                                                                                                                                                                        ArrayList<Integer> ret = new ArrayList<>();
                                                                                                                                                                        if (listNode != null) {
                                                                                                                                                                            ret.addAll(printListFromTailToHead(listNode.next));
                                                                                                                                                                            ret.add(listNode.val);
                                                                                                                                                                        }
                                                                                                                                                                        return ret;
                                                                                                                                                                    }
                                                                                                                                                                    

                                                                                                                                                                    # 2. 使用头插法

                                                                                                                                                                    头插法顾名思义是将节点插入到头部:在遍历原始链表时,将当前节点插入新链表的头部,使其成为第一个节点。

                                                                                                                                                                    链表的操作需要维护后继关系,例如在某个节点 node1 之后插入一个节点 node2,我们可以通过修改后继关系来实现:

                                                                                                                                                                    node3 = node1.next;
                                                                                                                                                                    node2.next = node3;
                                                                                                                                                                    node1.next = node2;
                                                                                                                                                                    

                                                                                                                                                                    ![img](https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/58c8e370-3bec-4c2b-bf17-c8d34345dd17.gif" width="220px">

                                                                                                                                                                    为了能将一个节点插入头部,我们引入了一个叫头结点的辅助节点,该节点不存储值,只是为了方便进行插入操作。不要将头结点与第一个节点混起来,第一个节点是链表中第一个真正存储值的节点。

                                                                                                                                                                    ![img](https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/0dae7e93-cfd1-4bd3-97e8-325b032b716f-1572687622947.gif" width="420px">

                                                                                                                                                                    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
                                                                                                                                                                        // 头插法构建逆序链表
                                                                                                                                                                        ListNode head = new ListNode(-1);
                                                                                                                                                                        while (listNode != null) {
                                                                                                                                                                            ListNode memo = listNode.next;
                                                                                                                                                                            listNode.next = head.next;
                                                                                                                                                                            head.next = listNode;
                                                                                                                                                                            listNode = memo;
                                                                                                                                                                        }
                                                                                                                                                                        // 构建 ArrayList
                                                                                                                                                                        ArrayList<Integer> ret = new ArrayList<>();
                                                                                                                                                                        head = head.next;
                                                                                                                                                                        while (head != null) {
                                                                                                                                                                            ret.add(head.val);
                                                                                                                                                                            head = head.next;
                                                                                                                                                                        }
                                                                                                                                                                        return ret;
                                                                                                                                                                    }
                                                                                                                                                                    

                                                                                                                                                                    # 3. 使用栈

                                                                                                                                                                    栈具有后进先出的特点,在遍历链表时将值按顺序放入栈中,最后出栈的顺序即为逆序。

                                                                                                                                                                    ![img](https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9d1deeba-4ae1-41dc-98f4-47d85b9831bc.gif" width="340px">

                                                                                                                                                                    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
                                                                                                                                                                        Stack<Integer> stack = new Stack<>();
                                                                                                                                                                        while (listNode != null) {
                                                                                                                                                                            stack.add(listNode.val);
                                                                                                                                                                            listNode = listNode.next;
                                                                                                                                                                        }
                                                                                                                                                                        ArrayList<Integer> ret = new ArrayList<>();
                                                                                                                                                                        while (!stack.isEmpty())
                                                                                                                                                                            ret.add(stack.pop());
                                                                                                                                                                        return ret;
                                                                                                                                                                    }
                                                                                                                                                                    
                                                                                                                                                                    编辑此页open in new window
                                                                                                                                                                    上次编辑于: 2022/5/21 13:08:59
                                                                                                                                                                    贡献者: yzqdev
                                                                                                                                                                    上一页
                                                                                                                                                                    59. 滑动窗口的最大值
                                                                                                                                                                    下一页
                                                                                                                                                                    60. n 个骰子的点数
                                                                                                                                                                    powered by vuepress-theme-home