二叉树的相关算法

 /**
     * 具体实现部分
     * @param node
     */
  //输出二叉树的所有叶子节点
  	public void yezi(Node<T> node)
  	{
  		if(node==null) return;
  		else
  		{
  			yezi(node.lChild);
  			yezi(node.rChild);			
  		}
  		if (node.lChild==null&&node.rChild==null) {
  			System.out.print("叶子:"+node.getData());
  		  }
  	}
  //统计二叉树所有节点的总数
  	public int count(Node<T> node)
  	{
  		if(node==null) return count;
  		else
  		{
  			count++;
  			count(node.lChild);
  			count(node.rChild);
  		}
  		return count;
  	}
  	
    //在当前二叉树中查找数据x
    public Node<T> search(Node<T> node,T x){
    	if(node==null)
    		return null;
    	else{
    		if((node.getData()).equals(x)){
    			return node;
    		}			
    		else{
    			Node<T> s=search(node.lChild,x);
    			if(s!=null)//预防右孩子执行不了
    				return s;
    			else
    				return search(node.rChild,x);
    		}
    	}
    }

    //查找node的parent
    public Node<T> search2(Node<T> node,T x){
    	if(node==null)
    		return null;
    	else{
    		if((node.getData()).equals(x)){	
    			return node;
    		}			
    		else{
    			Node<T> s=search2(node.lChild,x);
    			if(s!=null&&s.getData().equals(x))//预防右孩子执行不了
    				{
    				    a[b]=node;
    				    b++;
    				}
    			   
    			else{
    				s= search2(node.rChild,x);
    				if(s!=null&&s.getData().equals(x))
    				{
    					a[b] = node;
    				    b++;
    				}
    			}  				
    		}
    	}
		return (Node<T>) a[0];
    }
    
  //判断node是parent的左孩子还是右孩子
    public String search3(Node<T> node,T x){
    	if(node==null)
    		return null;
    	else{
    		if((node.getData()).equals(x)){
    			return "Yes";
    		}			
    		else{
    			String s=search3(node.lChild,x);
    			if(s!=null&&s.equals("Yes"))//预防右孩子执行不了
    			{
    				lr[c] = "left";
    				c++;
    			}  			
    			
    			else
    				{
    				    s=search3(node.rChild,x);
    				    if(s!=null&&s.equals("Yes"))
    				    {
    				    	lr[c] = "right";
    				        c++;			
    				    }
    				 
    				}
    		}
    	}
		return (String) lr[0];
    }
    //插入操作
    public boolean insert(Node<T> a, Node<T> parent)
	{ 
		if(parent==null)	return false;
		//Node<T> p= new Node<T>(x);
		if(parent.lChild==null) parent.lChild = a;
		else
		{
			insert(a,parent.lChild);
		}
		return true;
	} 
    //插入操作
    public boolean insertl(Node<T> a, Node<T> parent)
	{ 
		if(parent==null)	return false;
		//Node<T> p= new Node<T>(x);
		if(parent.lChild==null) parent.lChild = a;
		else
		{
			insertl(a,parent.lChild);
		}
		return true;
	} 
    //插入操作
    public boolean insertr(Node<T> a, Node<T> parent)
	{ 
		if(parent==null)	return false;
		//Node<T> p= new Node<T>(x);
		if(parent.rChild==null) parent.rChild = a;
		else
		{
			insertr(a,parent.lChild);
		}
		return true;
	} 
  //缩进打印
  	public void suojin()
  	{
  		Node<T>[] queue= new Node[this.maxNodes];
  		int frontL,rearL;
  		if (this.root==null) return;
  		frontL=-1;
  		rearL=0;
  		queue[rearL]=this.root.lChild;
  		System.out.print("左分支:");
  		while(frontL!=rearL)
  		{
  			frontL++;
  			System.out.print(queue[frontL].getData());
  			if (queue[frontL].lChild!=null)
  			{ 
  				rearL++;
  				queue[rearL]=queue[frontL].lChild;
  			}
  			if (queue[frontL].rChild!=null)
  			{
  				rearL++;
  				queue[rearL]=queue[frontL].rChild;
  			}
  		}
  		System.out.print("  右分枝:");
  		int frontR,rearR;
  		if (this.root==null) return;
  		frontR=-1;
  		rearR=0;
  		queue[rearR]=this.root.rChild;
  		while(frontR!=rearR)
  		{
  			frontR++;
  			System.out.print(queue[frontR].getData());
  			if (queue[frontR].lChild!=null)
  			{ 
  				rearR++;
  				queue[rearR]=queue[frontR].lChild;
  			}
  			if (queue[frontR].rChild!=null)
  			{
  				rearR++;
  				queue[rearR]=queue[frontR].rChild;
  			}
  		}
  	}

