题目一:
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; } }
题目二:
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; } }
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; } }
题目三:
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(""); } } }
题目四:
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; } }
题目五:
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; } }