二叉树的递归算法
Posted 甲哇技术栈
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了二叉树的递归算法相关的知识，希望对你有一定的参考价值。
递归(recursion) 又称递回，在数学与计算机科学中，是指在函数的定义中使用函数自身的方法。
一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。
构成递归需具备的条件：
1. 子问题须与原始问题为同样的事，且更为简单；
2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。
以中序遍历递归方法为例，这里显示的图解，仅诠释开始一小部分递归前进段与递归返回段的交叉过程。
private void inorderHelper( TreeNode node ){
if ( node == null ) //若节点为空
return; //无任何操作
inorderHelper( node.leftNode ); //有序遍历下一级左子树
System.out.print( node.data + " " ); //输出节点数据
inorderHelper( node.rightNode );//有序遍历下一级右子树
}
插图说明：
1.前进段的进程 1 ：鉴于以树根 节点 "49" 为参数，调用 inorderHelper(...)，开始调用以下一级树根 节点 "28" 为参数 的inorderHelper(...) 方法。
2.前进段的进程 2 ：鉴于以树根 节点 "28" 为参数，调用 inorderHelper(...)，开始调用以下一级树根 节点 "18" 为参数 的 inorderHelper(...) 方法。
3.前进段的进程 3 ：鉴于以树根 节点 "18" 为参数，调用 inorderHelper(...)，开始调用以下一级树根 节点 "11" 为参数 的 inorderHelper(...) 方法。
4.节点 "11" 为叶节点，递归前进到终点。开始启动返回操作， 输出其数值 11。
5.至此，参数为 节点 "11" 的 方法 inorderHelper(...) 执行完毕。返回进程 4 启动下一个 输出：18。
6.输出 18 的代码行执行完毕，进入前进段进程 5， 执行接下来一行的代码：调用参数为 节点 "19" 的节点的方法 inorderHelper(...)
7.节点 "19" 为叶节点，递归前进到终点。开始启动返回操作， 输出其数值 19。
8.至此，参数为 节点 "19" 的 方法 inorderHelper(...) 执行完毕。返回进程 6 启动下一个 输出：28。
......
源码：（代码取自美国课本 "Java How to Program "(Deitel & Detel)的练习：20.25。）
// Deitel & Detel, 20.25
// class TreeNode definition
class TreeNode {
// public access members
public TreeNode leftNode;
public int data;
public TreeNode rightNode;
// initialize data and make this a leaf node
public TreeNode(int nodeData) {
data = nodeData;
leftNode = rightNode = null; // node has no children
}
// locate insertion point and insert new node; ignore duplicate values
public synchronized void insert(int insertValue) {
// insert in left subtree
if (insertValue < data) {
// insert new TreeNode
if (leftNode == null)
leftNode = new TreeNode(insertValue);
else // continue traversing left subtree
leftNode.insert(insertValue);
}
// insert in right subtree
else if (insertValue > data) {
// insert new TreeNode
if (rightNode == null)
rightNode = new TreeNode(insertValue);
else // continue traversing right subtree
rightNode.insert(insertValue);
}
} // end method insert
// get right child
public synchronized TreeNode getRight() {
return rightNode;
}
// get left child
public synchronized TreeNode getLeft() {
return leftNode;
}
// return the data
public synchronized Object getData() {
return new Integer(data);
}
} // end class TreeNode
public class TreeTest {
private TreeNode root;
public TreeTest() {
root = null;
}
// insert a new node in the binary search tree
public synchronized void insertNode(Integer value) {
if (root == null)
root = new TreeNode(value.intValue());
else
root.insert(value.intValue());
}
// begin preorder traversal
public synchronized void preorderTraversal() {
preorderHelper(root);
}
// recursive method to perform preorder traversal
private void preorderHelper(TreeNode node) {
if (node == null)
return;
System.out.print(node.data + " ");
preorderHelper(node.leftNode);
preorderHelper(node.rightNode);
}
// begin inorder traversal
public synchronized void inorderTraversal() {
inorderHelper(root);
}
// recursive method to perform inorder traversal
private void inorderHelper(TreeNode node) {
if (node == null)
return;
inorderHelper(node.leftNode);
System.out.print(node.data + " ");
inorderHelper(node.rightNode);
}
// begin postorder traversal
public synchronized void postorderTraversal() {
postorderHelper(root);
}
// recursive method to perform postorder traversal
private void postorderHelper(TreeNode node) {
if (node == null)
return;
postorderHelper(node.leftNode);
postorderHelper(node.rightNode);
System.out.print(node.data + " ");
}
// begin printing tree
public void outputTree() {
outputTreeHelper(root, 0);
}
// recursive method to print tree
private void outputTreeHelper(TreeNode currentNode, int spaces) {
// recursively print right branch, then left
if (currentNode != null) {
outputTreeHelper(currentNode.getRight(), spaces + 5);
for (int k = 1; k <= spaces; k++)
System.out.print(" ");
System.out.println(currentNode.getData().toString());
outputTreeHelper(currentNode.getLeft(), spaces + 5);
}
}
public static void main(String args[]) {
TreeTest tree = new TreeTest();
int intVal;
System.out.println("Inserting the following values: ");
/*
// create Objects to store in tree
for ( int i = 1; i <= 10; i++ ) {
intVal = ( int ) ( Math.random() * 100 );
System.out.print( intVal + " " );
tree.insertNode( new Integer( intVal ) );
}
*/
tree.insertNode(new Integer(49));
tree.insertNode(new Integer(28));
tree.insertNode(new Integer(83));
tree.insertNode(new Integer(18));
tree.insertNode(new Integer(19));
tree.insertNode(new Integer(11));
tree.insertNode(new Integer(40));
tree.insertNode(new Integer(32));
tree.insertNode(new Integer(44));
tree.insertNode(new Integer(71));
tree.insertNode(new Integer(72));
tree.insertNode(new Integer(69));
tree.insertNode(new Integer(97));
tree.insertNode(new Integer(99));
// run three different traversal types
System.out.println("\n\nPreorder traversal");
tree.preorderTraversal();
System.out.println("\n\nInorder traversal");
tree.inorderTraversal();
System.out.println("\n\nPostorder traversal");
tree.postorderTraversal();
// print a depiction of the tree
System.out.println("\n\n");
tree.outputTree();
}
} // end class TreeTest
}
以上是关于二叉树的递归算法的主要内容，如果未能解决你的问题，请参考以下文章