剑指offer题解56-60（Java）

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

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

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead){
        if(pHead == null || pHead.next == null){
            return pHead;
        }
      //辅助节点，处理头节点就是重复节点的情况
        ListNode head = new ListNode(Integer.MIN_VALUE);
        head.next = pHead;
        ListNode last=head;
        ListNode cur=head.next;
        while(cur!=null){
            if(cur.next!=null&&cur.next.val==cur.val){
                while(cur.next!=null&&cur.next.val==cur.val){
                    cur=cur.next;
                }
                cur=cur.next;
                last.next=cur;
            }
            else{
                last=cur;
                cur=cur.next;
            }
            
        }
        return head.next;

    }
}

57.二叉树的下一个节点

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

public class Solution {
    public TreeLinkNode GetNext(TreeLinkNode pNode) {
      //右子树不为空，返回右子树的最左子树
        if (pNode.right != null) {
            TreeLinkNode cur = pNode.right;
            while (cur.left != null) {
                cur = cur.left;
            }
            return cur;
        }
      //父节点不为空，当前节点为左节点，返回父节点
        if (pNode.next != null && pNode.next.left == pNode) {
            return pNode.next;
        }
      //父节点不为空，当前节点为右节点，返回最父节点
        if (pNode.next != null&&pNode.next.right == pNode) {
            TreeLinkNode pre = pNode.next;
            while (pre.next != null && pre.next.right == pre) {
                pre = pre.next;
            }
            return pre.next;

        }
        return null;
    }
}

58.对称二叉树

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

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    boolean judge(TreeNode right, TreeNode left) {
      //走到根节点
        if (right == null && left == null) return true;
      //不对称
        else if (right == null || left == null) return false;
//值相等判断左右子树
        if (right.val == left.val) return judge(left.right, right.left) &&judge(right.right, left.left);
        else {
            return false;
        }

    }

    boolean isSymmetrical(TreeNode pRoot) {
        if (pRoot == null) return true;
        return judge(pRoot.right, pRoot.left);
    }
}

59.之字形打印二叉树

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

import java.util.LinkedList;

public class Solution {
    public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        LinkedList<TreeNode> q = new LinkedList<>();
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        boolean rev = true;
        q.add(pRoot);
        while (!q.isEmpty()) {
            int size = q.size();
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = q.poll();
                if (node == null) {
                    continue;
                }
                if (rev) {
                    list.add(node.val);
                } else {
                    list.add(0, node.val);
                }
                q.offer(node.left);
                q.offer(node.right);
            }
            if (list.size() != 0) {
                res.add(list);
            }
            rev = !rev;
        }
        return res;
    }
}

60.二叉树打印成多行

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行

poll 出队

offer 入队

import java.util.*;
/*
跟上一题类似，还更简单，bfs
*/
public class Solution {
    public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        LinkedList<TreeNode> q = new LinkedList<>();
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        q.add(pRoot);
        while (!q.isEmpty()) {
            int size = q.size();
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = q.poll();
                if (node == null) {
                    continue;
                }
                    list.add(node.val);
                q.offer(node.left);
                q.offer(node.right);
            }
            if (list.size() != 0) {
                res.add(list);
            }
  
        }
        return res;
    }
}