leetCode解题报告5道题(三)

题目一：

Binary Tree Zigzag Level Order Traversal

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree {3,9,20,#,#,15,7},

    3
   / \
  9  20
    /  \
   15   7

return its zigzag level order traversal as:

[
  [3],
  [20,9],
  [15,7]
]

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

分析：层次遍历的变形哈.没啥太大的变化，看代码理解下哈！

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if (root == null)
            return result;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        int k = 1;
        ArrayList<TreeNode> list = new ArrayList<TreeNode>();
        
        while (!queue.isEmpty()){
            list.clear();
            while (!queue.isEmpty()){
                list.add(queue.remove());
            }
            ArrayList<Integer> arrays = new ArrayList<Integer>();
            
            for(int i=0; i<list.size(); ++i){
                TreeNode node = list.get(i);
                if (k % 2 == 1){
                    arrays.add(list.get(i).val);
                }else{
                    arrays.add(list.get(list.size()-1-i).val);
                }
                if (node.left != null)
                    queue.add(node.left);
                if (node.right != null)
                    queue.add(node.right);
            }
            k++;
            result.add(arrays);
        }
        return result;
    }
}

题目二：

Convert Sorted Array to Binary Search Tree

 Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

题意：给你一个array数组，让你求出这个数组所能组成的一个平衡的二叉树，很明显的递归问题哈，用分治的思想把中间的结点作为根结点，再一直递归下去就可以了哈！！

AC代码：

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode sortedArrayToBST(int[] num) {
        if (num.length == 0){
            return null;
        }
        return buildBST(num, 0, num.length-1);
    }
    /*
        递归调用
    */
    public TreeNode buildBST(int[] num, int left, int right){
        /*当left > right 的时候，表示是叶子结点的孩子了，返回null*/
        if (left > right){
            return null;
        }
        /*取中间值，作为根结点的值*/
        int middle = (right + left) / 2;
        TreeNode root = new TreeNode(num[middle]);
        /*求出左右孩子*/
        root.left = buildBST(num, left, middle-1);
        root.right = buildBST(num, middle+1, right);
        return root;
    }
}

类似的题目：

Convert Sorted List to Binary Search Tree

 Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

题意：跟上面的一样，只不过数组换成了链表！！果断要知道如何快速求出链表中间的那个结点哈~

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; next = null; }
 * }
 */
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    
    public TreeNode sortedListToBST(ListNode head) {
        if (head == null){
            return null;
        }
        return buildBST(head, null);
    }
    
    public TreeNode buildBST(ListNode left, ListNode right){
        if (right == null && left == null){
            return null;
        }
        if (right != null && right.next == left){
            return null;
        }
        /*求链表中间结点的前一个结点 Begin*/
        ListNode preLeft = new ListNode(0);
        preLeft.next = left;
        ListNode tempNode = left;
        ListNode preMiddleNode = preLeft;
        /*求链表中间结点的具体方法*/
        while (tempNode != right && tempNode.next != right){
            preMiddleNode = preMiddleNode.next;
            tempNode = tempNode.next.next;
        }
        /*求链表中间结点的前一个结点 End*/
        
        /*递归咯！*/
        ListNode middleNode = preMiddleNode.next;
        TreeNode root = new TreeNode(middleNode.val);
        root.left = buildBST(left, preMiddleNode);
        root.right = buildBST(preMiddleNode.next.next, right);
        return root;
    }
}

题目三：

Surrounded Regions(考察深度搜索)

 

Given a 2D board containing 'X' and 'O', capture all regions surrounded by 'X'.

A region is captured by flipping all 'O's into 'X's in that surrounded region.

For example,

X X X X
X O O X
X X O X
X O X X

After running your function, the board should be:

X X X X
X X X X
X X X X
X O X X

分析：给你一个数组，里面包含了x(或者X) 还有 o(或者O)，要求我们把o(或者O)被x(或X)包围的情况，转换成  o -> x  而  O -> X

这个题目，其实是典型的广度搜索吧。。

解题方法：居然所有的边界o(或者O),我们都认为它是不被包围的，那么我们只要从边界入手就可以了...我们用一个二维数组flags来确定每个位置该出现什么字母，如：flags[row][col] = 0 则 row行 col列出现的字母为x(或者X), flags[row][col] = 1 则 row行 col列出现的字母为o(或者O), 

把所有处于边界的o(或者O)加入到queue中，然后就是一个典型的BFS了，只需要循环出队入队，并做好标记，如果从队列中出去的话，证明这个位置一定是没有被X所包围的，那么标记这个位置flags[row][col] = 1;

之后只需要循环flags这个二维数组就可以了。

