求两个节点的最近公共祖先
描述：
求二叉树两个节点的最近的共同祖先，这里假设二叉树的所有节点值都是不相等的，遵旨最小堆规范。
思路
记录遍历节点，map存储当前节点与对应的父节点信息
代码
/**记录遍历访问的节点*/
static Map<Integer,TreeNode>map = new HashMap<>();
/**存储记录是否访问过*/
static Set<Integer> visits = new HashSet<>();
/**
* 最近公共祖先节点
*/
public static TreeNode lowestCommonAncestor(TreeNode root,TreeNode node1, TreeNode node2) {
//1:遍历根节点 记录子节点对应的parent
dfs(root);
while (node1!=null){
visits.add(node1.val);
//获取node1节点的父节点
node1 = map.get(node1.val);
}
while (node2!=null){
if(visits.contains(node2.val)){
return node2;
}
node2 = map.get(node2.val);
}
return null;
}
public static void dfs(TreeNode node){
if(node.left!=null){
map.put(node.left.val,node);
dfs(node.left);
}
if(node.right!=null){
map.put(node.right.val,node);
dfs(node.right);
}
}
public static void main(String[] args) {
TreeNode head = new TreeNode(1);
TreeNode left1 = new TreeNode(2);
TreeNode right1 = new TreeNode(3);
TreeNode left11 = new TreeNode(4);
TreeNode left12 = new TreeNode(5);
left1.left = left11;
left1.right = left12;
TreeNode right11 = new TreeNode(6);
right1.left = right11;
head.left = left1;
head.right = right1;
TreeNode node = lowestCommonAncestor(head,left11,right11);
if(node!=null){
System.out.println(node.val);
}
}
二叉树中序 先序 后续 层次遍历 非递归
package com.test.com.per;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
/**
* 1
* 2 3
* 4 5 6
*/
public class TreeTravel {
//中序遍历 左根右 迭代算法
public static List<Integer> inorderTravel(TreeNode head) {
Deque<TreeNode> stack = new LinkedList<>();
List<Integer> list = new LinkedList<>();
TreeNode cur = head;
while (cur != null || !stack.isEmpty()) {
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
TreeNode node = stack.pop();
//根节点
list.add(node.val);
if (node.right != null) {
cur = node.right;
}
}
return list;
}
//前序遍历 根左右
public static List<Integer> preOrderTravel(TreeNode head) {
Deque<TreeNode> stack = new LinkedList<>();
List<Integer> list = new LinkedList<>();
stack.push(head);
while (!stack.isEmpty()) {
TreeNode cur = stack.pop();
list.add(cur.val);
if (cur.right != null) {
stack.push(cur.right);
}
if (cur.left != null) {
stack.push(cur.left);
}
}
return list;
}
//后序遍历 左右根
/**
* 记录 指针cur
*
* @param head
* @return
*/
public static List<Integer> postOrderTravel(TreeNode head) {
if (head == null) {
return null;
}
TreeNode cur = head;
Deque<TreeNode> stack = new LinkedList<>();
List<Integer> list = new LinkedList<>();
stack.push(cur);
while (!stack.isEmpty()) {
TreeNode node = stack.peek();
if (node.left != null && node.left != cur && node.right != cur) {
stack.push(node.left);
} else if (node.right != null && node.right != cur) {
stack.push(node.right);
} else {
list.add(stack.pop().val);
cur = node;
}
}
return list;
}
//二叉树层次遍历
public static List<Integer> binaryTreeLevelOrder(TreeNode head) {
if (head == null) {
return null;
}
TreeNode cur = head;
Deque<TreeNode> queue = new LinkedList<>();
List<Integer> list = new LinkedList<>();
queue.add(cur);
while (!queue.isEmpty()) {
TreeNode node = queue.remove();
list.add(node.val);
if(node.left!=null){
queue.add(node.left);
}
if(node.right!=null){
queue.add(node.right);
}
}
return list;
}
public static List<Integer> postOrderTravel2(TreeNode head) {
if (head == null) {
return null;
}
TreeNode cur = head;
Deque<TreeNode> stack1 = new LinkedList<>();
Deque<TreeNode> stack2 = new LinkedList<>();
List<Integer> list = new LinkedList<>();
stack1.push(cur);
while (!stack1.isEmpty()) {
TreeNode node = stack1.pop();
stack2.push(node);
if(node.left!=null){
stack1.push(node.left);
}
if(node.right!=null){
stack1.push(node.right);
}
}
while (!stack2.isEmpty()){
list.add(stack2.pop().val);
}
return list;
}
public static void main(String[] args) {
TreeNode head = new TreeNode(1);
TreeNode left1 = new TreeNode(2);
TreeNode right1 = new TreeNode(3);
TreeNode left11 = new TreeNode(4);
TreeNode left12 = new TreeNode(5);
left1.left = left11;
left1.right = left12;
TreeNode right11 = new TreeNode(6);
right1.left = right11;
head.left = left1;
head.right = right1;
// 4 2 5 1 6 3
List<Integer> list = inorderTravel(head);
System.out.println(list);
// 1 2 4 5 3 6
list = preOrderTravel(head);
System.out.println(list);
//4 5 2 6 3 1
list = postOrderTravel2(head);
System.out.println(list);
list = binaryTreeLevelOrder(head);
System.out.println(list);
}
}
翻转二叉树 - 非递归
记录遍历的节点，将遍历的节点的左右节点进行交换
代码
//二叉树翻转
// public static TreeNode inverseTree(TreeNode head) {
// TreeNode cur =head;
// Deque<TreeNode>stack = new LinkedList<>();
// if(head==null){
// return null;
// }
// stack.push(cur);
// while (!stack.isEmpty()){
// TreeNode node = stack.pop();
//
// TreeNode temp = node.left;
// node.left = node.right;
// node.right=temp;
// if(temp.right!=null){
// stack.push(node.right);
// }
//
// if(temp.left!=null){
// stack.push(node.left);
// }
// }
//
//
// return head;
// }
public static TreeNode inverseTree(TreeNode head) {
TreeNode cur =head;
Deque<TreeNode>queue = new LinkedList<>();
if(head==null){
return null;
}
queue.offer(cur);
while (!queue.isEmpty()){
TreeNode node = queue.poll();
TreeNode temp = node.left;
node.left = node.right;
node.right=temp;
if(temp.right!=null){
queue.offer(node.right);
}
if(temp.left!=null){
queue.offer(node.left);
}
}
return head;
}
public static void main(String[] args) {
TreeNode head = new TreeNode(1);
TreeNode left1 = new TreeNode(2);
TreeNode right1 = new TreeNode(3);
TreeNode left11 = new TreeNode(4);
TreeNode left12 = new TreeNode(5);
left1.left = left11;
left1.right = left12;
TreeNode right11 = new TreeNode(6);
right1.left = right11;
head.left = left1;
head.right = right1;
TreeNode temp =inverseTree(head);
System.out.println(temp);
二叉树的遍历
题意：
二叉树的前序遍历，中序遍历， 后序遍历 ， 层次遍历
前序遍历
public static List<Integer> preOrderTravel(TreeNode head) {
Deque<TreeNode> stack = new LinkedList<>();
List<Integer> list = new LinkedList<>();
stack.push(head);
while (!stack.isEmpty()) {
TreeNode cur = stack.pop();
list.add(cur.val);
if (cur.right != null) {
stack.push(cur.right);
}
if (cur.left != null) {
stack.push(cur.left);
}
}
return list;
}
中序遍历
public static List<Integer> inorderTravel(TreeNode head) {
Deque<TreeNode> stack = new LinkedList<>();
List<Integer> list = new LinkedList<>();
TreeNode cur = head;
while (cur != null || !stack.isEmpty()) {
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
TreeNode node = stack.pop();
//根节点
list.add(node.val);
if (node.right != null) {
cur = node.right;
}
}
return list;
}
后序遍历
双栈记录
public static List<Integer> postOrderTravel2(TreeNode head) {
if (head == null) {
return null;
}
TreeNode cur = head;
Deque<TreeNode> stack1 = new LinkedList<>();
Deque<TreeNode> stack2 = new LinkedList<>();
List<Integer> list = new LinkedList<>();
stack1.push(cur);
while (!stack1.isEmpty()) {
TreeNode node = stack1.pop();
stack2.push(node);
if(node.left!=null){
stack1.push(node.left);
}
if(node.right!=null){
stack1.push(node.right);
}
}
while (!stack2.isEmpty()){
list.add(stack2.pop().val);
}
return list;
}
public static List<Integer> postOrderTravel(TreeNode head) {
if (head == null) {
return null;
}
TreeNode cur = head;
Deque<TreeNode> stack = new LinkedList<>();
List<Integer> list = new LinkedList<>();
stack.push(cur);
while (!stack.isEmpty()) {
TreeNode node = stack.peek();
if (node.left != null && node.left != cur && node.right != cur) {
stack.push(node.left);
} else if (node.right != null && node.right != cur) {
stack.push(node.right);
} else {
list.add(stack.pop().val);
cur = node;
}
}
return list;
}
层次遍历：
public static List<Integer> binaryTreeLevelOrder(TreeNode head) {
if (head == null) {
return null;
}
TreeNode cur = head;
Deque<TreeNode> queue = new LinkedList<>();
List<Integer> list = new LinkedList<>();
queue.add(cur);
while (!queue.isEmpty()) {
TreeNode node = queue.remove();
list.add(node.val);
if(node.left!=null){
queue.add(node.left);
}
if(node.right!=null){
queue.add(node.right);
}
}
return list;
}
public static void main(String[] args) {
TreeNode head = new TreeNode(1);
TreeNode left1 = new TreeNode(2);
TreeNode right1 = new TreeNode(3);
TreeNode left11 = new TreeNode(4);
TreeNode left12 = new TreeNode(5);
left1.left = left11;
left1.right = left12;
TreeNode right11 = new TreeNode(6);
right1.left = right11;
head.left = left1;
head.right = right1;
// 4 2 5 1 6 3
List<Integer> list = inorderTravel(head);
// System.out.println(list);
// 1 2 4 5 3 6
// list = preOrderTravel(head);
// System.out.println(list);
//4 5 2 6 3 1
list = postOrderTravel(head);
System.out.println(list);
// list = binaryTreeLevelOrder(head);
// System.out.println(list);
}
469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
