数据结构九 二叉树的三种遍历方式，前序查找，删除

class TreeNode{
    private String name;
    private int no;
    private TreeNode left;
    private TreeNode right;

    public TreeNode(String name, int no) {
        this.name = name;
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "TreeNode{" +
                "name='" + name + '\'' +
                ", no=" + no +
                '}';
    }
}
class Tree
{
   TreeNode root;
    public Tree(TreeNode root) {
        this.root = root;
    }

    public void delinit(int no)
    {
        //这里单独提出来，是为了后续删除不必每次都对root进行判断
        if(root!=null)
        {
            if(root.getNo()==no)
            {
                root=null;
                return;
            }
            else
            {
                delNode(root,no);
            }

        }
        else
        {
            System.out.println("二叉树为空不能删除节点");
            return;
        }
    }
    public void delNode(TreeNode treeNode,int no)
    {
        //删除一个节点需要通过这个节点的父节点进行
        //必须判断treeNode.getleft!=null，不然会报空指针错误！
        //只需要把删除节点置为空，这样它的子树不会被上一个节点连接，也就相当于删除了.
      if(treeNode.getLeft()!=null&&treeNode.getLeft().getNo()==no)
      {
          treeNode.setLeft(null);
          return;
      }
      if(treeNode.getRight()!=null&&treeNode.getRight().getNo()==no)
      {
          treeNode.setRight(null);
          return;
      }
      if(treeNode.getLeft()!=null)
      {
         delNode(treeNode.getLeft(),no);
      }
      if(treeNode.getRight()!=null)
      {
          delNode(treeNode.getRight(),no);
      }
    }
    //前序遍历
    public void preorderfind(TreeNode treeNode,int no) {
      if (treeNode!=null)
      {
          if(treeNode.getNo()==no)
          {
              System.out.println("节点为"+no+"的元素找到为"+treeNode);
              return;
          }
          preorderfind(treeNode.getLeft(),no);
          preorderfind(treeNode.getRight(),no);
      }
    }
    //前序遍历
    public void preorder(TreeNode treeNode) {
        if(root==null)
        {
            System.out.println("二叉树为空，不能遍历!!");
        }
        if (treeNode!=null) {
            System.out.println(treeNode);
            preorder(treeNode.getLeft());
            preorder(treeNode.getRight());
        }
    }
    //中序遍历
    public void infixOrder(TreeNode treeNode)
    {
        if(root==null)
        {
            System.out.println("二叉树为空，不能遍历!!");
        }
        if(treeNode!=null)
        {
            infixOrder(treeNode.getLeft());
            System.out.println(treeNode);
            infixOrder(treeNode.getRight());
        }
    }
    //后序遍历
    public void postOrder(TreeNode treeNode)
    {
        if(root==null)
        {
            System.out.println("二叉树为空，不能遍历!!");
        }
        if(treeNode!=null)
        {
            postOrder(treeNode.getLeft());
            postOrder(treeNode.getRight());
            System.out.println(treeNode);

        }
    }
}
public class TreeTest {
    public static void main(String[] args) {
        TreeNode treeNode1=new TreeNode("姜志远1",1);
        TreeNode treeNode2=new TreeNode("姜志远2",2);
        TreeNode treeNode3=new TreeNode("姜志远3",3);
        TreeNode treeNode4=new TreeNode("姜志远4",4);
        TreeNode treeNode5=new TreeNode("姜志远5",5);
        Tree tree=new Tree(treeNode1);
        treeNode1.setLeft(treeNode2);
        treeNode1.setRight(treeNode3);
        treeNode2.setLeft(treeNode4);
        treeNode3.setLeft(treeNode5);
        System.out.println("前序遍历为:");
        tree.preorder(tree.root);
        System.out.println("中序遍历为:");
        tree.infixOrder(tree.root);
        System.out.println("后序遍历为:");
        tree.postOrder(tree.root);
        tree.preorderfind(tree.root,5);
        tree.delinit(5);
        System.out.println("删除节点5后，前序遍历为:");
        tree.preorder(tree.root);
    }
}