lee简单链表

在递归的归的过程，在意的东西是归来的这个东西，这个被整理好的链表，我要在这个整理好的链表后面，然后我的next要为null。
注意我这里的操作和前面的差别，，将归来的部分的尾巴指向head,然后head会成为归来部分的新尾巴，也就是head.next == null,最后将归来部分交给上一层就行了
每次递归回来都是整理好的链表，我们只需要将head放在整理好的链表后面就行了。让Head当尾巴
每一个回合，完成的都是这样的交换，将next和head交换一下位置，然后将next作为新的头节点返回回去。

。。。。。。

快慢指针找到回文字符串中点
两个指针
fast一次走两个
slow一次走一个


快慢指针：fast 一次走两步；slow 一次走一步。利用快慢指针来找到链表的中点，当 fast 指针走到链表结尾时，slow 指针一定是在链表的中点位置，此时返回链表中点的节点。

class Solution {
     

    public boolean isPalindrome(ListNode head) {
     

        if (head == null || head.next == null) return true;

        Stack<ListNode> stack = new Stack<>();
        ListNode slow = head;
        ListNode fast = head;

        while (fast != null && fast.next != null && fast.next.next != null) {
     

            slow = slow.next;
            fast = fast.next.next;
        }

        ListNode mid = slow;

        while (mid.next != null) {
     

            stack.push(mid.next);
            mid = mid.next;
        }

        ListNode p = head;
        while (!stack.isEmpty()) {
     

            if (p.val != stack.pop().val) {
     

                return false;
            }
            p = p.next;
        }
        return true;
    }
}

根据栈的特点进行先进后出操作！有意思，反转链表也可以啊

class Solution {
     
    public int[] reversePrint(ListNode head) {
     
        
        //使用栈
        Stack<Integer> stack = new Stack<>();
        while(head != null){
     
            stack.push(head.val);
            head = head.next;
        }
        int size = stack.size();
        int[] print = new int[size];
        for(int i = 0;i < size;i++){
     
            print[i] = stack.pop();
        }
        return print;


    }
}