从尾到头打印链表+反转链表

3从尾到头打印链表

思想1）：直接堆栈先进后出，调换顺序

考点:    新建栈                                            Stack<Integer> stk=new Stack<Integer>();

            进栈：                                            stk.push(listNode.val);

            栈指针向下一个：                           listNode=listNode.next;

            新建类型为Integer的ArrayList        ArrayList<Integer> arr=new ArrayList<Integer>();

            出栈                                               while(!stk.isEmpty())     {  arr.add(stk.pop());  }

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

法二：利用递归，递归也是栈的思想体现

 

import java.util.ArrayList;  
    public class Solution {  
        ArrayList<Integer> arrayList = new ArrayList<Integer>();  
        //使用递归实现  
        public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {  
            if (listNode != null) {  
                printListFromTailToHead(listNode.next);  
                arrayList.add(listNode.val);  
            }  
            return arrayList;  
        }  
    }

4输入一个链表，反转链表后，输出链表的所有元素。

思想：其实链表的问题就类似于指针的问题，在于你要把它的指针当成一个节点来看。在反转的时候你要断开它的链也就是把它的p.next指向它的p.pre,但是链子断了之后容易丢失，所以要找一个pNext来记住头结点的下一个位置，即断裂的地方。

考点：1）定义pNext为头节点的下一个位置，记录断裂的地方      ListNode pNext=head.next;

            定义新头，最后返回链表其实只用返回头就行了             ListNode newhead=null;

          2）  p的指针从下一个指向前一个              p.next=pPre;
                pPre往后移一个挪到p的位置               pPre=p;
                 同理p往后移挪到pNext的位置            p=pNext;

特意画的一张框图，你敢信？？为了昨天的惨痛教训，没得法

/*
public class ListNode {
    int val;
    ListNode next = null;
    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        ListNode pre = null;
        ListNode next = null;
        
        while(head!=null){
            next = head.next;          //持有下一个节点的引用
            head.next = pre;           //将当前节点对下一个节点的引用指向前一个节点
            pre = head;                //将前一个节点指向当前节点
            head = next;               //将当前节点指向下一个节点
        }
        return pre;
    }
    
}