【剑指offer】03——从尾到头打印链表

题目描述

  输入一个链表，按链表值从尾到头的顺序返回一个 ArrayList 。

一、解题思路

1、使用栈

  栈的特点是“先进后出”，那么我们就可以遍历链表，链表顺序将链表值依次入栈，然后我们在进行出栈操作，并加入到 ArrayList 中即可。

2、头插法

  利用的是链表头插法为逆序的特征。逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。

3、递归

  递归的本质还是使用了栈结构

二、Java代码

//1、使用栈
import java.util.ArrayList;
import java.util.Stack;

public class Solution {
    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());  //执行出栈，加入到ArrayList中
        }
        return ret;
    }
}

//2、头插法
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ListNode head = new ListNode(-1);  //创建新的链表
        while(listNode != null){  //如果链表不为空
            ListNode p = listNode.next;  //记录下个节点的地址，防止段链
            listNode.next = head.next;  //listNode的下个节点指向head的下个节点，也就是listNode的第一个元素的下一个元素为head的第一个元素
            head.next = listNode; //head指向listNode，此时listNode就是要插入的那个元素，并且这个元素经过上一步操作已经连接到原本head的下个节点
            listNode = p;  //加p赋给listNode，相比之前少了第一个元素
        }
        
        ArrayList<Integer> ret = new ArrayList<>();
        head = head.next;  //head指向head的下个节点，也就是去掉之前创建的时候的第一个节点-1
        while(head != null){
            ret.add(head.val);
            head = head.next;
        }
        
        return ret;
    }
}

//3、递归
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        
        if(listNode!=null){
            list = printListFromTailToHead(listNode.next);
            list.add(listNode.val);
        }
        
        return list;
    }
}

三、C++代码

class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        stack<int> nodes;  //创建堆栈
        vector<int> result;  //结果
        ListNode* node = head;  //创建链表node
        while(node != NULL){
            nodes.push(node->val);  //将值push到堆栈中
            node = node->next;  //指向下个节点
        }
        
        while(!nodes.empty()){  //如果堆栈不为空
            result.push_back(nodes.top()); //取出栈顶元素（不删除元素），并添加到vector最后面
            nodes.pop();  //出栈（删除元素）
        }
        
        return result;
    }
};

四、Python代码

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if not listNode:
            return []
        
        result = []
        
        while listNode:
            result.insert(0, listNode.val)  # 将指定对象插入列表的下标为0的地方，也就是第一个元素
            listNode = listNode.next
        return result