给定一个包含 0 和 1 的二维网格地图,其中 1 表示陆地 0 表示水域。
网格中的格子水平和垂直方向相连(对角线方向不相连)。整个网格被水完全包围,但其中恰好有一个岛屿(或者说,一个或多个表示陆地的格子相连组成的岛屿)。
岛屿中没有“湖”(“湖” 指水域在岛屿内部且不和岛屿周围的水相连)。格子是边长为 1 的正方形。网格为长方形,且宽度和高度均不超过 100 。计算这个岛屿的周长。
示例 :
输入:
[[0,1,0,0],
[1,1,1,0],
[0,1,0,0],
[1,1,0,0]]
输出: 16
解释: 它的周长是下面图片中的 16 个黄色的边:
思路:遇到每个岛就加四个边,加后就判断每个岛的右边界和下边界是否也为岛,是的话就边-2。
class Solution {
public int islandPerimeter(int[][] grid) {
int num = 0;
for(int i = 0; i < grid.length; i++) {
for(int j = 0; j < grid[i].length; j++) {
if(grid[i][j] == 1) {
num = num + 4;
//如果grid[i+1][j]不超出数组并且也等于1(岛)则边减2
if(i + 1 < grid.length && grid[i + 1][j] == 1) {
num = num -2;
}
//如果grid[i][j+1]不超出数组并且也等于1(岛)则边减2
if(j + 1 < grid[i].length && grid[i][j + 1] == 1) {
num = num -2;
}
}
}
}
return num;
}
}
给定一个二叉树,返回它的 前序 遍历。
示例:
输入: [1,null,2,3]
1
\
2
/
3
输出: [1,2,3]
进阶: 递归算法很简单,你可以通过迭代算法完成吗?
递归方式:
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
preorderTraverse(root, list);
return list;
}
private void preorderTraverse(TreeNode root, List<Integer> list) {
if(root == null) return;
list.add(root.val);
preorderTraverse(root.left, list);
preorderTraverse(root.right, list);
}
}
非递归方式:
思路:
依据前序遍历的顺序,优先訪问根结点。然后在訪问左子树和右子树。所以。对于随意结点node。第一部分即直接訪问之,之后在推断左子树是否为空,不为空时即反复上面的步骤,直到其为空。若为空。则须要訪问右子树。注意。在訪问过左孩子之后。须要反过来訪问其右孩子。所以,须要栈这样的数据结构的支持。对于随意一个结点node,详细过程例如以下:
a)訪问之,并把结点node入栈。当前结点置为左孩子;
b)推断结点node是否为空,若为空。则取出栈顶结点并出栈,将右孩子置为当前结点;否则反复a)步直到当前结点为空或者栈为空(能够发现栈中的结点就是为了訪问右孩子才存储的)
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
preorderTraverse(root, list);
return list;
}
private void preorderTraverse(TreeNode root, List<Integer> list) {
Stack<TreeNode> stack = new Stack<TreeNode>();
while(root != null || !stack.empty()) {
if(root != null) {
list.add(root.val);
stack.push(root);
root = root.left;
} else {
TreeNode node = stack.pop();
root = node.right;
}
}
}
}
给定一个二叉树,返回它的中序 遍历。
示例:
输入: [1,null,2,3]
1
\
2
/
3
输出: [1,3,2]
进阶: 递归算法很简单,你可以通过迭代算法完成吗?
递归方式:
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
inorderTraverse(root, list);
return list;
}
private void inorderTraverse(TreeNode root, List<Integer> list) {
if(root == null) return;
inorderTraverse(root.left, list);
list.add(root.val);
inorderTraverse(root.right, list);
}
}
非递归方式:非递归实现,有了上面前序的解释,中序也就比較简单了。同样的道理。仅仅只是訪问的顺序移到出栈时。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
inorderTraverse(root, list);
return list;
}
private void inorderTraverse(TreeNode root, List<Integer> list) {
Stack<TreeNode> stack = new Stack<>();
while(root != null || !stack.empty()) {
if(root != null) {
stack.push(root);
root = root.left;
} else {
TreeNode node = stack.pop();
list.add(node.val);
root = node.right;
}
}
}
}
给定一个二叉树,返回它的 后序 遍历。
示例:
输入: [1,null,2,3]
1
\
2
/
3
输出: [3,2,1]
进阶: 递归算法很简单,你可以通过迭代算法完成吗?
递归方式:
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
postorderTraverse(root, list);
return list;
}
private void postorderTraverse(TreeNode root, List<Integer> list) {
if(root == null) return;
postorderTraverse(root.left, list);
postorderTraverse(root.right, list);
list.add(root.val);
}
}
非递归方式:使用一个遍历保存上次访问的节点,节点的右节点为空或者右节点为前一个访问节点,则打印节点
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
postorderTraverse(root, list);
return list;
}
private void postorderTraverse(TreeNode root, List<Integer> list) {
TreeNode preNode = null;//上次访问的结点
TreeNode curNode = root;
Stack<TreeNode> stack = new Stack<TreeNode>();
while(curNode != null) {//遍历到最左节点
stack.push(curNode);
curNode = curNode.left;
}
while(!stack.empty()) {
curNode = stack.pop();
//节点的右节点为空,或右节点为前一个访问到的节点,则打印根节点
if(curNode.right == null || curNode.right == preNode) {
list.add(curNode.val);
preNode = curNode;
} else {
//把根节点再次压入
stack.push(curNode);
curNode = curNode.right;
while(curNode != null) {
stack.push(curNode);
curNode = curNode.left;
}
}
}
}
}
给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。
例如:
给定二叉树: [3,9,20,null,null,15,7]
,
3
/ \
9 20
/ \
15 7
返回其层次遍历结果:
[
[3],
[9,20],
[15,7]
]
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
if(root == null) return new ArrayList<>();
List<List<Integer>> result = new ArrayList<>();
LinkedList<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()) {
int count = queue.size();
List<Integer> list = new ArrayList<>();
while(count > 0) {
TreeNode node = queue.poll();
list.add(node.val);
if(node.left != null) {
queue.offer(node.left);
}
if(node.right != null) {
queue.offer(node.right);
}
count--;
}
result.add(list);
}
return result;
}
}