11天刷完《剑指Offer》/ Day7：第55~58题

做不到最初的计划2月底弄完，一方面手生，一方面事情也多，但是每天坚持做几道，有时发的时候可能还是写在一篇里，形式上的东西不是很要紧。这周应该可以结束！

55.链表中环的入口结点

• 题目描述

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

• 解题思路：
  第一次不会做，参考树上思路，
  1.判断链表中有环 -> 2.得到环中节点的数目 -> 3.找到环中的入口节点

public class Solution {
 
    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        if(pHead == null){
            return null;
        }
        // 1.判断链表中有环
        ListNode l=pHead,r=pHead;//这里不能写成 ListNode l,r=pHead;
        boolean flag = false;
        while(r != null && r.next!=null){
            l=l.next;
            r=r.next.next;
            if(l==r){
                flag=true;
                break;
            }
        }
        if(!flag){
            return null;
        }else{
            // 2.得到环中节点的数目
            int n=1;
            r=r.next;
            while(l!=r){
                r=r.next;
                n++;
            }
            // 3.找到环中的入口节点
            l=r=pHead;
            for(int i=0;i<n;i++){
                r=r.next;
            }
            while(l!=r){
                l=l.next;
                r=r.next;
            }
            return l;
        }
 
    }
}

56. 删除链表中重复的节点

• 题目描述

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

• 解题思路
  这道题蛮难的，链表指向麻烦死了，总结了有几个思路，注意积累！

1.递归法：

public class Solution {
    public ListNode deleteDuplication(ListNode pHead) {
        if (pHead == null || pHead.next == null) { // 只有0个或1个结点，则返回
            return pHead;
        }
        if (pHead.val == pHead.next.val) { // 当前结点是重复结点
            ListNode pNode = pHead.next;
            while (pNode != null && pNode.val == pHead.val) {
                // 跳过值与当前结点相同的全部结点,找到第一个与当前结点不同的结点
                pNode = pNode.next;
            }
            return deleteDuplication(pNode); // 从第一个与当前结点不同的结点开始递归
        } else { // 当前结点不是重复结点
            pHead.next = deleteDuplication(pHead.next); // 保留当前结点，从下一个结点开始递归
            return pHead;
        }
    }
}

2.非递归：新建头结点，若头结点重复，要删除头结点

链接：https://www.nowcoder.com/questionTerminal/fc533c45b73a41b0b44ccba763f866ef?answerType=1&f=discussion
来源：牛客网

public class Solution {
    public ListNode deleteDuplication(ListNode pHead) {
        if (pHead == null || pHead.next == null) {
            return pHead;
        }
 
        ListNode head = new ListNode(-1); // 新建一个头结点，防止链表中头结点是重复节点被删除。
        ListNode trail = head;
 
        while (pHead != null) {
            ListNode node = pHead.next;
            boolean flag = false;
            while (node != null && pHead.val == node.val) {
                node = node.next;
                flag = true;
            }
            if (!flag) {
                trail.next = pHead;
                trail = trail.next;
            }
            pHead = node;
        }
        trail.next = null; // 1->2->3->3->3
        return head.next;
    }
}

57.二叉树的下一个节点

• 题目描述

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

1. 解题思路

分析二叉树的下一个节点，一共有以下情况：
1. 二叉树为空，则返回空；
2. 节点右孩子存在，则设置一个指针从该节点的右孩子出发，一直沿着指向左子结点的指针找到的叶子节点即为下一个节点；
3. 节点不是根节点。如果该节点是其父节点的左孩子，则返回父节点；否则继续向上遍历其父节点的父节点，重复之前的判断，返回结果。

/*
public class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;//  父节点的定义

    TreeLinkNode(int val) {
        this.val = val;
    }
}
*/
public class Solution
{
    public TreeLinkNode GetNext(TreeLinkNode node)
    {
        if(node==null)return null;
        if(node.right!=null)
        {
            node=node.right;//有右孩子，自身变成右节点
            while(node.left!=null)
            {
                node=node.left;//有左节点，变成初始节点的右节点的左孩子
               
            }return node;
        }
        while(node.next!=null)
        {
            if(node.next.left==node)return node.next;
            node=node.next;
        }
        return null;
    }
}

58.对称的二叉树

• 题目描述

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

• 解题思路

递归：

boolean isSymmetrical(TreeNode pRoot) {
        if (pRoot == null)
            return true;
 
        return f(pRoot.left,pRoot.right);
    }
     
    boolean f(TreeNode t1, TreeNode t2) {
        if (t1 == null && t2 == null)
            return true;
         
        if (t1 != null && t2 != null)
            return t1.val == t2.val && f(t1.left,t2.right) && f(t1.right, t2.left);
         
        return false;
    }

非递归 BFS
学习下别人的思路，BFS使用Queue来保存成对的节点

• 1.出队的时候也是成对成对的
  1.若都为空，继续；
  2.一个为空，返回false;
  3.不为空，比较当前值，值不等，返回false；
• 2.确定入队顺序，每次入队都是成对成对的，如left.left， right.right ;left.rigth,right.left

boolean isSymmetricalBFS(TreeNode pRoot)
    {
        if(pRoot == null) return true;
        Queue<TreeNode> s = new LinkedList<>();
        s.offer(pRoot.left);
        s.offer(pRoot.right);
        while(!s.isEmpty()) {
            TreeNode left= s.poll();//成对取出
            TreeNode right= s.poll();
            if(left == null && right == null) continue;
            if(left == null || right == null) return false;
            if(left.val != right.val) return false;
            //成对插入
            s.offer(left.left);
            s.offer(right.right);
            s.offer(left.right);
            s.offer(right.left);
        }
        return true;
    }