树的相关概念
二叉树的概念
1）树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
2）二叉树的子节点分为左节点和右节点。
3）如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。
4）如果该二叉树的所有叶子节点都在最后一层或倒数第二层，且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。
二叉树的前序遍历，中序遍历和后序遍历。
前序遍历: 先输出父节点，再遍历左子树和右子树
中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
技巧: 看输出父节点的顺序，就确定是前序，中序还是后序
举例：
代码实现思路：
前序遍历：先输出当前节点（初始为root），如果左子节点不为空，则递归继续前序遍历，如果右子节点不为空，则递归继续前序遍历。
中序遍历：如果当前节点的左子节点不为空，则递归中序遍历，如果当前右子节点不为空，则递归中序遍历。
后序遍历：如果当前节点的左子节点不为空，则递归后续遍历，后序遍历：如果当前节点的右子节点不为空，则递归后续遍历。
代码实现：
import sun.reflect.generics.tree.Tree;
import javax.swing.tree.TreeNode;
public class BinaryTreeDemo {
public static void main(String[] args) {
//先创建一颗二叉树
BinaryTree binaryTree=new BinaryTree();
TreeNode root =new TreeNode("A");
TreeNode node2=new TreeNode("B");
TreeNode node3=new TreeNode("C");
TreeNode node4=new TreeNode("D");
TreeNode node5=new TreeNode("E");
TreeNode node6=new TreeNode("F");
root.setLeft(node2);
root.setRight(node3);
node2.setLeft(node4);
node2.setRight(node5);
node3.setRight(node6);
binaryTree.setRoot(root);
//输出
System.out.println("前序遍历结果：");
binaryTree.preOrder();
System.out.println("中序遍历结果：");
binaryTree.infixOrder();
System.out.println("后序遍历结果：");
binaryTree.postOrder();
}
//定义二叉树
static class BinaryTree{
private TreeNode root;
public void setRoot(TreeNode root){
this.root=root;
}
//前序遍历
public void preOrder(){
if(this.root!=null){
this.root.preOrder();
}else{
System.out.println("二叉树为空");
}
}
//中序遍历
public void infixOrder(){
if(this.root!=null){
this.root.infixOrder();
}else{
System.out.println("二叉树为空");
}
}
//中序遍历
public void postOrder(){
if(this.root!=null){
this.root.postOrder();
}else{
System.out.println("二叉树为空");
}
}
}
//定义节点
static class TreeNode{
private String value;
private TreeNode left;
private TreeNode right;
public TreeNode(String value){
this.value=value;
}
public String getValue() {
return value;
}
public TreeNode getLeft() {
return left;
}
public TreeNode getRight() {
return right;
}
public void setValue(String value) {
this.value = value;
}
public void setLeft(TreeNode left) {
this.left = left;
}
public void setRight(TreeNode right) {
this.right = right;
}
@Override
public String toString() {
return value;
}
//前序遍历的方法
public void preOrder(){
System.out.println(this);//先输出根节点
//递归向左子树遍历
if(this.left!=null){
this.left.preOrder();
}
//递归向右子树遍历
if(this.right!=null){
this.right.preOrder();
}
}
//中序遍历的方法
public void infixOrder(){
//递归向左子树遍历
if(this.left!=null){
this.left.infixOrder();
}
System.out.println(this);//输出根节点
//递归向右子树遍历
if(this.right!=null){
this.right.infixOrder();
}
}
//后序遍历的方法
public void postOrder(){
//递归向左子树遍历
if(this.left!=null){
this.left.postOrder();
}
//递归向右子树遍历
if(this.right!=null){
this.right.postOrder();
}
System.out.println(this);//输出根节点
}
}
}
二叉树查找指定节点
查找思路：
前序查找：先判断当前节点的value是否为要找的，是则返回当前节点，不是，则判断当前节点的左子节点是否为空，若为空，则递归前序查找，如果在左递归前序查找中找到节点就返回，否则继续判断当前节点是否为空，若不为空则继续向右递归前序查找。
中序查找：判断当前节点的左子节点是否为空，若不为空，则递归中序查找，如果找到，则返回，如果没找到就和当前节点比较，如果是则返回当前节点，否则继续进行右递归的中序查找，如果找到就返回，否则返回null。
后序查找：判断当前节点的左子节点是否为空，若不为空，则递归后序查找，如果找到，则返回，如果没找到，就判断当前当前节点的右子节点是否为空，如果不为空，则有递归进行后序查找，如果找到就返回，否则就和当前节点进行比较，如果是则返回，否则返回null。
代码实现：
public class BinaryTreeDemo {
public static void main(String[] args) {
//先创建一颗二叉树
BinaryTree binaryTree = new BinaryTree();
TreeNode root = new TreeNode("A");
TreeNode node2 = new TreeNode("B");
TreeNode node3 = new TreeNode("C");
TreeNode node4 = new TreeNode("D");
TreeNode node5 = new TreeNode("E");
TreeNode node6 = new TreeNode("F");
root.setLeft(node2);
root.setRight(node3);
node2.setLeft(node4);
node2.setRight(node5);
node3.setRight(node6);
binaryTree.setRoot(root);
//前序遍历查找
System.out.println("前序遍历查找");
TreeNode resNode = binaryTree.preOrderSearch("B");
if (resNode != null) {
System.out.println("找到" + resNode);
} else {
System.out.println("没有找到");
}
//中序遍历查找
/* System.out.println("中序遍历查找");
TreeNode resNode=binaryTree.infixOrderSearch("B");
if(resNode!=null){
System.out.println("找到"+resNode);
}else{
System.out.println("没有找到");
}
//后序遍历查找
System.out.println("后序遍历查找");
TreeNode resNode=binaryTree.postOrderSearch("B");
if(resNode!=null){
System.out.println("找到"+resNode);
}else{
System.out.println("没有找到");
}*/
}
}
//定义二叉树
class BinaryTree{
private TreeNode root;
public void setRoot(TreeNode root){
this.root=root;
}
public TreeNode preOrderSearch(String value) {
if(root!=null){
return root.preOrderSearch(value);
}else{
return null;
}
}
public TreeNode infixOrderSearch(String value) {
if(root!=null){
return root.infixOrderSearch(value);
}else{
return null;
}
}
public TreeNode postOrderSearch(String value) {
if(root!=null){
return root.postOrderSearch(value);
}else{
return null;
}
}
}
//定义节点
class TreeNode{
private String value;
private TreeNode left;
private TreeNode right;
public TreeNode(String value){
this.value=value;
}
public String getValue() {
return value;
}
public TreeNode getLeft() {
return left;
}
public TreeNode getRight() {
return right;
}
public void setValue(String value) {
this.value = value;
}
public void setLeft(TreeNode left) {
this.left = left;
}
public void setRight(TreeNode right) {
this.right = right;
}
@Override
public String toString() {
return value;
}
//前序遍历查找
public TreeNode preOrderSearch(String value){
//比较当前节点是不是要找的
if(this.value==value){
return this;
}
//判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
//如果找到返回
TreeNode resNode=null;
if(this.left!=null){
resNode=this.left.preOrderSearch(value);
}
if(resNode!=null){//说明在左子树找到
return resNode;
}
//判断当前节点的右子节点是否为空，不为空则继续向右递归前序查找
if(this.right!=null){
resNode=this.right.preOrderSearch(value);
}
return resNode;
}
//中序遍历查找
public TreeNode infixOrderSearch(String value){
//判断当前节点的左子节点是否为空，若不为空，则递归中序查找
TreeNode resNode=null;
if(this.left!=null){
resNode=this.left.infixOrderSearch(value);
}
if(resNode!=null){
return resNode;
}
//如果找到返回，如果没找到，就和当前节点比较
if(this.value==value){
resNode=this;
}
//否则继续进行右递归的中序查找
if(this.right!=null){
resNode=this.right.preOrderSearch(value);
}
return resNode;
}
//后序遍历查找
public TreeNode postOrderSearch(String value){
//判断当前节点的左子节点是否为空，若不为空，则递归后序查找
TreeNode resNode=null;
if(this.left!=null){
resNode=this.left.postOrderSearch(value);
}
if(resNode!=null){
return resNode;
}
//如果左子树没找到，则向右子树递归进行后序查找
if(this.right!=null){
resNode=this.right.postOrderSearch(value);
}
if(resNode!=null){
return resNode;
}
//说明左右子树都没有找到，比较当前节点
if(this.value==value){
return this;
}
return resNode;
}
}
