Leetcode-234，844，19

234-回文链表

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2
输出: false  

示例 2:

输入: 1->2->2->1
输出: true  

思路：本想将链表逆置然后进行比较，后来想了想用栈去做更简单，因为栈的性质是先进后出，所以就相当于给逆置了，每次只需要比较链表当前结点的值和栈顶的值是否相等就行，如果出现有一个不相等的情况就返回false，否则就返回true。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
       Stack stack = new Stack<>();
            ListNode node = head;
            while(node != null){
                stack.push(node.val);
                node = node.next;
            }
            while(!stack.isEmpty()){
                int val = (int) stack.pop();
                if(head.val != val){
                    return false;
                }
                head = head.next;
            }
        return true;
    }
}

844-比较含退格的字符串

给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：S = "ab#c", T = "ad#c"
输出：true
解释：S 和 T 都会变成 “ac”。
示例 2：

输入：S = "ab##", T = "c#d#"
输出：true
解释：S 和 T 都会变成 “”。
示例 3：

输入：S = "a##c", T = "#a#c"
输出：true
解释：S 和 T 都会变成 “c”。
示例 4：

输入：S = "a#c", T = "b"
输出：false
解释：S 会变成 “c”，但 T 仍然是 “b”。
 

提示：

1 <= S.length <= 200
1 <= T.length <= 200
S 和 T 只含有小写字母以及字符 '#'。

思路：用两个栈来存储字符，遇到#就出栈一个元素，最后比较这两个栈是否相等即可，我这里其实可以将两个栈的代码写一个函数，然后只用调用就行可以减少代码量。

    class Solution {
        public boolean backspaceCompare(String S, String T) {
            if (S.length() < 1 || T.length() < 1 || S == null || T == null) {
                return false;
            }
            int len = S.length() < T.length() ? T.length() : S.length();
            Stack stack = new Stack();
            Stack stack1 = new Stack();
            for (int i = 0; i < S.length(); i++) {
                if(S.charAt(i) != '#'){
                    stack.push(S.charAt(i));
                }else{
                    if(stack.size()<1){
                        continue;
                    }else {
                        stack.pop();
                    }
                }
            }
            for (int i = 0; i < T.length(); i++) {
                if(T.charAt(i) != '#'){
                    stack1.push(T.charAt(i));
                }else{
                    if(stack1.size()<1){
                        continue;
                    }else {
                        stack1.pop();
                    }
                }
            }

            return stack.equals(stack1)?true:false;
        }
        }

19-删除链表的倒数第N个结点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：

给定的 n 保证是有效的。

思路：通过快慢指针来做，先让快指针走到要删除的结点位置，然后此时慢指针还是指向头结点，这时让两个指针同时前进，当fast指针为空的时候，就说明慢指针已经指向了要删除的结点位置，这时候只需要将慢指针的前一个结点指向当前结点的下一个结点即可，因此要定义一个结点来保存慢指针的前一个结点的值。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if (head == null || n <= 0) {
            return null;
        }
        ListNode newHead = new ListNode(0);
        newHead.next = head;
        ListNode slow = head;
        ListNode fast = head;
        int count = 0;
        while(count < n) {
            fast = fast.next;
            count++;
        }
        ListNode preSlow = newHead;
        while(fast != null) {
            preSlow = preSlow.next;
            slow = slow.next;
            fast = fast.next;
        }
        preSlow.next = slow.next;
        return newHead.next;
    }
}