/**主函数部分
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] aa= new int[]{1,2,3,4};
		int[] bb= new int[]{5,6,7,8};
		BinaryTree<Integer> tree = new BinaryTree<>(0);
		Node<Integer> node = tree.root;
        for (int i = 0; i < aa.length; i++) {
			tree.insertLeft(aa[i], node);
			tree.insertRight(bb[i], node);
		}
        System.out.println("原始二叉树:");
        tree.traversal(0);
        
        //2.输出二叉树的所有叶子节点
        System.out.println("\n二叉树的所有叶子节点:");
        tree.yezi(tree.root);
        
        //3.统计节点数量
        System.out.println("\n节点的数量为："+tree.count(tree.root));
        
        //4.交换二叉树任意两个节点（假设二叉树的每个节点的值都不一样）
        Node<Integer> node1 = tree.search(tree.root, 3);
        Node<Integer> node2 = tree.search(tree.root, 7);
        int temp = node1.getData();
        node1.setData(node2.getData());
        node2.setData(temp);
        System.out.print("节点3和节点7交换后：");
        tree.traversal(0);       
        System.out.println("(先序遍历)");
        
        
        
        //5.将现有二叉树的某个子树a移到其他子树b中
        Node<Integer> a = tree.search(tree.root, 2);
        Node<Integer> b = tree.search(tree.root, 3);
  
        //5.1查找a的双亲
        Node<Integer> parentOfa=tree.search2(tree.root,a.getData());
        //System.out.println("a的双亲是:"+parentOfa.getData());       
        //5.2判断a是parent的左节点还是右节点
        String s= tree.search3(tree.root,a.getData()); 
        System.out.println("a在双亲的:"+s);   
        System.out.println();
        //5.3插入操作将a插到b中
        tree.insert(a, b); 
        //5.4将子树a置空
        if (s.equals("left")) {
			parentOfa.lChild=null; 
		}else if (s.equals("right")){
			parentOfa.rChild=null;
		}     
        //5.5遍历一下,检验是否正确
        System.out.println("将a移到b以后：");
        tree.traversal(0);
        System.out.println("(先序)");           
        tree.traversal(1);
        System.out.println("(中序)");
        
        
        //6.删除一个节点
        //6.1找到这个节点
        Node<Integer> delete = tree.search(tree.root, 3);
        //6.2找到这个节点的双亲节点
        tree.b = 0;
        Node<Integer> parentOfdelete=tree.search2(tree.root,delete.getData());
        //System.out.println("delete的双亲是:"+parentOfdelete.getData());
        //6.3判断这个节点是双亲的左孩子还是右
        tree.c = 0;
        //6.4判断delete是双亲节点的左孩子还是右孩子
        s= tree.search3(tree.root,delete.getData());
        if (s.equals("left")) {
			parentOfdelete.lChild=null;
		}
        if (s.equals("right")){
        	parentOfdelete.rChild=null;
        }
        //6.5找到节点的左孩子和右孩子
        Node<Integer> left = delete.lChild;
        Node<Integer> right = delete.rChild;
        //6.6插入操作
        if (left != null) {
			tree.insertl(left,parentOfdelete);
		}
        if (right != null) {
			tree.insertr( right,parentOfdelete);
		}
        //6.7遍历一下,检验是否正确
        System.out.println("删除节点以后:");
        tree.traversal(0);
        System.out.println("(先序)");
        tree.traversal(1);       
        System.out.println("(中序)");
        
        
        //7.缩进结构打印
        System.out.println("缩进结构打印:");
        tree.suojin();
     }