菜鸟笔记
提升您的技术认知

剑指offer

《剑指Offer》刷题目笔记

剑指Offer 数组

《剑指Offer》二维数组中的查找《剑指Offer》旋转数组的最小数字《剑指Offer》调整数组顺序使奇数位于偶数前面《剑指Offer》数组中出现次数超过一半的数字《剑指Offer》连续子数组的最大和《剑指Offer》把数组排成最小的数《剑指Offer》数组中的逆序对《剑指Offer》数字在排序数组中出现的次数《剑指Offer》数组中只出现一次的数字《剑指Offer》数组中重复的数字《剑指Offer》构建乘积数组

剑指Offer 字符串

《剑指Offer》替换空格《剑指Offer》字符串的排列《剑指Offer》第一个只出现一次的字符《剑指Offer》左旋转字符串《剑指Offer》翻转单词顺序序列《剑指Offer》把字符串转换成整数《剑指Offer》正则表达式匹配《剑指Offer》表示数值的字符串

剑指Offer 链表

《剑指Offer》从尾到头打印链表《剑指Offer》链表中倒数第k个结点《剑指Offer》反转链表《剑指Offer》合并两个排序的链表《剑指Offer》复杂链表的复制《剑指Offer》两个链表的第一个公共结点《剑指Offer》链表中环的入口结点《剑指Offer》删除链表中重复的结点

剑指Offer 树

《剑指Offer》重建二叉树《剑指Offer》树的子结构《剑指Offer》二叉树的镜像《剑指Offer》从上往下打印二叉树《剑指Offer》二叉树中和为某一值的路径《剑指Offer》二叉树的深度《剑指Offer》平衡二叉树《剑指Offer》二叉树的下一个结点《剑指Offer》对称的二叉树《剑指Offer》按之字顺序打印二叉树《剑指Offer》把二叉树打印成多行《剑指Offer》序列化二叉树

《剑指Offer》从尾到头打印链表

阅读 : 1527

题目描述:

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

解题思路:

  (三种方法:借助栈、递归、列表的首位插入)

  从头到尾打印链表比较简单,从尾到头很自然的可以想到先将链表进行反转,然后再打印。但是,通常我们不希望改变原链表的结构,这是一个只读操作。

  因此,我们进一步分析,可以发现排在后面的先输出,这是一个典型的“后入先出”的思想,因此很自然的可以想到用栈来实现,每遍历一个结点,可以将其压入栈中,遍历结束后再逐个弹栈,将结点值存入ArrayList,这样就实现了从尾到头的打印。

  更进一步,既然想到了用栈,那一定可以通过递归来实现。每访问到一个结点,先递归输出其后的结点,在输出该结点自身即可。

  另外,当我们使用Java或者python语言时,有一种比较巧妙的方法就是使用列表的插入方法,每次插入数据,都总是插入到首位,这样得到的List就是从尾到头的链表序列。

代码实现(c++)

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        stack<int> nodes;
        vector<int> result;
        ListNode* node = head;
        while(node != NULL){
            nodes.push(node->val);
            node = node->next;
        }

        while(!nodes.empty()){
            result.push_back(nodes.top());
            nodes.pop();
        }
        return result;
    }
};

代码实现(java)

//方法一:借助栈的后入先出实现
   public ArrayList<Integer> printListFromTailToHead(ListNode listNode){
        ArrayList<Integer> list=new ArrayList<>();
        if(listNode==null)
            return list;
        ListNode head=listNode;
        Stack<ListNode> stack=new Stack<>();
        while(head!=null){  //依次压入栈中
            stack.push(head);
            head=head.next;
        }
        while(!stack.isEmpty()){ //逐个弹栈
            ListNode temp=stack.pop();
            list.add(temp.val);
        }
        return list;
    }

     //方法二:递归实现
     public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list=new ArrayList<>();
        getNext(listNode,list);
        return list;
    }
    public void getNext(ListNode listNode,ArrayList<Integer> list){
        if(listNode!=null){
            getNext(listNode.next,list); //先递归输出其后的结点
            list.add(listNode.val); //再输出自身
        }
    }

    //方法三:列表的首位插入
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode){
        ArrayList<Integer> list=new ArrayList<>();
        if(listNode==null)
            return list;
        ListNode head=listNode;
        while(head!=null){ 
            list.add(0,head.val);  //每次插入数据,都总是插入到首位
            head=head.next;
        }
        return list;
    }