首页 > 试题广场 > 从尾到头打印链表
[编程题]从尾到头打印链表
输入一个链表,按链表值从尾到头的顺序返回一个ArrayList。

185个回答

添加回答
推荐
方法一:链表从尾到头输出,利
   查看全部
编辑于 2015-06-18 16:53:34 回复(51)
//顺序遍历链表 每次插在集合的最前面不就完了- -
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> arr = new ArrayList();
        if(listNode==null)
            return arr;
        arr.add(listNode.val);
        ListNode next = listNode.next;
        while(next !=null){
            arr.add(0,next.val);
            next = next.next;
        }
        return arr;
    }
}
发表于 2018-11-28 22:57:27 回复(0)
借助一个栈,进去再出栈加入创建的list中
import java.util.ArrayList;
import java.util.Stack;

public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> arr = new ArrayList<>();
        Stack<Integer> s = new Stack<>();
        if (listNode == null){
            return arr;
        }
        else{
            while(listNode != null){
                s.push(listNode.val);
                listNode = listNode.next;
            }
            while(!s.isEmpty()){
                arr.add(s.pop());
            }
            return arr;
        }
    }
}

发表于 2018-11-28 19:59:44 回复(0)

java 递归至简版

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(null==listNode) {
            return new ArrayList();
        }
        ArrayList list = printListFromTailToHead(listNode.next);
        list.add(listNode.val);
        return list;
    }
}
发表于 2018-11-26 23:22:40 回复(0)
先遍历链表取出数据存入arrayList中,再对arrayList进行遍历取反 public ArrayList<Integer> printListFromTailToHead(ListNode listNode)
{ if (listNode == null)
    { return new ArrayList<>();  }
    ArrayList<Integer> arrayList = new ArrayList<>();  while (listNode != null)
    {
        arrayList.add(listNode.val);  listNode = listNode.next;  } if (arrayList != null && arrayList.size() > 0)
    {
        ArrayList<Integer> integerArrayList = new ArrayList<>();  for (int i = arrayList.size() - 1; i >= 0; i--)
        {
            integerArrayList.add(arrayList.get(i));  } return integerArrayList;  } return arrayList; }
发表于 2018-11-22 15:09:10 回复(0)
import java.util.ArrayList;

public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();

        ListNode pointNode = listNode;

        while (pointNode != null) {
            list.add(0, pointNode.val);
            pointNode = pointNode.next;
        }

        return list;
    }
}

发表于 2018-11-20 16:20:51 回复(0)
/**
用堆栈的思想,用一个整数栈保存,然后再读取
*/
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> a = new ArrayList<Integer>();
        int[] st = new int[10000];
        int top=-1;
        ListNode p=null;
        p=listNode;
        while(p != null){
            top++;
            st[top]=p.val;
            p=p.next;
        }
        while(top>=0){
            a.add(Integer.valueOf(st[top]));
            top--;
        }
        return a;
    }
}
发表于 2018-11-17 12:52:59 回复(0)
import java.util.*;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> al = new ArrayList<Integer>();
        while(listNode != null){
            al.add(listNode.val);
            listNode = listNode.next;
        }
        int list_i, list_j, size = al.size();
        for(int i=0,mid=size>>1,j=size-1; i<mid; i++,j--){
            list_i = al.get(i);
            list_j = al.get(j);
            al.set(i, list_j);
            al.set(j, list_i);
        }
        return al;
    }
}


发表于 2018-11-16 22:11:25 回复(0)

方法一: 不使用Stack,直接用add(int index, Element e)增加指定元素到链表指定位置.

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

方法二:借助栈先入后出的原理,不太好感觉,引入了两个辅助空间,很蠢

import java.util.*;
import java.util.ArrayList;
public class Solution {
    public ArrayList printListFromTailToHead(ListNode listNode) {
        ArrayList list = new ArrayList();
        Stack st = new Stack();
        if(listNode == null)
            return list;
        st.push(listNode.val);
        while(listNode.next != null) {
            listNode = listNode.next;
            st.push(listNode.val);
        }
        while(!st.empty()){
            list.add(st.pop());
        }
        return list;
    }
}

方法三:用栈的地方就可以用递归,代码很简洁。但是链表很长的时候调用的层级就很深,可能会导致函数的调用栈溢出


public class Solution {
    ArrayList<Integer> arrayList=new ArrayList<Integer>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode!=null){
            this.printListFromTailToHead(listNode.next);
            arrayList.add(listNode.val);
        }
        return arrayList;
    }
}
编辑于 2018-11-13 15:23:10 回复(0)
其实并没有那么麻烦arraylist中有一个方法就是在固定某个位置插入元素,只要我们不断在0的位置插入元素,就能实现倒叙了,
真的没有那么麻烦,不用什么堆栈
真的没有那么麻烦,不用什么堆栈
真的没有那么麻烦,不用什么堆栈
真的没有那么麻烦,不用什么堆栈

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
     ListNode q = listNode;
        ArrayList<Integer> al = new ArrayList<>();
        while(q != null) {
            al.add(0,q.val);
            q = q.next;
        }
        return al;
        }
    
}

发表于 2018-10-19 21:27:59 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> array = new ArrayList<Integer>();
        if(listNode==null){
            return array;
        }else{incertNode(array,listNode);
        return array;}
    }
    public static void incertNode(ArrayList<Integer> array ,ListNode listNode ){
         if(listNode.next!=null){
            incertNode(array,listNode.next);
        }
          array.add(listNode.val);
    }
}
直接利用递归进行求解【过程中忘记了空链表的特例,一直报错】

