链表思路记录1.JZ6 从尾到头打印链表

1.JZ6 从尾到头打印链表

链表学习参考：https://blog.csdn.net/m0_53656722/article/details/127892069
描述
输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。

如输入{1,2,3}的链表如下图:

返回一个数组为[3,2,1]

0 <= 链表长度 <= 10000
示例1
输入：
{1,2,3}
返回值：
[3,2,1]
示例2
输入：
{67,0,24,58}
返回值：
[58,24,0,67]
我的解题思路：递归
代码：

import java.util.*;
/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    public void printListFromTailToHead1(ListNode listNode, ArrayList<Integer> list) {
        if(listNode != null){
            printListFromTailToHead1(listNode.next,list);
            list.add(listNode.val);
        }
    }
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer>  list = new ArrayList<>();
        if(listNode != null){
            printListFromTailToHead1(listNode, list);
        }
        return list;
    }
}

复杂度分析：
时间复杂度：O(n)，其中n为链表长度，递归遍历一次链表
空间复杂度：O(n)，递归栈的最大空间为链表长度

方法二：栈（扩展思路）
知识点：栈
栈是一种仅支持在表尾进行插入和删除操作的线性表，这一端被称为栈顶，另一端被称为栈底。元素入栈指的是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；元素出栈指的是从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

思路：

递归的思想也可以用栈实现，因为栈是先进后出的，符合逆序的特点，递归本质上就是用栈实现的。

具体做法：

step 1：我们可以顺序遍历链表，将链表的值push到栈中。
step 2：然后再依次弹出栈中的元素，加入到数组中，即可实现链表逆序。

import java.util.*;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        Stack<Integer> s = new Stack<Integer>();
        //正序输出链表到栈中
        while(listNode != null){ 
            s.push(listNode.val);
            listNode = listNode.next;
        }
        //输出栈中元素到数组中
        while(!s.isEmpty()) 
            res.add(s.pop());
        return res;
    }
}

我的代码：

import java.util.*;
/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<ListNode> stack = new Stack<>();
        while(listNode!=null){
            stack.push(listNode);
            listNode = listNode.next;
        }
        ArrayList<Integer>  list = new ArrayList<>();
        while(!stack.isEmpty()){
            ListNode tmp = stack.pop();
            list.add(tmp.val);
        }
        return list;
    }
}

补充：在csdn机器人那里学习的栈
Java中的栈是一种用于存储数据的数据结构。栈遵循"先进后出"（Last In First Out，LIFO）的原则，即最后放入栈的元素最先被取出。

在Java中，栈可以通过Java的集合类java.util.Stack来实现。Stack类继承自Vector类，并提供了一些额外的方法，使其具有栈的特性。

你可以使用Stack类的push()方法将元素压入栈顶，使用pop()方法将栈顶元素弹出并返回，使用peek()方法获取栈顶元素而不移除它。Stack类还提供了一些其他方法，如empty()用于判断栈是否为空，search()用于查找元素在栈中的位置等。

以下是一个简单的示例代码，展示了如何使用Stack类实现栈的功能：

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();

        // 将元素压入栈顶
        stack.push("Java");
        stack.push("Python");
        stack.push("C++");

        // 获取并移除栈顶元素
        String topElement = stack.pop();
        System.out.println("弹出的元素：" + topElement);

        // 获取栈顶元素但不移除
        String peekElement = stack.peek();
        System.out.println("栈顶元素：" + peekElement);

        // 判断栈是否为空
        boolean isEmpty = stack.empty();
        System.out.println("栈是否为空：" + isEmpty);

        // 查找元素在栈中的位置（从栈顶开始计数）
        int position = stack.search("Java");
        System.out.println("元素\"Java\"在栈中的位置：" + position);
    }
}

这里推荐我在学习中看到的一篇讲解java中的栈的文章：java中的栈