首页 > 试题广场 > 从尾到头打印链表
[编程题]从尾到头打印链表
输入一个链表,按链表值从尾到头的顺序返回一个ArrayList。
推荐
方法一:链表从尾到头输出,利用递归实现,不使用库函数直接printf输出的时候用递归比较好
/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(struct ListNode* head) {
        vector<int> value;
        if(head != NULL)
        {
            value.insert(value.begin(),head->val);
            if(head->next != NULL)
            {
                vector<int> tempVec = printListFromTailToHead(head->next);
                if(tempVec.size()>0)
                value.insert(value.begin(),tempVec.begin(),tempVec.end());  
            }         
            
        }
        return value;
    }
};
方法二:用库函数,每次扫描一个节点,将该结点数据存入vector中,如果该节点有下一节点,将下一节点数据直接插入vector最前面,直至遍历完,或者直接加在最后,最后调用reverse
/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(struct ListNode* head) {
        vector<int> value;
        if(head != NULL)
        {
            value.insert(value.begin(),head->val);
            while(head->next != NULL)
            {
                value.insert(value.begin(),head->next->val);
                head = head->next;
            }         
            
        }
        return value;
    }
};

编辑于 2015-06-18 16:53:34 回复(63)
/**
*    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) {
        ArrayList<Integer> array = new ArrayList<>();
        //array.add(listNode.val);
        while(listNode != null) {
            array.add(0, listNode.val);
            listNode = listNode.next;
        }
        return array;
    }
}

发表于 2019-07-17 08:25:16 回复(0)
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();
        if (listNode == null) {
            return list;
        }
        ListNode p = listNode;

        while (p != null) {
            list.add(0, p.val);
            p = p.next;
        }
        return list;
    }
发表于 2019-07-16 17:52:27 回复(0)
/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    /*单链表中的节点应该具有两个属性:val 和 next。
    val 是当前节点的值
    next 是指向下一个节点的指针/引用*/
    ArrayList<Integer> array = new ArrayList<Integer>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
       if(listNode != null){
           printListFromTailToHead(listNode.next);
           array.add(listNode.val);
       }
        return array;
    }
}
发表于 2019-07-10 17:24:05 回复(0)
/**
*    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) {
        ArrayList<Integer> result = new ArrayList<>();
        ListNode pHead = null;
        ListNode pNode = listNode;
        ListNode pre = null;
        while(pNode !=null){
            ListNode pNext = pNode.next;
            if(pNext==null)
                pHead = pNode;
            pNode.next = pre;
            pre = pNode;
            pNode = pNext;
        }
        while(pHead!=null){
            result.add(pHead.val);
            pHead = pHead.next;
        }
        return result;
    }
}

发表于 2019-07-08 16:24:39 回复(0)
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList res=new ArrayList<Integer>();
        Stack stack=new Stack<Integer>();

        ListNode p=listNode;
        while(p!=null){
            stack.push(p.val);
            p=p.next;
        }
        while(!stack.isEmpty()){
            res.add(stack.pop());
        }
        return res;
    }
}
发表于 2019-07-04 21:04:28 回复(0)
方法一:递归 方法二:栈 方法三:链表反转
发表于 2019-07-01 16:55:48 回复(0)
直接使用栈
Stack<Integer> queue = new Stack<>(); int i = 0;  while (listNode!=null){
    queue.push(listNode.val);
  listNode = listNode.next;   i++;  }
ArrayList<Integer> mList = new ArrayList<>(i); while (i>0){
    mList.add((Integer) queue.pop()); i--; } return mList;

发表于 2019-06-26 19:58:23 回复(1)
import java.util.ArrayList;
import java.util.Collections;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        while (listNode != null) {
            list.add(listNode.val);
            listNode = listNode.next;
        }
        Collections.reverse(list);
        return list;
    }
}

如果该节点不为空,就把数据放入 ArrayList<Integer>
最后反转
发表于 2019-06-26 09:36:11 回复(0)
//链表长度未知
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> temp = new ArrayList();
        while(listNode != null ){
            temp.add(listNode.val);
            listNode=listNode.next;
        }
        ArrayList<Integer> res = new ArrayList();
        for(int i = temp.size()-1; i>=0; i--)
            res.add(temp.get(i));
        return res;
    }
}
  • 目前我能想到的就是先把链表赋值给一个ArrayList,然后再把这个ArryList 赋值给新的ArrayList,很low对不对 哈哈
编辑于 2019-06-25 15:47:36 回复(0)
Collections有个方法直接可以把ArrayList反序输出 
Collections..reverse(list);
发表于 2019-06-13 10:29:57 回复(0)
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> array = new ArrayList<Integer>();
        while(listNode != null) {
            array.add(0,listNode.val);
            listNode = listNode.next;
        }
        
        return array;
        
    }
}

发表于 2019-06-01 15:37:57 回复(0)
  ArrayList<Integer> list = new ArrayList<>();
while(p!=null){
            result.add(0,p.val);
            p=p.next;
        }
利用ArrayList的add函数,从头到尾遍历链表,每次都把新值放在list的第一个位置,其余后移。不需要自己造轮子,调用add函数即可。
发表于 2019-05-30 20:32:29 回复(0)
//利用几何的反转工具,先顺序存入在反转,不知道这种做法可以不?还请大家指点,感觉本题主要是考察链表的反转,这样做就避开了链表的翻转,感觉有点偷懒
import java.util.ArrayList;
import java.util.Collections;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();
        ListNode p = listNode;
        while(p!=null){
            list.add(p.val);
            p = p.next;
        }
        Collections.reverse(list);
        return list;
        
    }
}
发表于 2019-05-27 16:29:49 回复(0)
可以使用栈的先入后出特性,不过需要额外引入java.util.Stack;在不使用栈的情况下,我的解决方法是先反转链表再存入到ArrayList。
发表于 2019-05-16 10:16:56 回复(0)
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    if (listNode == null) {
        return list;
    }
    list.add(listNode.val);
    while ((listNode = listNode.next) != null) {
        list.add(listNode.val);
    }
    for (int i = 0; i < list.size() / 2 ; i++) {
        Collections.swap(list, i , list.size() - i - 1);
    }
     return list;
}
第一想法是这样的😂

编辑于 2019-05-13 22:42:26 回复(0)