发表于 2018-10-17 09:58:33 回复(0)
// Java
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> newArrayList = new ArrayList<Integer>();
        if (listNode != null){
            newArrayList.addAll(this.printListFromTailToHead(listNode.next));
            newArrayList.add(listNode.val);
        }
        return newArrayList;
    }
}

发表于 2018-10-13 17:52:30 回复(0)
链表从头到尾输出,很容易想起栈,栈的特点就是先进后出。先用一个栈存进来的每一个值,然后list就添加栈pop返回并删除的栈顶元素。
发表于 2018-09-26 21:20:38 回复(0)
1. 栈
首先想到的是后进先出,就用现成的栈结构来做:
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> stack = new Stack<>();
        ArrayList<Integer> arrayList = new ArrayList<>();
        while (listNode != null){
            //推入栈
            stack.push(listNode.val);
            //移至下一个节点
            listNode = listNode.next;
        }
        //推出所有元素
        while (!stack.isEmpty()){
            arrayList.add(stack.pop());
        }
        return arrayList;
    }
}

2. 递归
先找到最后一个节点,然后递归添加到 ArrayList:
import java.util.ArrayList;
public class Solution {
    ArrayList<Integer> list = new ArrayList<>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if (listNode != null){
            printListFromTailToHead(listNode.next);
            list.add(listNode.val);
        }
        return list;
    }
}
发表于 2018-09-26 18:03:44 回复(0)
方法一:转置链表,缺点是改变了链表原来的结构
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        
        ArrayList<Integer> array = new ArrayList<Integer>();
        ListNode pnode = null;
        ListNode nnode = null;
        if(listNode==null)    return array;
        while(listNode!=null){
            nnode = listNode.next;
            listNode.next = pnode;
            pnode = listNode;
            listNode = nnode;
        }
        while(pnode!=null){
            array.add(pnode.val);
            pnode = pnode.next;
        }
        return array;
}

方法二:利用栈先进后出的特点,循环链表将每个数放入栈中,再循环输出栈中元素
注意:如果链表为空{}, 返回的是一个空栈 [] ,而不是 null
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode ==null){
            ArrayList<Integer> arr =newArrayList<Integer>();
            returnarr;
        }
        Stack<Integer> stack =newStack<Integer>();
        while(listNode !=null){
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        ArrayList<Integer> arr =newArrayList<Integer>();
        while(!stack.isEmpty()){
            arr.add(stack.pop());
        }
        returnarr;
    }
	


方法三:利用递归的思想   
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> array =newArrayList<Integer>();
        if(listNode!=null){
            if(listNode.next!=null){
                array = printListFromTailToHead(listNode.next);
            }
            array.add(listNode.val);
        }
        return array;
    }




编辑于 2018-09-25 08:40:26 回复(0)
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList list = new ArrayList();
        Stack stack = new Stack();
        while(listNode!=null){
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        while(!stack.empty()){
            list.add(stack.peek());
            stack.pop();
        }
        return list;
    }
}

发表于 2018-09-21 11:03:07 回复(0)
两种解题思路,第一种依靠栈的“先进后出”性质;第二种利用递归到链表尾,将后面的先放在arraylist里
发表于 2018-09-10 22:22:04 回复(0)
/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.*;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> s = new Stack<>();
        ArrayList<Integer> arr = new ArrayList<>();
        while(listNode != null){
            s.add(listNode.val);
            listNode = listNode.next;
        }
        while(!s.isEmpty()){
            arr.add(s.pop());
        }
        return arr;
    }
}
发表于 2018-09-03 15:28:15 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList list = new ArrayList();
        while(listNode != null){
            ListNode p = null;
            ListNode q = null;
            p = listNode;
            if(listNode.next != null)
                q = listNode.next;
            else{
                list.add(p.val);
                break;
            }
            while(q.next != null){
                p = q;
                q = q.next;
            }
            list.add(q.val);
            p.next = null;
        }
        return list;
    }
}

发表于 2018-08-31 15:49:52 回复(0)

// 不依赖全局变量, 无副作用,Java语法终究是太拖沓
public static ArrayList intListFromTailToHead(ListNode listNode) { if (listNode == null) return new ArrayList(); ArrayList ls = printListFromTailToHead(listNode.next); ls.add(listNode.val); return ls; }

编辑于 2018-08-30 15:07:29 回复(0)
提供一个思路:先计算出链表的长度,通过长度创建一个数组,下标从后向前添加链表节点值。
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
       ArrayList<Integer> result = new ArrayList<Integer>();
        if(listNode == null){
            return result;
        }
        int size = 1;
        ListNode last = listNode;
        while(last.next!=null){
            size++;
            last = last.next;
        }
        last = listNode;
        int[] data = new int[size];
        for(int i=size-1;i>=0;i--){
            data[i] = last.val;
            last = last.next;
        }
        for(int i=0;i<data.length;i++){
            result.add(data[i]);
        }
        return result;
    }
}

发表于 2018-08-28 17:46:08 回复(0)

扫一扫,把题目装进口袋

牛客网,程序员必备求职神器

扫描二维码,进入QQ群

扫描二维码,关注牛客网公众号

  • 公司地址:北京市朝阳区大屯路东金泉时代3-2708北京牛客科技有限公司
  • 联系方式:010-60728802(电话) admin@nowcoder.com
  • 牛客科技©2018 All rights reserved
  • 京ICP备14055008号-4
  • 京公网安备 11010502036488号