AC代码：

public class Solution {
    private int[][] flags;//用来标记每个位置的字母
	private int rowLength;//行数
	private int colLength;//列数
	
	/*自定义放入queue中的数据结构类型*/
	class Node{
		int i;
		int j;
		public Node(int i, int j) {
			this.i = i;
			this.j = j;
		}
	}
	
	public void solve(char[][] board){
	    /*初始化*/
		rowLength = board.length;
		if (rowLength == 0 || board[0].length == 0)
			return ;
		colLength = board[0].length;
		
		/*初始化flags, queue, 然后把board[][]中的边界字母为o(或者O)的取出放入queue*/
		flags = new int[rowLength][colLength];
		Queue<Node> queue = new LinkedList<Node>();
		for (int i=0; i<rowLength; ++i){
			for (int j=0; j<colLength; ++j){
				if (i == 0 || i == rowLength - 1){
					if (board[i][j] == 'o' || board[i][j] == 'O'){
						queue.add(new Node(i,j));
					}
				}else{
					if (j == 0 || j == colLength - 1){
						if (board[i][j] == 'o' || board[i][j] == 'O'){
							queue.add(new Node(i,j));
						}
					}
				}
				
			}
		}
		/*BFS*/
		while (!queue.isEmpty()){
			Node node = queue.remove();
			int row = node.i;
			int col = node.j;
			flags[row][col] = 1;
			//left
			if (col-1 >= 0 && (board[row][col-1] == 'o' || board[row][col-1] == 'O' )&& flags[row][col-1] == 0){
				queue.add(new Node(row,col-1));
			}
			//right
			if (col+1 < colLength && (board[row][col+1] == 'o' || board[row][col+1] == 'O') && flags[row][col+1] == 0){
				queue.add(new Node(row,col+1));
			}
			//up
			if (row-1 >= 0 && (board[row-1][col] == 'o' || board[row-1][col] == 'O')&& flags[row-1][col] == 0){
				queue.add(new Node(row-1,col));
			}
			//down
			if (row+1 < rowLength && (board[row+1][col] == 'o' || board[row+1][col] == 'O')&& flags[row+1][col] == 0){
				queue.add(new Node(row+1,col));
			}
		}
		/*重新赋值board[][]*/
		for (int i=0; i<rowLength; ++i){
			for (int j=0; j<colLength; ++j){
				if (flags[i][j] == 0){
					if (board[i][j] == 'o'){
						board[i][j] = 'x';
					}else if (board[i][j] == 'O'){
						board[i][j] = 'X';
					}
				}
				//System.out.print(board[i][j] + " ");
			}
			//System.out.println("");
		}
	}
}

题目四：

Balanced Binary Tree

Given a binary tree, determine if it is height-balanced.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

分析：考察的其实就是对平衡二叉树概念的理解，和二叉树求深度的方法的掌握

一棵二叉树如果满足平衡的条件，那么包括它自身，和它的任何一个子树的左右子树的深度之差必须要小于2，这样问题就转换成了递归的了，一直递归下去，如果不满足条件，则把全局的标志flag置为false;

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private boolean flag = true;

	public boolean isBalanced(TreeNode root) {
		calDeepthByTree(root);
		return flag;
	}

	public int calDeepthByTree(TreeNode root) {
		if (root == null)
			return 0;
		if (root.left == null && root.right == null)
			return 1;

		int deepLeft = 0;
		int deepRight = 0;
		deepLeft = calDeepthByTree(root.left) + 1;
		deepRight = calDeepthByTree(root.right) + 1;
		if (Math.abs(deepRight - deepLeft) >= 2) {
			flag = false;
		}
		return deepRight > deepLeft ? deepRight : deepLeft;
	}
}

题目五：

Minimum Depth of Binary Tree

 

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

分析： 给我们一个二叉树，要求出从根结点到叶子结点的最短的路径（依旧还是递归哈！）

很简单，直接看代码：

AC代码：

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int minDepth(TreeNode root) {
        /*递归结束条件*/
        if (root == null)
            return 0;
        if (root.left == null && root.right == null)
            return 1;
        
        int leftdepth = minDepth(root.left);
        int rightdepth = minDepth(root.right);
        
        /*当其中左右子树有一支是为null的时候，那么路径也只有另外一支了，不管多长都只能选那条路了*/
        if (leftdepth == 0){
            return rightdepth+1;
        }
        if (rightdepth == 0){
            return leftdepth+1;
        }
        
        /*返回左右子树中较小的一边*/
        return leftdepth > rightdepth ? rightdepth + 1 : leftdepth + 1;
    }
}