二叉树的递归遍历
java
复制代码
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
if(root==null) {
return list;
}else {
traversal(list,root);
}
return list;
}
public void traversal(List<Integer> list,TreeNode root) {
if(root==null) {
return;
}
//前中后序调整一下下面的顺序即可
list.add(root.val);
traversal(list,root.left);
traversal(list,root.right);
}
}
二叉树的迭代遍历
java
复制代码
思路 以中序为扩展，其他的改变顺序即可 中序---左中右 栈---右中左
1、先入栈根结点
2、弹出第一个，因为我们每次先拿到的都是子树的中结点
3、右结点入栈 中结点入栈并打上标记null 左结点入栈
4、遇见null结点则弹出两次 第二次的值入列表
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
Deque<TreeNode> de = new LinkedList<>();
if(root==null){
return list;
}else{
de.addLast(root);
}
while(!de.isEmpty()){
TreeNode node = de.peekLast();
if(node!=null){
de.pollLast();
if(node.right!=null){ //右
de.addLast(node.right);
}
de.addLast(node); //中
de.addLast(null);
if(node.left!=null){ //左
de.addLast(node.left);
}
}else{
de.pollLast();
node = de.peekLast();
de.pollLast();
list.add(node.val);
}
}
return list;
}
}
二叉数的层序遍历（Leetcode102）
java
复制代码
思路
1、根结点入队 用int size = de.size() 可以了解到这一层有几个结点
2、每层遍历到的结点考虑他的左右结点，如果有结点则入队 先左后右
3、这一层遍历到的size个结点加入到arr中 这一层遍历完后再加入到list中
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> list = new ArrayList<>();
Deque<TreeNode> de = new LinkedList<>();
if(root==null) {
return list;
}else {
de.add(root);
}
while(!de.isEmpty()) {
int size = de.size();
List<Integer> arr = new ArrayList<>();
for(int i = 0;i<size;i++) {
TreeNode temp = de.pollFirst();
if(temp.left!=null) {
de.addLast(temp.left);
}
if(temp.right!=null) {
de.addLast(temp.right);
}
arr.add(temp.val);
}
list.add(arr);
}
return list;
}
二叉树的层序遍历2（Leetcode107）
java
复制代码
思路 先层序遍历 再把顺序颠倒一下即可 Collections.reverse(list); 可以改变集合顺序
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> list = new ArrayList<>();
Deque<TreeNode> de = new LinkedList<>();
if(root==null) {
return list;
}else {
de.add(root);
}
while(!de.isEmpty()) {
int size = de.size();
List<Integer> arr = new ArrayList<>();
while(size-->0) {
TreeNode temp = de.pollFirst();
if(temp.left!=null) {
de.add(temp.left);
}
if(temp.right!=null) {
de.add(temp.right);
}
arr.add(temp.val);
}
list.add(arr);
}
Collections.reverse(list);
return list;
}
二叉树的右视图（Leetcode199）
java
复制代码
思路：每次把每一层最后一个结点的值加入列表即可 也是层序
public List<Integer> rightSideView(TreeNode root) {
List<Integer> list = new ArrayList<>();
Deque<TreeNode> de = new LinkedList<>();
if(root==null) {
return list;
}else {
de.add(root);
}
while(!de.isEmpty()) {
int size = de.size();
for(int i = 0;i<size;i++) {
TreeNode temp = de.pollFirst();
if(i==(size-1)){ //判断是不是当前层最后一个结点
list.add(temp.val);
}
if(temp.left!=null) {
de.addLast(temp.left);
}
if(temp.right!=null) {
de.addLast(temp.right);
}
}
}
return list;
}
二叉树的层平均值（Leetcode637）
java
复制代码
class Solution {
public List<Double> averageOfLevels(TreeNode root) {
List<Double> result = new LinkedList<>();
Deque<TreeNode> de = new LinkedList<>();
if(root==null) {
return result;
}
de.add(root);
while(!de.isEmpty()){
int size = de.size();
int sum = size;
double num = 0;
while(size-->0){
TreeNode temp = de.pollFirst();
num += temp.val;
if(temp.left!=null){
de.addLast(temp.left);
}
if(temp.right!=null){
de.addLast(temp.right);
}
}
double total = num/sum;
result.add(total);
}
return result;
}
}
N叉树的层序遍历（Leetcode429）
java
复制代码
class Solution {
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> result = new LinkedList<>();
Deque<Node> de = new LinkedList<>();
if(root == null) {
return result;
}
de.add(root);
while(!de.isEmpty()) {
int size = de.size();
List<Integer> list = new LinkedList<>();
while(size-->0){
Node temp = de.pollFirst();
list.add(temp.val);
if(temp.children!=null){ //判断是不是有子结点，有的话全部入队
for(int i = 0;i<temp.children.size();i++){
de.addLast(temp.children.get(i));
}
}
}
result.add(list);
}
return result;
}
}
每个树行中找最大值（Leetcode515）
java
复制代码
class Solution {
public List<Integer> largestValues(TreeNode root) {
List<Integer> result = new LinkedList<>();
Deque<TreeNode> de = new LinkedList<>();
if(root==null) {
return result;
}
de.add(root);
while(!de.isEmpty()){
int size = de.size();
int max = Integer.MIN_VALUE;
while(size-->0){
TreeNode temp = de.pollFirst();
max = max>temp.val?max:temp.val; //判断是不是当前层最大的
if(temp.left!=null){
de.addLast(temp.left);
}
if(temp.right!=null){
de.addLast(temp.right);
}
}
result.add(max);
}
return result;
}
}
填充每个节点的下一个右侧节点（Leetcode116/117）
java
复制代码
思路
1、一先创建一个虚拟指针指向root ，用这个指针来操控即可，就不会影响影响到root
2、层序遍历
3、判断每层的最后一个都指向null 前面的按照队列顺序指向
public Node connect(Node root) {
Deque<Node> de = new LinkedList<>();
if(root==null) {
return root;
}else {
Node cur = root;
de.add(cur);
}
while(!de.isEmpty()) {
int size = de.size();
for(int i = 0;i<size;i++) {
Node temp = de.pollFirst();
if(!de.isEmpty()&&de.peekFirst()!=null&&i!=(size-1)) { //除了最后一个节点外 弹出的指向弹出后的队首
temp.next = de.peekFirst();
}else {
temp.next = null;
}
if(temp.left!=null) {
de.addLast(temp.left);
}
if(temp.right!=null) {
de.addLast(temp.right);
}
}
}
return root;
}
翻转二叉树（Leetcode226）
java
复制代码
思路
1、定义一个函数来交换左右节点
2、遍历节点，每遍历一个节点交换一次
class Solution {
public TreeNode invertTree(TreeNode root) {
Deque<TreeNode> de = new LinkedList<>();
if(root==null) {
return root;
}else {
de.add(root);
}
while(!de.isEmpty()) {
int size = de.size();
for(int i = 0;i<size;i++) {
TreeNode temp = de.pollFirst();
if(temp.left!=null) {
de.addLast(temp.left);
}
if(temp.right!=null) {
de.addLast(temp.right);
}
SwapNode(temp);
}
}
return root;
}
public void SwapNode(TreeNode root) {
TreeNode temp = root.left;
root.left = root.right;
root.right = temp;
}
}
对称二叉树（Leetcode101）
java
复制代码
思路：
1、根节点的左右节点入队
2、每次判断左右节点的外侧和内侧节点是否相同
3、左右节点的内外侧节点入队
public boolean isSymmetric(TreeNode root) {
Deque<TreeNode> de = new LinkedList<>();
if(root==null){
return true;
}else {
de.add(root.left);
de.add(root.right);
}
while(!de.isEmpty()) {
TreeNode node1 = de.pollFirst();
TreeNode node2 = de.pollFirst();
if(node1==null&&node2!=null) {
return false;
}
if(node2==null&&node1!=null) {
return false;
}
if(node1==null&&node2==null){
continue;
}
if(node1.val!=node2.val) {
return false;
}
de.add(node1.left);
de.add(node2.right);
de.add(node1.right);
de.add(node2.left);
}
return true;
}
二叉树的最大深度（Leetcode104）
java
复制代码
思路：直接层序遍历，层数就是它的最大深度 后序遍历求的是高度
public int maxDepth(TreeNode root) {
Deque<TreeNode> de = new LinkedList<>();
if(root==null) {
return 0;
}else {
de.add(root);
}
int count = 0;
while(!de.isEmpty()) {
int size = de.size();
count++;
while(size-->0) {
TreeNode temp = de.pollFirst();
if(temp.left!=null) {
de.add(temp.left);
}
if(temp.right!=null) {
de.add(temp.right);
}
}
}
return count;
}
二叉数的最小深度（Leetcode111）
java
复制代码
思路2 层序，从左到右，先遍历到的叶子节点所处的层就是最小深度 可以自己画图理解一下
class Solution {
public int minDepth(TreeNode root) {
if(root==null) return 0;
Deque<TreeNode> queue = new LinkedList<>();
queue.add(root);
int depth = 1;
while(!queue.isEmpty()){
int size = queue.size();
for(int i=0;i<size;i++){
TreeNode node = queue.remove();
if(node.left == null&&node.right == null) {
return depth;
}
if(node.left!=null){
queue.add(node.left);
}
if(node.right!=null){
queue.add(node.right);
}
}
depth++;
}
return -1;
}
}
完全二叉数的节点数 （Leetcode222）
java
复制代码
public static int countNodes(TreeNode root) {
if(root==null) {
return 0;
}
return traveral(root);
}
public static int traveral(TreeNode root) {
if(root==null) {
return 0;
}
int left = traveral(root.left);
int right = traveral(root.right);
return left+right+1;
}