精华内容
下载资源
问答
  • Java对二叉树操作

    2018-04-21 18:21:16
    面试题7:重建二叉树 题目:输入某二叉树的前序遍历和中序遍历的结果,请重建该二叉树,假设输入的前序遍历和中序遍历的结果中都不包含重复的数字。例如:输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,...

        面试题7:重建二叉树 题目:输入某二叉树的前序遍历和中序遍历的结果,请重建该二叉树,假设输入的前序遍历和中序遍历的结果中都不包含重复的数字。例如:输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}则重建如图(a)所示的二叉树并输出它的头节点。二叉树节点的定义如(b):

                         

                 (a)       

    struct BinaryTreeNode
    {
        int              m_nValue;
        BinaryTreeNode   m_pLeft;
        BinaryTreeNode   m_pRight;
    };
                  (b)

            

    示例代码:

    public class BinaryTreeNode {
        public  int value;   /*结点的值*/
        BinaryTreeNode leftNode;    /*左子树*/
        BinaryTreeNode rightNode;   /*右子树*/
    }
    
    public class BinaryTree {
        public static void main(String args[]){
            int[] preSort = {1,2,4,7,3,5,6,8};  /*前序遍历序列*/
            int[] inSort = {4,7,2,1,5,3,8,6};   /*中序遍历序列*/
    
        }
        public static BinaryTreeNode constructCore(int[] preorder,int[] inorder)
                throws Exception{
            /*两个序列不能为空*/
            if (preorder == null || inorder == null){
                return null;
            }
            /*两个序列长度要一样*/
            if (preorder.length != inorder.length){
                throw new Exception("长度不一样,非法的输入");
            }
            BinaryTreeNode root = new BinaryTreeNode();
            /*前序遍历的第一个就是根节点*/
            for (int i = 0;i < inorder.length;i++){
                if (inorder[i] == preorder[0]){
                    root.value = inorder[i];
                    System.out.println(root.value);
                    /*遍历左子树*/
                    /*
                    *前序遍历的左子树是下标从1到i+1(不包括i+1)的数
                    *中序遍历的左子树是下标从0到i(不包括i)的数
                    * */
                    root.leftNode = constructCore(Arrays.copyOfRange(preorder,1,i+1),
                            Arrays.copyOfRange(inorder,0,i));
                    root.rightNode = constructCore(Arrays.copyOfRange(preorder,i+1,preorder.length),
                            Arrays.copyOfRange(inorder,i+1,inorder.length));
                }
            }
            return root;
        }
    }



    
    展开全文
  • Java实现二叉树的基本操作
  • java 实现二叉树操作

    2012-09-03 23:48:32
    java实现二叉树的创建、先序遍历、中序遍历、后序遍历及二叉树的深度  public class Tree {  private int data;// 数据节点  private Tree left;// 左子树  private Tree right;// 右子树...
    
    

    java实现二叉树的创建、先序遍历、中序遍历、后序遍历及二叉树的深度  


    public class Tree {

     private int data;// 数据节点
     private Tree left;// 左子树
     private Tree right;// 右子树

     public Tree(int data) {
      this.data = data;
      this.left = null;
      this.right = null;
     }

     /**
      * 创建二叉树,返回根结点
      * 
      * @param input
      * @return
      */
     public static Tree createTree(int[] input) {
      Tree root = null;
      Tree temp = null;
      for (int i = 0; i < input.length; i++) {
       // 创建根节点
       if (root == null) {
        root = temp = new Tree(input[i]);
       } else {
        // 回到根结点
        temp = root;
        // 添加节点
        while (temp.data != input[i]) {
         if (input[i] <= temp.data) {
          if (temp.left != null) {
           temp = temp.left;
          } else {
           temp.left = new Tree(input[i]);
          }
         } else {
          if (temp.right != null) {
           temp = temp.right;
          } else {
           temp.right = new Tree(input[i]);
          }
         }
        }
       }
      }
      return root;
     }

     /**
      * 前序遍历
      * 
      * @param tree
      */
     public static void preOrder(Tree tree) {
      if (tree != null) {
       System.out.print(tree.data + " ");
       preOrder(tree.left);
       preOrder(tree.right);
      }
     }

     /**
      * 中序遍历
      * 
      * @param tree
      */
     public static void midOrder(Tree tree) {
      if (tree != null) {
       midOrder(tree.left);
       System.out.print(tree.data + " ");
       midOrder(tree.right);
      }
     }

     /**
      * 后序遍历
      * 
      * @param tree
      */
     public static void posOrder(Tree tree) {
      if (tree != null) {
       posOrder(tree.left);
       posOrder(tree.right);
       System.out.print(tree.data + " ");
      }
     }
     
     /**
      * 求二叉树的深度
      * 
      * @param tree
      */
     public static int length(Tree tree){
      int depth1;
      int depth2;
      if(tree == null) return 0;
      //左子树的深度
      depth1 = length(tree.left);
      //右子树的深度
      depth2 = length(tree.right);
      if(depth1>depth2)
       return depth1+1;
      else
       return depth2+1;
     }


     /**
      * @param args
      */
     public static void main(String[] args) {
      int[] input = { 4, 2, 6, 1, 3, 5, 7,8,10 };
      Tree tree = createTree(input);
      System.out.print("前序遍历:");
      preOrder(tree);
      System.out.print("\n二叉树深度为:"+length(tree));
      
      System.out.print("\n中序遍历:");
      midOrder(tree);
      System.out.print("\n后序遍历:");
      posOrder(tree);
     }
    }

    展开全文
  • 二叉树Java实现二叉树基本操作

    万次阅读 多人点赞 2016-08-25 03:08:44
    定义一个节点类,使节点与二叉树操作分离 class Node { int value; Node leftChild; Node rightChild; Node(int value) { this.value = value; } public void display() { System.out.print(th

    参考自《Java数据结构与算法》

    • 定义一个节点类,使节点与二叉树操作分离

    class Node {
    	int  value;
    	Node leftChild;
    	Node rightChild;
    	
    	Node(int value) {
    		this.value = value;
    	}
    	
    	public void display() {
    		System.out.print(this.value + "\t");
    	}
    
    	@Override
    	public String toString() {
    		// TODO Auto-generated method stub
    		return String.valueOf(value);
    	}
    }

    • 需要实现的二叉树操作

    class BinaryTree {
    	private Node root = null;
    	
    	BinaryTree(int value) {
    		root = new Node(value);
    		root.leftChild  = null;
    		root.rightChild = null;
    	}
    	public Node findKey(int value) {}   //查找
            public String insert(int value) {}  //插入
            public void inOrderTraverse() {}    //中序遍历递归操作
            public void inOrderByStack() {}     //中序遍历非递归操作    
            public void preOrderTraverse() {}  //前序遍历
            public void preOrderByStack() {}   //前序遍历非递归操作
            public void postOrderTraverse() {} //后序遍历
            public void postOrderByStack() {}  //后序遍历非递归操作
            public int getMinValue() {} //得到最小(大)值
            public boolean delete(int value) {} //删除
    }

    • 查找数据:

      public Node findKey(int value) {
    		Node current = root;
    		while (true) {
    			if (value == current.value) {
    				return current;
    			} else if (value < current.value) {
    				current = current.leftChild;
    			} else if (value > current.value) {
    				current = current.rightChild;
    			}
    			
    			if (current == null) {
    				return null;
    			}
    		}
    	}

    • 插入数据:与查找数据类似,不同点在于当节点为空时,不是返回而是插入

      public String insert(int value) {
    		String error = null;
    		
    		Node node = new Node(value);
    		if (root == null) {
    			root = node;
    			root.leftChild  = null;
    			root.rightChild = null;
    		} else {
    			Node current = root;
    			Node parent = null;
    			while (true) {
    				if (value < current.value) {
    					parent = current;
    					current = current.leftChild;
    					if (current == null) {
    						parent.leftChild = node;
    						break;
    					}
    				} else if (value > current.value) {
    					parent = current;
    					current = current.rightChild;
    					if (current == null) {
    						parent.rightChild = node;
    						break;
    					}
    				} else {
    					error = "having same value in binary tree";
    				}	
    			} // end of while
    		}
    		return error;
        }

    • 遍历数据:

                1)中序遍历:最常用的一种遍历方法

      /**
    	 * //中序遍历(递归):
    	 *    1、调用自身来遍历节点的左子树
    	 *    2、访问这个节点
    	 *    3、调用自身来遍历节点的右子树
    	 */
    	public void inOrderTraverse() {
    		System.out.print("中序遍历:");
    		inOrderTraverse(root);
    		System.out.println();
    	}
    	
    	private void inOrderTraverse(Node node) {
    		if (node == null) 
    			return ;
    		
    		inOrderTraverse(node.leftChild);
    		node.display();
    		inOrderTraverse(node.rightChild);
    	}

                   

    /**
    	 * 中序非递归遍历:
    	 *     1)对于任意节点current,若该节点不为空则将该节点压栈,并将左子树节点置为current,重复此操作,直到current为空。
    	 *     2)若左子树为空,栈顶节点出栈,访问节点后将该节点的右子树置为current
    	 *     3) 重复1、2步操作,直到current为空且栈内节点为空。
    	 */
    	public void inOrderByStack() {
    		System.out.print("中序非递归遍历:");
    		Stack<Node> stack = new Stack<Node>();
    		Node current = root;
    		while (current != null || !stack.isEmpty()) {
    			while (current != null) {
    				stack.push(current);
    				current = current.leftChild;
    			}
    			
    			if (!stack.isEmpty()) {
    				current = stack.pop();
    				current.display();
    				current = current.rightChild;
    			}
    		}
    		System.out.println();
    	}

                  2)前序遍历:

      /**
    	 * //前序遍历(递归):
    	 *    1、访问这个节点
    	 *    2、调用自身来遍历节点的左子树
    	 *    3、调用自身来遍历节点的右子树
    	 */
    	public void preOrderTraverse() {
    		System.out.print("前序遍历:");
    		preOrderTraverse(root);
    		System.out.println();
    	}
    	
    	private void preOrderTraverse(Node node) {
    		if (node == null) 
    			return ;
    		
    		node.display();
    		preOrderTraverse(node.leftChild);
    		preOrderTraverse(node.rightChild);
    	}

                   

    /**
    	 * 前序非递归遍历:
    	 *     1)对于任意节点current,若该节点不为空则访问该节点后再将节点压栈,并将左子树节点置为current,重复此操作,直到current为空。
    	 *     2)若左子树为空,栈顶节点出栈,将该节点的右子树置为current
    	 *     3) 重复1、2步操作,直到current为空且栈内节点为空。
    	 */
    	public void preOrderByStack() {
    		System.out.print("前序非递归遍历:");
    		Stack<Node> stack = new Stack<Node>();
    		Node current = root;
    		while (current != null || !stack.isEmpty()) {
    			while (current != null) {
    				stack.push(current);
    				current.display();
    				current = current.leftChild;
    			}
    			
    			if (!stack.isEmpty()) {
    				current = stack.pop();
    				current = current.rightChild;
    			}
    		}
    		System.out.println();
    	}

                 3)后序遍历:

      /**
    	 * //后序遍历(递归):
    	 *    1、调用自身来遍历节点的左子树
    	 *    2、调用自身来遍历节点的右子树
    	 *    3、访问这个节点
    	 */
    	public void postOrderTraverse() {
    		System.out.print("后序遍历:");
    		postOrderTraverse(root);
    		System.out.println();
    	}
    	
    	private void postOrderTraverse(Node node) {
    		if (node == null) 
    			return ;
    		
    		postOrderTraverse(node.leftChild);
    		postOrderTraverse(node.rightChild);
    		node.display();
    	}
    /**
    	 * 后序非递归遍历:
    	 *     1)对于任意节点current,若该节点不为空则访问该节点后再将节点压栈,并将左子树节点置为current,重复此操作,直到current为空。
    	 *     2)若左子树为空,取栈顶节点的右子树,如果右子树为空或右子树刚访问过,则访问该节点,并将preNode置为该节点
    	 *     3) 重复1、2步操作,直到current为空且栈内节点为空。
    	 */
    	public void postOrderByStack() {
    		System.out.print("后序非递归遍历:");
    		Stack<Node> stack = new Stack<Node>();
    		Node current = root;
    		Node preNode = null;
    		while (current != null || !stack.isEmpty()) {
    			while (current != null) {
    				stack.push(current);
    				current = current.leftChild;
    			}
    			
    			if (!stack.isEmpty()) {
    				current = stack.peek().rightChild;
    				if (current == null || current == preNode) {
    					current = stack.pop();
    					current.display();
    					preNode = current;
    					current = null;
    				}
    			}
    		}
    		System.out.println();
    	}


    • 得到最小(大)值:依次向左(右)直到空为之
      public int getMinValue() {
    		Node current = root;
    		while (true) {
    			if (current.leftChild == null)
    				return current.value;
    			
    			current = current.leftChild;
    		}
    	}
    • 删除:删除操作很复杂,删除节点大致分为三种情况:
                 1)删除节点为叶子节点

                   

                  2)删除节点只有一个子节点:只有一个左子节点和只有一个右子节点

                   

                  3)删除节点有两个子节点:这种情况比较复杂,需要寻找后继节点,即比要删除的节点的关键值次高的节点是它的后继节点。

                说得简单一些,后继节点就是比要删除的节点的关键值要大的节点集合中的最小值

                得到后继节点的代码如下:

      /**
    	 * 
    	 * 得到后继节点,即删除节点的左后代
    	 */
    	private Node getSuccessor(Node delNode) {
    		Node successor = delNode;
    		Node successorParent = null;
    		Node current = delNode.rightChild;
    		
    		while (current != null) {
    			successorParent = successor;
    			successor = current;
    			current = current.leftChild;
    		}
    		
    		//如果后继节点不是删除节点的右子节点时,
    		if (successor != delNode.rightChild) {
    			//要将后继节点的右子节点指向后继结点父节点的左子节点,
    			successorParent.leftChild = successor.rightChild;
    			//并将删除节点的右子节点指向后继结点的右子节点
    			successor.rightChild = delNode.rightChild;
    		}
    		//任何情况下,都需要将删除节点的左子节点指向后继节点的左子节点
    		successor.leftChild = delNode.leftChild;
    		
    		return successor;
    	}
                     a)如果后继节点是刚好是要删除节点的右子节点(此时可以知道,这个右子节点没有左子点,如果有,就不该这个右子节点为后继节点)

              

                

             //删除的节点为父节点的左子节点时:
             parent.leftChild = successor;
             successor.leftChild = delNode.leftChild;
                  
             //删除的节点为父节点的右子节点时:
             parent.rightChild = successor;
             successor.leftChild = delNode.leftChild

    
    

                 b)如果后继节点为要删除节点的右子节点的左后代:

                 

                

            //删除的节点为父节点的左子节点时:
             successorParent.leftChild = successor.rightChild;
             successor.rightChild = delNode.rightChild;
              parent.leftChild = successor;
              successor.leftChild = delNode.leftChild;
                  
              //删除的节点为父节点的右子节点时:
              successorParent.leftChild = successor.rightChild;
              successor.rightChild = delNode.rightChild;
              parent.rightChild = successor;
              successor.leftChild = delNode.leftChild;

    
                    综合以上各种情况,删除代码如下:
    

      public boolean delete(int value) {
    		Node current = root;    //需要删除的节点
    		Node parent = null;     //需要删除的节点的父节点
    		boolean isLeftChild = true;   //需要删除的节点是否父节点的左子树
    		
    		while (true) {
    			if (value == current.value) {
    				break;
    			} else if (value < current.value) {
    				isLeftChild = true;
    				parent = current;
    				current = current.leftChild;
    			} else {
    				isLeftChild = false;
    				parent = current;
    				current = current.rightChild;
    			}
    			
    			//找不到需要删除的节点,直接返回
    			if (current == null)
    				return false;
    		}
    		
    		//分情况考虑
    		//1、需要删除的节点为叶子节点
    		if (current.leftChild == null && current.rightChild == null) {
    			//如果该叶节点为根节点,将根节点置为null
    			if (current == root) {
    				root = null;
    			} else {
    				//如果该叶节点是父节点的左子节点,将父节点的左子节点置为null
    				if (isLeftChild) {
    					parent.leftChild  = null;
    				} else { //如果该叶节点是父节点的右子节点,将父节点的右子节点置为null
    					parent.rightChild = null;
    				}
    			}
    		} 
    		//2、需要删除的节点有一个子节点,且该子节点为左子节点
    		else if (current.rightChild == null) {
    			//如果该节点为根节点,将根节点的左子节点变为根节点
    			if (current == root) {
    				root = current.leftChild;
    			} else {
    				//如果该节点是父节点的左子节点,将该节点的左子节点变为父节点的左子节点
    				if (isLeftChild) {
    					parent.leftChild = current.leftChild;
    				} else {  //如果该节点是父节点的右子节点,将该节点的左子节点变为父节点的右子节点
    					parent.rightChild = current.leftChild;
    				}
    			}
    		}
    		//2、需要删除的节点有一个子节点,且该子节点为右子节点
    		else if (current.leftChild == null) {
    			//如果该节点为根节点,将根节点的右子节点变为根节点
    			if (current == root) {
    				root = current.rightChild;
    			} else {
    				//如果该节点是父节点的左子节点,将该节点的右子节点变为父节点的左子节点
    				if (isLeftChild) {
    					parent.leftChild = current.rightChild;
    				} else {  //如果该节点是父节点的右子节点,将该节点的右子节点变为父节点的右子节点
    					parent.rightChild = current.rightChild;
    				}
    			}
    		}
    		//3、需要删除的节点有两个子节点,需要寻找该节点的后续节点替代删除节点
    		else {
    			Node successor = getSuccessor(current);
    			//如果该节点为根节点,将后继节点变为根节点,并将根节点的左子节点变为后继节点的左子节点
    			if (current == root) {
    				root = successor;
    			} else {
    				//如果该节点是父节点的左子节点,将该节点的后继节点变为父节点的左子节点
    				if (isLeftChild) {
    					parent.leftChild = successor;
    				} else {  //如果该节点是父节点的右子节点,将该节点的后继节点变为父节点的右子节点
    					parent.rightChild = successor;
    				}
    			}
    		}
    		current = null;
    		return true;
    	}

    •                测试代码
        public class BinaryTreeDemo {
    	    public static void main(String[] args) {
    		BinaryTree bt = new BinaryTree(52);
    		bt.insert(580);
    		bt.insert(12);
    		bt.insert(50);
    		bt.insert(58);
    		bt.insert(9);
    		bt.insert(888);
    		bt.insert(248);
    		bt.insert(32);
    		bt.insert(666);
    		bt.insert(455);
    		bt.insert(777);
    		bt.insert(999);
    		bt.inOrderTraverse();
    		bt.preOrderTraverse();
    		bt.postOrderTraverse();
    		System.out.println(bt.findKey(32));
    		System.out.println(bt.findKey(81));
    		System.out.println("最小值:" + bt.getMinValue());
    //		bt.delete(32);      //删除叶子节点
    //		bt.delete(50);      //删除只有一个左子节点的节点
    //		bt.delete(248);      //删除只有一个右子节点的节点
    //		bt.delete(248);      //删除只有一个右子节点的节点
    //		bt.delete(580);      //删除有两个子节点的节点,且后继节点为删除节点的右子节点的左后代
    //		bt.delete(888);      //删除有两个子节点的节点,且后继节点为删除节点的右子节点
    		bt.delete(52);       //删除有两个子节点的节点,且删除节点为根节点
    		
    		bt.inOrderTraverse();
    	    }
        }
    测试结果:

    中序遍历:91232 50 52 58248455580 666777 888999
    中序非递归遍历:9 12 32 50 5258248 455580 666777 888999
    前序遍历:52 12 9 50 3258058 248 455 888 666 777 999
    前序非递归遍历:52 12 9 50 3258058 248 455 888 666 777 999
    后序遍历:9 32 50 12 45524858 777 666 999 888 580 52
    后序非递归遍历:9 32 50 12 45524858 777 666 999 888 580 52
    32
    null
    最小值:9
    中序遍历:9 12 32 50 58248455580 666777 888999

    展开全文
  • 使用Java实现二叉树及其遍历操作 实现二叉树 首先实现二叉树的结点元素 此处结点元素定义为树结点的值和二叉树结点类型的左孩子和右孩子 操作为构建、遍历操作(前序遍历、中序遍历、后续遍历) 代码如下 ...

    使用Java实现二叉树及其遍历操作

    实现二叉树 首先实现二叉树的结点元素 此处结点元素定义为树结点的值和二叉树结点类型的左孩子和右孩子

    操作为构建、遍历操作(前序遍历、中序遍历、后续遍历)

    代码如下

    
    public class BinTree {
    
    	//二叉树的定义、构建以及前中后序遍历
    	int val;//the value of the node
    	BinTree lchild;//左子树
    	BinTree rchild;//右子树
    	
    	BinTree(int x)
    	{
    		this.val=x;
    	}
    	
    	public void Pretraverse(BinTree bt)//二叉树的前序遍历:root-left-right
    	{
    		BinTree temp=bt;
    		if(temp!=null)
    		{
    			System.out.print(temp.val+"->");
    			Pretraverse(bt.lchild);
    			Pretraverse(bt.rchild);
    		}
    			
    	}
    	public void Intraverse(BinTree bt)//二叉树的中序遍历:left-root-right
    	{
    		BinTree temp=bt;
    		if(temp!=null)
    		{
    			Intraverse(bt.lchild);
    			System.out.print(temp.val+"->");
    			Intraverse(bt.rchild);
    		}
    			
    	}
    	public void Posttraverse(BinTree bt)//二叉树的后序遍历:left-right-root
    	{
    		BinTree temp=bt;
    		if(temp!=null)
    		{		
    			Posttraverse(bt.lchild);
    			Posttraverse(bt.rchild);
    			System.out.print(temp.val+"->");
    		}
    			
    	}
    	public static void main(String[] args) {
    		
    		//构建二叉树
    		BinTree root=new BinTree(100);
    		
    		root.lchild=new BinTree(50);
    		root.rchild=new BinTree(130);
    		
    		root.lchild.lchild=new BinTree(35);
    		root.lchild.rchild=new BinTree(55);
    		
    		root.rchild.lchild=new BinTree(105);
    		root.rchild.rchild=new BinTree(135);
    		
    		//遍历
    		System.out.println("前序遍历");
    		root.Pretraverse(root);
    		System.out.println("\\");
    		
    		
    		System.out.println("中序遍历");
    		root.Intraverse(root);
    		System.out.println("\\");
    		
    		
    		System.out.println("后序遍历");
    		root.Posttraverse(root);
    		System.out.println("\\");
    	}
    
    }
    

    运行结果:

    前序遍历
    100->50->35->55->130->105->135->\
    中序遍历
    35->50->55->100->105->130->135->\
    后序遍历
    35->55->50->105->135->130->100->\

     

    展开全文
  • java操作二叉树java遍历二叉树 java前序中序后续遍历二叉树 java计算二叉树深度 java层次遍历二叉树
  • Java实现二叉树的相关操作.
  • java操作二叉树

    2015-01-16 14:58:43
    题目:用java语言创建二叉树,完成二叉树的建立和遍历; */ import java.util.Scanner; class BinaryTreeDemo { public static void main(String[] args) { Node binaryNode = new Node(); BinaryTree binary...
  • 总结了下二叉树的基本操作。 创建二叉查找树 先序遍历二叉树(递归) 先序遍历二叉树(栈) 中序遍历二叉树(递归) 中序遍历二叉树(栈) 后序遍历二叉树(递归) 后序遍历二叉树(栈) 宽度优先...
  • 参考他人代码,自己手打一遍,嗯,没有语法错误,哈哈。 .../**二叉树的链式储存结构 * Created by Administrator on 2017/1/1. */ public class TwoTree { private int[] arry={1,2,3,4,5,6,7
  • 本文实例讲述了Java实现二叉树的建立、计算高度与递归输出操作。分享给大家供大家参考,具体如下:1. 建立 递归输出 计算高度 前中后三种非递归输出public class Tree_Link {private int save = 0;private int now =...
  • 主要介绍了Java实现二叉树的建立、计算高度与递归输出操作,结合实例形式分析了Java二叉树的创建、遍历、计算等相关算法实现技巧,需要的朋友可以参考下
  • java 实现二叉树的基本操作

    千次阅读 2018-05-01 13:32:52
    我建立的二叉树如下图所示:以下是使用Java语言实现二叉树的基本操作package com.ddh.binarytree; import java.util.*; @SuppressWarnings("all") public class BinaryTree { private TreeNode root...
  • 之前写过关于C语言实现二叉树的一些操作这段时间正好在看Java,就将一些常见的二叉树问题转换为Java语言实现1.二叉树的先序、中序、后序、层序遍历(递归与非递归)先序遍历:二叉树的先序遍历顺序为:先打印根节点...
  • java 二叉树

    2017-06-22 21:28:49
    java 二叉树 leetcode(一)首先来看看 java 生成二叉树 直接上代码 生成二叉树步骤 创建二叉树节点对象 创建存储所有二叉树节点的集合 list 使用LinkedList是因为这是链表数组结构 add 和 remove 操作比arrayList ...
  • java泛型二叉树

    2020-04-10 20:34:27
    二叉树为空,则退出,否则, 按照树的结构,从根开始自上而下,自左而右访问每一个结点,从而实现每一个结点的遍历
  • import java.util.Scanner; public class BinaryTree { private static Node root=null; private class Node{ Node left; Node right; int value; public Node(int value){ this.value=value; lef
  • 二叉树操作

    2012-07-22 13:03:27
    java 二叉树操作
  • Java实现二叉树

    2017-02-09 17:03:00
    什么是二叉树? 用自己的话说就是, 树中的每个节点最多只有2个子节点. 主要树中没有任何节点也是一颗树(空树).... 在后面用java实现二叉树时, 我们都是递归的方式实现的. java代码实现 首先定义二叉树...
  • Java 判断二叉树是否是平衡二叉树

    千次阅读 2018-05-08 16:52:03
    输入一棵二叉树,判断该二叉树是否是平衡二叉树。平衡二叉树平衡二叉树(Balanced BinaryTree)又被称为AVL树。...但是由于其对二叉树施加了额外限制,因而其添加、删除操作都必须保证平衡二叉树的性子...
  • java实现二叉树的常见操作

    千次阅读 2011-10-02 23:41:39
    树型结构是最常见的非线性结构,其中二叉树最为常见。今天我主要就是用java来实现一下树的一些常见操作。  首先需要一个用来存储树节点值的javabean: public class TreeBean { private int nodeValue; p
  • Java 二叉树

    2020-08-11 16:59:19
    Java 二叉树树的概念二叉树概念特殊的二叉树二叉树的遍历二叉树的表现形式常见操作 树是一种非线性的数据结构,它是由n(n>=0)个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看 起来像一棵倒挂的树...
  • Java二叉树

    2015-05-25 10:59:23
    java中treemap和treeset实现(红黑树) TreeMap 的实现就是红黑树数据结构,也就说是一棵自平衡的排序二叉树,这样就可以保证当需要快速检索指定节点。 TreeSet 和 TreeMap 的关系 为了让大家了解 TreeMap 和 ...
  • java实现二叉树

    2017-05-25 15:21:48
    1.二叉树的主要性质 性质1:非空二叉树上叶子节点数等于双分支节点数加1。(使用总分支数=总节点数-1证明) 性质2:二叉树的第i层上最多有2^(i-1)个节点(i>=1)。 性质3:高度为k的二叉树最多有2^(i-1)个节点。 ...
  • java实现二叉树相关操作,欢迎讨论
  • java 实现二叉树题目

    2017-09-11 23:33:32
    二叉树是一种特殊的树,在二叉树中每个节点最多有两个子节点,一般称为左子节点和右子节点(或左孩子和右孩子),并且二叉树的子树有左右之分,其次序不能任意颠倒。二叉树是递归定义的,因此,与二叉树有关的题目...
  • Java实现二叉树的创建和遍历操作(有更新)
  • 许多实际问题抽象出来的数据结构往往是二叉树的形式,即使是一般的树也能简单地转换为二叉树,而且二叉树的存储结构及其算法都较为简单,因此二叉树显得特别重要。 二叉树(BinaryTree)由一个节点及两棵互不相交的、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,701
精华内容 24,280
关键字:

java对二叉树操作

java 订阅