二叉樹演算法系列文章
演算法知識梳理(11) - 二叉樹相關演算法第一部分
演算法知識梳理(12) - 二叉樹相關演算法第二部分
演算法知識梳理(13) - 二叉樹相關演算法第三部分
一、概述
二叉樹演算法第二部分內容包括以下幾個主題：
- 獲得二叉樹的映象
- 判斷元素是否存在於二叉樹中
- 列印二叉樹中和為
s的路徑 - 獲得二叉樹的最大距離
- 判斷二叉樹是否是平衡樹
二、程式碼實現
2.1 獲得二叉樹的映象
程式碼實現
public class Untitled {
static class Tree {
int size;
Node root;
}
static class Node {
Node parent;
Node left;
Node right;
int value;
}
static void insertNode(Tree tree, int value) {
if (tree == null) {
return;
}
Node tNode = tree.root;
//待插入結點的父結點，如果遍歷完為空，說明此時是一個空樹。
Node pNode = null;
//新的結點。
Node nNode = new Node();
nNode.value = value;
while (tNode != null) {
pNode = tNode;
if (tNode.value > value) {
tNode = tNode.left;
} else {
tNode = tNode.right;
}
}
nNode.parent = pNode;
if (pNode == null) {
tree.root = nNode;
} else if (pNode.value > value) {
pNode.left = nNode;
} else {
pNode.right = nNode;
}
tree.size++;
}
static Tree createBinTree(int p[], int len) {
Tree tree = new Tree();
for (int i = 0; i < len; i++) {
int value = p[i];
insertNode(tree, value);
}
return tree;
}
static void swapTree(Node node) {
if (node == null) {
return;
}
Node temp = node.left;
node.left = node.right;
node.right = temp;
swapTree(node.left);
swapTree(node.right);
}
static void printInOrder(Node node) {
if (node == null) {
return;
}
printInOrder(node.left);
//遍歷完左子樹後，列印根結點，最後遍歷右子樹。
System.out.println(node.value);
printInOrder(node.right);
}
public static void main(String[] args) {
int p[] = {3, 5, 6, 1, 2, 4, -1, -3};
Tree tree = createBinTree(p, p.length);
System.out.println("- 轉換前 -");
printInOrder(tree.root);
swapTree(tree.root);
System.out.println("- 轉換後 -");
printInOrder(tree.root);
}
}
複製程式碼執行結果
- 轉換前 -
-3
-1
1
2
3
4
5
6
- 轉換後 -
6
5
4
3
2
1
-1
-3
複製程式碼2.2 判斷元素是否存在於二叉樹中
程式碼實現
public class Untitled {
static class Tree {
int size;
Node root;
}
static class Node {
Node parent;
Node left;
Node right;
int value;
}
static void insertNode(Tree tree, int value) {
if (tree == null) {
return;
}
Node tNode = tree.root;
//待插入結點的父結點，如果遍歷完為空，說明此時是一個空樹。
Node pNode = null;
//新的結點。
Node nNode = new Node();
nNode.value = value;
while (tNode != null) {
pNode = tNode;
if (tNode.value > value) {
tNode = tNode.left;
} else {
tNode = tNode.right;
}
}
nNode.parent = pNode;
if (pNode == null) {
tree.root = nNode;
} else if (pNode.value > value) {
pNode.left = nNode;
} else {
pNode.right = nNode;
}
tree.size++;
}
static Tree createBinTree(int p[], int len) {
Tree tree = new Tree();
for (int i = 0; i < len; i++) {
int value = p[i];
insertNode(tree, value);
}
return tree;
}
static boolean isKInTree(Node node, int k) {
if (node == null) {
return false;
}
if (node.value == k) {
return true;
}
boolean has;
//先在左子樹中尋找，如果左子樹中找到了，那麼就不需要在右子樹中尋找了。
has = isKInTree(node.left, k);
if (!has) {
has = isKInTree(node.right, k);
}
return has;
}
public static void main(String[] args) {
int p[] = {3, 5, 6, 1, 2, 4, -1, -3};
Tree tree = createBinTree(p, p.length);
System.out.println("5 is in tree=" + isKInTree(tree.root, 5));
System.out.println("9 is in tree=" + isKInTree(tree.root, 9));
}
}
複製程式碼執行結果
>> 5 is in tree=true
>> 9 is in tree=false
複製程式碼2.3 列印二叉樹中和為 s 的路徑
問題描述
輸入一個整數和一棵二叉樹，列印出和與輸入整數相等的所有路徑，從樹的根結點開始往下訪問一直到葉結點所經過的所有結點形成一條路徑。
程式碼實現
import java.util.LinkedList;
public class Untitled {
static class Tree {
int size;
Node root;
}
static class Node {
Node parent;
Node left;
Node right;
int value;
}
static void insertNode(Tree tree, int value) {
if (tree == null) {
return;
}
Node tNode = tree.root;
//待插入結點的父結點，如果遍歷完為空，說明此時是一個空樹。
Node pNode = null;
//新的結點。
Node nNode = new Node();
nNode.value = value;
while (tNode != null) {
pNode = tNode;
if (tNode.value > value) {
tNode = tNode.left;
} else {
tNode = tNode.right;
}
}
nNode.parent = pNode;
if (pNode == null) {
tree.root = nNode;
} else if (pNode.value > value) {
pNode.left = nNode;
} else {
pNode.right = nNode;
}
tree.size++;
}
static Tree createBinTree(int p[], int len) {
Tree tree = new Tree();
for (int i = 0; i < len; i++) {
int value = p[i];
insertNode(tree, value);
}
return tree;
}
static void printSum(LinkedList<Node> curPath, Node curNode, int curSum, int expectSum) {
if (curNode == null) {
return;
}
curPath.offer(curNode);
boolean isLeaf = curNode.left == null && curNode.right == null;
int sum = curSum + curNode.value;
//如果是葉結點，並且和滿足要求，那麼列印出所有的路徑。
if (isLeaf && sum == expectSum) {
for (int i = 0; i < curPath.size(); i++) {
System.out.println(String.valueOf(curPath.get(i).value));
}
} else {
printSum(curPath, curNode.left, sum, expectSum);
printSum(curPath, curNode.right, sum, expectSum);
}
//當其左右子樹都遍歷完之後，將當前結點出棧。
curPath.pop();
}
public static void main(String[] args) {
int p[] = {3, 5, 6, 1, 2, 4, -1, -3};
Tree tree = createBinTree(p, p.length);
printSum(new LinkedList<Node>(), tree.root, 0, 12);
}
}
複製程式碼執行結果
2
5
4
複製程式碼2.4 獲得二叉樹的最大距離
問題描述
二叉樹距離 指的是兩個 葉結點之間邊的個數，計算一個二叉樹的最大距離有兩種情況，最終的目的就是要獲得這兩種情況的值，並取其最大值作為該結點的最大距離：
- 路徑經過左子樹的最深結點，通過根結點，再到右子樹的最深結點，在這種情況下，最大距離等於左子樹的高度加上右子樹的高度在加上
2。 - 路徑不穿過根結點，而是左子樹或右子樹的最大距離路徑，在這種情況下，最大距離等於這兩者的最大值。
對於每個結點，定義兩個額外的屬性，maxDistance表示 以該結點為根結點的子樹的最大距離，而maxDepth為 以該結點為根結點的子樹到最深結點的距離，對於每個葉結點來說，這兩個值為0，而對於每個非葉結點來說，這兩個值是通過它的左右孩子結點的這兩個屬性計算出來的。
程式碼實現
public class Untitled {
static class Tree {
int size;
Node root;
}
static class Node {
Node parent;
Node left;
Node right;
int value;
int maxDistance;
int maxDepth;
}
static void insertNode(Tree tree, int value) {
if (tree == null) {
return;
}
Node tNode = tree.root;
//待插入結點的父結點，如果遍歷完為空，說明此時是一個空樹。
Node pNode = null;
//新的結點。
Node nNode = new Node();
nNode.value = value;
while (tNode != null) {
pNode = tNode;
if (tNode.value > value) {
tNode = tNode.left;
} else {
tNode = tNode.right;
}
}
nNode.parent = pNode;
if (pNode == null) {
tree.root = nNode;
} else if (pNode.value > value) {
pNode.left = nNode;
} else {
pNode.right = nNode;
}
tree.size++;
}
static Tree createBinTree(int p[], int len) {
Tree tree = new Tree();
for (int i = 0; i < len; i++) {
int value = p[i];
insertNode(tree, value);
}
return tree;
}
static void calculateMaxTreeDistance(Node node) {
//如果是空結點，那麼不需要計算。
if (node == null) {
return;
}
if (node.left == null && node.right == null) {
return;
}
int leftDistance = 0;
int leftDepth = -1;
if (node.left != null) {
calculateMaxTreeDistance(node.left);
leftDistance = node.left.maxDistance;
leftDepth = node.left.maxDepth;
}
int rightDistance = 0;
int rightDepth = -1;
if (node.right != null) {
calculateMaxTreeDistance(node.right);
rightDistance = node.left.maxDistance;
rightDepth = node.left.maxDepth;
}
//深度為左右孩子結點的深度最大值+1
node.maxDepth = leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
//(1) 通過根結點，則選取左子樹的深度+右子樹深度+2
int throughRoot = leftDepth + rightDepth + 2;
//(2) 不通過根結點，則選取左右子樹的距離最大值。
int notThroughRoot = leftDistance > rightDistance ? leftDistance : rightDistance;
//取以上兩者的最大值，作為該結點的最大距離屬性。
node.maxDistance = throughRoot > notThroughRoot ? throughRoot : notThroughRoot;
}
static void printInOrder(Node node) {
if (node == null) {
return;
}
printInOrder(node.left);
//遍歷完左子樹後，列印根結點，最後遍歷右子樹。
System.out.println("value=" + node.value + ", depth=" + node.maxDepth + ", distance=" + node.maxDistance);
printInOrder(node.right);
}
public static void main(String[] args) {
int p[] = {3, 5, 6, 1, 2, 4, -1, -3};
Tree tree = createBinTree(p, p.length);
calculateMaxTreeDistance(tree.root);
System.out.println("最大距離=" + tree.root.maxDistance);
}
}
複製程式碼執行結果
>> 最大距離=6
複製程式碼2.5 判斷二叉樹是否是平衡樹
問題描述
平衡二叉樹 具有以下性質：它是一棵空樹或它的 左右兩個子樹的高度差的絕對值不超過1，並且左右兩個子樹都是一棵平衡二叉樹。
解決思路
根據平衡二叉樹的定義，對於每個結點需要滿足兩個條件：
- 左右子樹都是平衡樹
- 左右子樹的高度差小於等於
1
因此，我們可以採用遞迴的方式來實現，對於每個結點，返回一個資料結構BalanceValue表示以該結點為根結點的子樹是否是平衡樹，以及它的高度（葉結點的高度為0）。
程式碼實現
public class Untitled {
static class Tree {
int size;
Node root;
}
static class Node {
Node parent;
Node left;
Node right;
int value;
}
static class BalanceValue {
boolean isBalance;
int treeHeight;
}
static void insertNode(Tree tree, int value) {
if (tree == null) {
return;
}
Node tNode = tree.root;
//待插入結點的父結點，如果遍歷完為空，說明此時是一個空樹。
Node pNode = null;
//新的結點。
Node nNode = new Node();
nNode.value = value;
while (tNode != null) {
pNode = tNode;
if (tNode.value > value) {
tNode = tNode.left;
} else {
tNode = tNode.right;
}
}
nNode.parent = pNode;
if (pNode == null) {
tree.root = nNode;
} else if (pNode.value > value) {
pNode.left = nNode;
} else {
pNode.right = nNode;
}
tree.size++;
}
static Tree createBinTree(int p[], int len) {
Tree tree = new Tree();
for (int i = 0; i < len; i++) {
int value = p[i];
insertNode(tree, value);
}
return tree;
}
static BalanceValue isTreeBalance(Node node) {
BalanceValue value = new BalanceValue();
if (node == null) {
value.treeHeight = -1;
value.isBalance = true;
return value;
}
//先確定左子樹是否是平衡樹。
BalanceValue left = isTreeBalance(node.left);
if (left.isBalance) {
//再確定右子樹是否是平衡樹。
BalanceValue right = isTreeBalance(node.right);
if (right.isBalance) {
int leftHeight = left.treeHeight;
int rightHeight = right.treeHeight;
//左右的高度差是否小於等於1。
if (Math.abs(leftHeight - rightHeight) <= 1) {
//得到當前結點的高度。
value.treeHeight = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
value.isBalance = true;
return value;
}
}
}
value.isBalance = false;
return value;
}
public static void main(String[] args) {
int p[] = {3, 5, 6, 1, 2, 4, -1, -3, -99, -100};
Tree tree = createBinTree(p, p.length);
System.out.println("平衡樹=" + isTreeBalance(tree.root).isBalance);
}
}
複製程式碼執行結果
>> 平衡樹=false
複製程式碼