每日算法：朋友圈、島嶼數量、合法二叉樹、後繼者

1、朋友圈

班上有 N 名學生。其中有些人是朋友，有些則不是。他們的友誼具有是傳遞性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那麼我們可以認爲 A 也是 C 的朋友。所謂的朋友圈，是指所有朋友的集合。

給定一個 N * N 的矩陣 M，表示班級中學生之間的朋友關係。如果M[i][j] = 1，表示已知第 i 個和 j 個學生互爲朋友關係，否則爲不知道。你必須輸出所有學生中的已知的朋友圈總數。

輸入: 
[[1,1,0],
 [1,1,0],
 [0,0,1]]
輸出: 2 
說明：已知學生0和學生1互爲朋友，他們在一個朋友圈。
第2個學生自己在一個朋友圈。所以返回2。

輸入: 
[[1,1,0],
 [1,1,1],
 [0,1,1]]
輸出: 1
說明：已知學生0和學生1互爲朋友，學生1和學生2互爲朋友，所以學生0和學生2也是朋友，所以他們三個在一個朋友圈，返回1。

class Solution {
    public int findCircleNum(int[][] arr) {
        if(arr == null || arr.length == 0){
           return 0;
       }
       int[] visited = new int[arr.length];
       int count = 0;
       for(int i = 0;i < arr.length;i++) {
           if(visited[i] == 0){
               visited[i] = 0;
               dfs(arr,visited,i);
               count++;
           }
       }
       return count;
    }

     public  void dfs(int[][] arr, int[] visited,int index){
        for(int j = 0;j < arr.length;j++){
            if(visited[j] == 0 && arr[index][j] == 1){
                visited[j] = 1;
                dfs(arr,visited,j);
            }
        }
    }
}

解題思路也特別easy，就是深度優先遍歷就解決了。就是看連着的他們這一個圈子有多少。

2、島嶼數量

給你一個由 '1'（陸地）和 '0'（水）組成的的二維網格，請你計算網格中島嶼的數量。

島嶼總是被水包圍，並且每座島嶼只能由水平方向或豎直方向上相鄰的陸地連接形成。

此外，你可以假設該網格的四條邊均被水包圍。

輸入:
11110
11010
11000
00000
輸出: 1

輸入:
11000
11000
00100
00011
輸出: 3
解釋: 每座島嶼只能由水平和/或豎直方向上相鄰的陸地連接而成。

class Solution {
    public int numIslands(char[][] grid) {
       if(grid == null || grid.length == 0){
            return 0;
        }
        int n = grid.length;
        int m = grid[0].length;
        int result = 0;
        for(int i = 0;i < n;i++){
            for(int j = 0;j < m;j++){
                if(grid[i][j] == '1'){
                    result++;
                    grid[i][j] = '0';
                    dfs(grid,i,j);
                }
            }
        }
        return result;
    }

    public  void dfs(char[][] grid,int i,int j){
        
        int m = grid.length - 1;
        int n = grid[0].length - 1;
        if(i - 1 >= 0 && grid[i - 1][j] == '1'){
            grid[i - 1][j] = '0';
            dfs(grid,i - 1,j);
        }
        if(i + 1 <= m && grid[i + 1][j] == '1'){
            grid[i + 1][j] = '0';
            dfs(grid,i + 1,j);
        }
        if(j - 1 >= 0 && grid[i][j - 1] == '1'){
            grid[i][j - 1] = '0';
            dfs(grid,i,j - 1);
        }
        if(j + 1 <= n && grid[i][j + 1] == '1'){
            grid[i][j + 1] = '0';
            dfs(grid,i,j + 1);
        }
    }
}

這個也是找連在一塊兒的島嶼，但是與朋友圈有本質的不同，只能搜索的時候按照上下左右來。搜索過的值設置0

3、合法二叉樹

實現一個函數，檢查一棵二叉樹是否爲二叉搜索樹。

輸入:
    2
   / \
  1   3
輸出: true

 

輸入:
    5
   / \
  1   4
     / \
    3   6
輸出: false
解釋: 輸入爲: [5,1,4,null,null,3,6]。
     根節點的值爲 5 ，但是其右子節點值爲 4 。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        if (root == null){
            return true;
        }
        TreeNode maxLeft = root.left, minRight = root.right;
        while (maxLeft != null && maxLeft.right != null){
            maxLeft = maxLeft.right;
        }
        while (minRight != null && minRight.left != null){
            minRight = minRight.left;
        }
        boolean ret = (maxLeft == null || maxLeft.val < root.val) && (minRight == null || root.val < minRight.val);
        return  ret && isValidBST(root.left) && isValidBST(root.right);
    }
}

最簡單的方法就是中序遍歷，然後看是否是升序序列，但是那樣效率低。看到一個大神的做法是，從根節點開始，依次判斷左子樹的最大節點比當前節點小，右子樹的最小節點比當前節點大，之後對於每一個節點，都是這麼操作，其中有一次不滿足，就失敗！就做成功了。

4、後繼者

設計一個算法，找出二叉搜索樹中指定節點的“下一個”節點（也即中序後繼）。

如果指定節點沒有對應的“下一個”節點，則返回null。

輸入: root = [2,1,3], p = 1

  2
 / \
1   3

輸出: 2

輸入: root = [5,3,6,2,4,null,null,1], p = 6

      5
     / \
    3   6
   / \
  2   4
 /   
1

輸出: null

class Solution {
    boolean flag = false;
    TreeNode aimNode;
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        if(root==null){
            return aimNode;
        }
        inorderSuccessor(root.left,p);
        if(root==p){
            flag = true;
        }else if(flag){
            aimNode = root;
            flag =false;
        }
        inorderSuccessor(root.right,p);
        return aimNode;
    }
}

中序遍歷，當發現前一個節點是目標節點的時候就記錄下來，設置一個標誌，之後發現後續節點了，直接就保存。