Java 二叉树

2025年5月13日 | 阅读 33 分钟

二叉树 是一种树状非线性数据结构，主要用于排序和搜索，因为它以分层形式存储数据。在本节中，我们将学习 Java 中二叉树数据结构的实现。还将提供二叉树数据结构的简要说明。

二叉树

每个节点（父节点）最多有两个子节点（左节点和右节点）的树称为二叉树。最顶端的节点称为根节点。在二叉树中，一个节点包含数据以及指向左子节点和右子节点的指针（地址）。

二叉树的高度是树的根与其最远（最深）叶节点之间边的数量。如果树为空，则高度为0。节点的高度表示为h。

上述二叉树的高度为 2。

我们可以使用以下公式计算叶节点和节点的数量。

二叉树的最大叶节点数：2^h
二叉树的最大节点数：2^h+1-1

其中，h 是二叉树的高度。

二叉树示例

二叉树的类型

数据结构中有以下类型的二叉树

满/严格二叉树
完全二叉树
完美二叉树
平衡二叉树
有根二叉树
退化/病态二叉树
扩展二叉树
斜二叉树
1. 左斜二叉树
2. 右斜二叉树
线索二叉树
1. 单线索二叉树
2. 双线索二叉树
AVL 树
红黑树
B 树
B+ 树
线段树

Java 中的二叉树实现

有许多方法可以实现二叉树。在本节中，我们将使用 LinkedList 数据结构来实现二叉树。此外，我们还将实现遍历顺序、搜索节点和在二叉树中插入节点。

使用 LinkedList 实现二叉树

算法

定义 Node 类，该类包含三个属性：data、left 和 right。这里，left 表示节点的左子节点，right 表示节点的右子节点。

创建节点时，数据将传递到节点的 data 属性，left 和 right 都将设置为 null。
定义另一个类，该类有一个 root 属性。
Root 表示树的根节点，并将其初始化为 null。

insert() 将添加一个新节点到树中
- 它检查 root 是否为 null，这意味着树是空的。它将新节点添加为 root。
- 否则，它将 root 添加到队列中。
- 变量 node 表示当前节点。
- 首先，它检查节点是否有左子节点和右子节点。如果有，它将两个节点都添加到队列中。
- 如果左子节点不存在，它将新节点添加为左子节点。
- 如果左子节点存在，则它将新节点添加为右子节点。
inorder() 将按中序顺序显示树的节点。
- 它遍历整个树，然后打印左子节点，然后是根节点，然后是右子节点。

BinarySearchTree.java

public class BinarySearchTree {  
    //Represent the node of binary tree  
    public static class Node{  
        int data;  
        Node left;  
        Node right;  
        public Node(int data){  
            //Assign data to the new node, set left and right children to null  
            this.data = data;  
            this.left = null;  
            this.right = null;  
            }  
        }  
    //Represent the root of binary tree  
    public Node root;  
    public BinarySearchTree(){  
        root = null;  
    }  
    //factorial() will calculate the factorial of given number  
    public int factorial(int num) {  
        int fact = 1;  
        if(num == 0)  
            return 1;  
        else {  
            while(num > 1) {  
                fact = fact * num;  
                num--;  
            }  
            return fact;  
        }  
    }  
    //numOfBST() will calculate the total number of possible BST by calculating Catalan Number for given key  
    public int numOfBST(int key) {  
        int catalanNumber = factorial(2 * key)/(factorial(key + 1) * factorial(key));  
        return catalanNumber;  
    }  
    public static void main(String[] args) {  
        BinarySearchTree bt = new BinarySearchTree();  
        //Display total number of possible binary search tree with key 5  
        System.out.println("Total number of possible Binary Search Trees with given key: " + bt.numOfBST(5));  
      }  
}  

输出

Binary tree after insertion
1 
Binary tree after insertion
2 1 3 
Binary tree after insertion
4 2 5 1 3 
Binary tree after insertion
4 2 5 1 6 3 7

二叉树操作

可以在二叉树上执行以下操作

插入：将新节点添加到树中。
删除：从树中删除一个节点。
遍历
1. 中序遍历：访问左子树，然后是当前节点，然后是右子树。
2. 前序遍历：访问当前节点，然后是左子树，然后是右子树。
3. 后序遍历：访问左子树，然后是右子树，然后是当前节点。
4. 层序遍历：从左到右逐层访问节点。
搜索：查找具有给定值的特定节点。

Java 程序在二叉树中插入节点

BinaryTreeInsert.java

public class BinaryTreeInsert 
{
    public static void main(String[] args) 
    {
        new BinaryTreeInsert().run();
    }
    static class Node 
    {
        Node left;
        Node right;
        int value;
        public Node(int value) 
        {
            this.value = value;
        }
    }
    public void run() 
    {
        Node rootnode = new Node(25);
        System.out.println("Building tree with root value " + rootnode.value);
        System.out.println("=================================");
        insert(rootnode, 11);
        insert(rootnode, 15);
        insert(rootnode, 16);
        insert(rootnode, 23);
        insert(rootnode, 79);
    }
    public void insert(Node node, int value) 
    {
        if (value < node.value) 
        {
            if (node.left != null) 
            {
                insert(node.left, value);
            } else 
            {
                System.out.println("  Inserted " + value + " to left of Node " + node.value);
                node.left = new Node(value);
            }
        } 
        else if (value > node.value) 
        {
            if (node.right != null) 
            {
                insert(node.right, value);
            } else 
            {
                System.out.println("  Inserted " + value + " to right of Node " + node.value);
                node.right = new Node(value);
            }
        }
    }
}

输出

Building tree with root value 25
=================================
  Inserted 11 to left of Node 25
  Inserted 15 to right of Node 11
  Inserted 16 to right of Node 15
  Inserted 23 to right of Node 16
  Inserted 79 to right of Node 25

Java 程序在 Java 中删除节点

算法

从根节点开始，找到二叉树中最深、最右的节点以及要删除的节点。
将最深、最右节点的*数据*替换为要删除的节点。
然后删除最深、最右的节点。

考虑下图。

DeleteNode.java

import java.util.LinkedList;
import java.util.Queue;
public class DeleteNode 
{
// A binary tree node has key, pointer to
// left child and a pointer to right child
static class Node
{
	int key;
	Node left, right;
	
	// Constructor
	Node(int key)
	{
		this.key = key;
		left = null;
		right = null;
	}
}
static Node root;
static Node temp = root;
// Inorder traversal of a binary tree
static void inorder(Node temp)
{
	if (temp == null)
		return;
	inorder(temp.left);
	System.out.print(temp.key + " ");
	inorder(temp.right);
}
// Function to delete deepest
// element in binary tree
static void deleteDeepest(Node root, Node delNode)
{
	Queue<Node> q = new LinkedList<Node>();
	q.add(root);
	Node temp = null;
	// Do level order traversal until last node
	while (!q.isEmpty())
	{
		temp = q.peek();
		q.remove();
		
		if (temp == delNode)
		{
			temp = null;
			return;
		}
		if (temp.right!=null)
		{
			if (temp.right == delNode)
			{
				temp.right = null;
				return;
		}
		else
			q.add(temp.right);
	}
	if (temp.left != null)
	{
		if (temp.left == delNode)
		{
			temp.left = null;
			return;
		}
		else
			q.add(temp.left);
	}
}
}
// Function to delete given element
// in binary tree
static void delete(Node root, int key)
{
	if (root == null)
		return;
		
	if (root.left == null &&
	root.right == null)
	{
		if (root.key == key)
		{
			root=null;
			return;
		}
		else
			return;
	}
	Queue<Node> q = new LinkedList<Node>();
	q.add(root);
	Node temp = null, keyNode = null;
	// Do level order traversal until
	// we find key and last node.
	while (!q.isEmpty())
	{
		temp = q.peek();
		q.remove();
		if (temp.key == key)
			keyNode = temp;
		if (temp.left != null)
			q.add(temp.left);
		if (temp.right != null)
			q.add(temp.right);
	}
	if (keyNode != null)
	{
		int x = temp.key;
		deleteDeepest(root, temp);
		keyNode.key = x;
	}
}
// Driver code
public static void main(String args[])
{
	root = new Node(10);
	root.left = new Node(11);
	root.left.left = new Node(7);
	root.left.right = new Node(12);
	root.right = new Node(9);
	root.right.left = new Node(15);
	root.right.right = new Node(8);
	System.out.print("Inorder traversal before deletion: ");
	inorder(root);
	//node to delete
	int key = 7;
	delete(root, key);
	System.out.print("\nInorder traversal after deletion: ");
	inorder(root);
}
}

输出

Inorder traversal before deletion: 7 11 12 10 15 9 8 
Inorder traversal after deletion: 8 11 12 10 15 9

Java 程序在二叉树中搜索节点

算法

定义 Node 类，该类包含三个属性：data、left 和 right。这里，left 表示节点的左子节点，right 表示节点的右子节点。
创建节点时，数据将传递到节点的 data 属性，left 和 right 都将设置为 null。
定义另一个类，该类有两个属性 root 和 flag。
1. Root 表示树的根节点，并将其初始化为 null。
2. Flag 将用于检查给定节点是否在树中。最初，它将设置为 false。

searchNode() 将在二叉树中搜索特定节点
- 它检查 root 是否为 null，这意味着树是空的。
- 如果树不为空，它将比较 temp 的数据与 value。如果它们相等，它将设置 flag 为 true 并返回。
- 通过递归调用 searchNode() 来遍历左子树，并检查 value 是否存在于左子树中。
- 通过递归调用 searchNode() 来遍历右子树，并检查 value 是否存在于右子树中。

SearchBinaryTree.java

public class SearchBinaryTree 
{  
      //Represent a node of binary tree  
      public static class Node
{  
        int data;  
        Node left;  
        Node right;  
        public Node(int data)
        {  
          //Assign data to the new node, set left and right children to null  
          this.data = data;  
          this.left = null;  
          this.right = null;  
        }  
      }  
      //Represent the root of binary tree  
      public Node root;  
      public static boolean flag = false;  
      public SearchBinaryTree()
      {  
        root = null;  
      }  
      //searchNode() will search for the particular node in the binary tree  
      public void searchNode(Node temp, int value)
      {  
        //Check whether tree is empty  
        if(root == null)
        {  
          System.out.println("Tree is empty");  
        }  
        else
        {  
          //If value is found in the given binary tree then, set the flag to true  
          if(temp.data == value)
          {  
            flag = true;  
               return;  
          }  
          //Search in left subtree  
          if(flag == false && temp.left != null)
          {  
          searchNode(temp.left, value);  
          }  
          //Search in right subtree  
          if(flag == false && temp.right != null)
          {  
          searchNode(temp.right, value);  
          }  
        }  
      }  
      public static void main(String[] args) 
      {  
        SearchBinaryTree bt = new SearchBinaryTree();  
        //Add nodes to the binary tree  
        bt.root = new Node(11);  
        bt.root.left = new Node(8);  
        bt.root.right = new Node(12);  
        bt.root.left.left = new Node(78);  
        bt.root.right.left = new Node(23);  
        bt.root.right.right = new Node(36);  
        //Search for node 5 in the binary tree  
           bt.searchNode(bt.root, 23);  
        if(flag)  
          System.out.println("Element is present in the binary tree.");  
        else  
          System.out.println("Element is not present in the binary tree.");  
      }  
    }  

输出

Element is present in the binary tree.

二叉树遍历

遍历顺序	第一次访问	第二次访问	第三次访问
中序	按中序遍历左子树	访问根节点	按中序遍历右子树
前序	访问根节点	按前序遍历左子树	按前序遍历右子树
后序	按后序遍历左子树	按后序遍历右子树	访问根节点

注意：除了上述三种遍历方式，还有一种遍历方式称为边界遍历。

Java 程序遍历中序、前序和后序遍历

BinaryTree.java

public class BinaryTree 
{
  // first node
  private Node root;
  BinaryTree()
  {
    root = null;
  }
  // Class representing tree nodes
  static class Node
  {
    int value;
    Node left;
    Node right;
    Node(int value)
    {
      this.value = value;
      left = null;
      right = null;        
    }
    public void displayData()
    {
      System.out.print(value + " ");
    }
  }
    
  public void insert(int i)
  {
    root = insert(root, i);
  }
  //Inserting node - recursive method
  public Node insert(Node node, int value)
  {
    if(node == null){
      return new Node(value);
    }
    // Move to the left if passed value is 
    // less than the current node
    if(value < node.value)
    {
      node.left = insert(node.left, value);
    }
    // Move to the right if passed value is 
    // greater than the current node
    else if(value > node.value)
    {
      node.right = insert(node.right, value);
    }
    return node;
  }
  // Search node in binary search tree
  public Node find(int searchedValue)
  {
    Node current = root;
    while(current.value != searchedValue)
    {
      if(searchedValue < current.value)
        // Move to the left if searched value is less
        current = current.left;
      else
        // Move to the right if searched value is >=
        current = current.right;
      if(current == null)
      {
        return null;
      }
    }
    return current;
  }
  // For traversing in order
  public void inOrder(Node node)
  {
    if(node != null)
    {
      inOrder(node.left);
      node.displayData();
      inOrder(node.right);
    }
  }
  // Preorder traversal
  public void preOrder(Node node)
  {
    if(node != null){
      node.displayData();
      preOrder(node.left);           
      preOrder(node.right);
    }
  }
  // Postorder traversal
  public void postOrder(Node node)
  {
    if(node != null)
    {
      postOrder(node.left);
      postOrder(node.right);
      node.displayData();          
    }
  }
  public static void main(String[] args) 
  {
    BinaryTree bst = new BinaryTree();
    bst.insert(34);
    bst.insert(56);
    bst.insert(12);
    bst.insert(89);
    bst.insert(67);
    bst.insert(90);
    System.out.println("Inorder traversal of binary tree");
    bst.inOrder(bst.root);
    System.out.println();
    System.out.println("Preorder traversal of binary tree");
    bst.preOrder(bst.root);
    System.out.println();
    System.out.println("Postorder traversal of binary tree");
    bst.postOrder(bst.root);
    System.out.println();
  }
}

输出

Inorder traversal of binary tree
12 34 56 67 89 90 
Preorder traversal of binary tree
34 12 56 89 67 90 
Postorder traversal of binary tree
12 67 90 89 56 34

除了上述操作，我们还可以执行查找最大节点、最小节点和所有节点之和等操作。

Java 程序查找二叉树中的最大节点

LargestNode.java

public class LargestNode 
{  
    //Represent the node of binary tree  
    public static class Node
    {  
        int data;  
        Node left;  
        Node right;  
        public Node(int data)
        {  
            //Assign data to the new node, set left and right children to null  
            this.data = data;  
            this.left = null;  
            this.right = null;  
        }  
     }  
      //Represent the root of binary tree  
      public Node root;  
      public LargestNode()
      {  
        root = null;  
      }  
      //largestElement() will find out the largest node in the binary tree  
      public int largestElement(Node temp)
      {  
          //Check whether tree is empty  
           if(root == null) 
           {  
               System.out.println("Tree is empty");  
               return 0;  
            }  
           else
           {  
               int leftMax, rightMax;  
               //Max will store temp's data  
               int max = temp.data;  
               //It will find largest element in left subtree  
               if(temp.left != null){  
                   leftMax = largestElement(temp.left);  
                   //Compare max with leftMax and store greater value into max  
                   max = Math.max(max, leftMax);  
                }  
                //It will find largest element in right subtree  
                if(temp.right != null){  
                    rightMax = largestElement(temp.right);  
                    //Compare max with rightMax and store greater value into max  
                    max = Math.max(max, rightMax);  
                }  
                return max;  
           }  
      }  
      public static void main(String[] args) 
      {  
        LargestNode bt = new LargestNode();  
        //Add nodes to the binary tree  
        bt.root = new Node(90);  
        bt.root.left = new Node(99);  
        bt.root.right = new Node(23);  
        bt.root.left.left = new Node(96);  
        bt.root.right.left = new Node(45);  
        bt.root.right.right = new Node(6);  
         bt.root.right.left = new Node(13);  
         bt.root.right.right = new Node(77);  
        //Display largest node in the binary tree  
        System.out.println("Largest element in the binary tree: " + bt.largestElement(bt.root));  
      }  
}  

输出

Largest element in the binary tree: 99

Java 程序查找二叉树中的最小节点

算法

定义 Node 类，该类包含三个属性：data、left 和 right。这里，left 表示节点的左子节点，right 表示节点的右子节点。
创建节点时，数据将传递到节点的 data 属性，left 和 right 都将设置为 null。
定义另一个类，该类有一个 root 属性。
1. Root 表示树的根节点，并将其初始化为 null。

smallestElement() 将查找二叉树中的最小节点
1. 它检查 root 是否为 null，这意味着树是空的。
2. 如果树不为空，则定义一个变量 min，该变量将存储 temp 的数据。
3. 通过递归调用 smallestElement() 来查找左子树中的最小节点。将该值存储在 leftMin 中。将 min 和 leftMin 的值进行比较，并将两者中的较小者存储到 min 中。
4. 通过递归调用 smallestElement() 来查找右子树中的最小节点。将该值存储在 rightMin 中。将 min 和 rightMin 的值进行比较，并将两者中的较小者存储到 min 中。
5. 最后，min 将包含二叉树中的最小节点。

SmallestNode.java

public class SmallestNode 
{  
      //Represent the node of binary tree  
      public static class Node
      {  
        int data;  
        Node left;  
        Node right;  
        public Node(int data)
        {  
            //Assign data to the new node, set left and right children to null  
            this.data = data;  
            this.left = null;  
            this.right = null;  
        }  
      }  
      //Represent the root of binary tree  
      public Node root;  
      public SmallestNode()
      {  
          root = null;  
      }  
      //smallestElement() will find out the smallest node in the binary tree  
      public int smallestElement(Node temp)
      {  
          //Check whether tree is empty  
          if(root == null) 
          {  
              System.out.println("Tree is empty");  
              return 0;  
          }  
          else 
          {  
                int leftMin, rightMin;  
                //Min will store temp's data  
                int min = temp.data;  
                //It will find smallest element in left subtree  
                if(temp.left != null)
                {  
                  leftMin = smallestElement(temp.left);  
                  //If min is greater than leftMin then store the value of leftMin into min  
                  min = Math.min(min, leftMin);  
                }  
                //It will find smallest element in right subtree  
                if(temp.right != null)
                {  
                  rightMin = smallestElement(temp.right);  
                  //If min is greater than rightMin then store the value of rightMin into min  
                  min = Math.min(min, rightMin);  
                }  
                return min;  
          }  
      }  
      public static void main(String[] args) {  
        SmallestNode bt = new SmallestNode();  
        //Add nodes to the binary tree  
        bt.root = new Node(9);  
        bt.root.left = new Node(5);  
        bt.root.right = new Node(7);  
        bt.root.left.left = new Node(1);  
        bt.root.right.left = new Node(2);  
        bt.root.right.right = new Node(8);  
        bt.root.right.left = new Node(4);  
        bt.root.right.right = new Node(3);  
        //Display smallest node in the binary tree  
        System.out.println("Smallest element in the binary tree: " + bt.smallestElement(bt.root));  
      }  
}  

输出

Smallest element in the binary tree: 1

Java 程序查找二叉树的最大宽度

算法

定义 Node 类，该类包含三个属性：data、left 和 right。这里，left 表示节点的左子节点，right 表示节点的右子节点。
创建节点时，数据将传递到节点的 data 属性，left 和 right 都将设置为 null。
定义另一个类，该类有一个 root 属性。
1. Root 表示树的根节点，并将其初始化为 null。
findMaximumWidth() 将查找给定二叉树的最大宽度
1. 变量 maxWidth 将存储任何层上存在的最大节点数。
2. 队列用于逐层遍历二叉树。
3. 它检查 root 是否为 null，这意味着树是空的。
4. 如果不是，则将根节点添加到队列。变量 nodesInLevel 用于跟踪每个层上的节点数。
5. 如果 nodesInLevel > 0，则从队列的前面移除节点，并将其左子节点和右子节点添加到队列中。在第一次迭代中，将移除节点 1，并将其子节点 2 和 3 添加到队列中。在第二次迭代中，将移除节点 2，其子节点 4 和 5 将添加到队列中，依此类推。
6. MaxWidth 将存储 max(maxWidth, nodesInLevel)。因此，在任何给定时间点，它将表示最大节点数。
7. 这将一直持续到遍历完树的所有层。

BinaryTree.java

import java.util.LinkedList;  
import java.util.Queue;  
   
public class BinaryTree 
{  
    //Represent the node of binary tree  
      public static class Node
      {  
        int data;  
        Node left;  
        Node right;  
        public Node(int data)
        {  
          //Assign data to the new node, set left and right children to null  
          this.data = data;  
          this.left = null;  
          this.right = null;  
        }  
      }  
      //Represent the root of binary tree  
      public Node root; 
      public BinaryTree()
      {  
        root = null;  
      }  
//findMaximumWidth() will find out the maximum width of the given binary tree  
      public int findMaximumWidth() 
      {  
          int maxWidth = 0;  
          //Variable nodesInLevel keep tracks of number of nodes in each level  
          int nodesInLevel = 0;  
          //queue will be used to keep track of nodes of tree level-wise  
          Queue<Node> queue = new LinkedList<Node>();  
          //Check if root is null, then width will be 0  
          if(root == null) {  
              System.out.println("Tree is empty");  
              return 0;  
          }  
          else 
          {  
              //Add root node to queue as it represents the first level  
              queue.add(root); 
              while(queue.size() != 0) 
              {  
                  //Variable nodesInLevel will hold the size of queue i.e. number of elements in queue  
                  nodesInLevel = queue.size();  
                  //maxWidth will hold maximum width.   
                  //If nodesInLevel is greater than maxWidth then, maxWidth will hold the value of nodesInLevel  
                  maxWidth = Math.max(maxWidth, nodesInLevel);  
                  //If variable nodesInLevel contains more than one node   
                  //then, for each node, we'll add left and right child of the node to the queue  
                  while(nodesInLevel > 0) 
                  {  
                     Node current = queue.remove();  
                     if(current.left != null)   
                         queue.add(current.left);  
                     if(current.right != null)   
                         queue.add(current.right);  
                     nodesInLevel--;  
                  }  
              }  
          }  
          return maxWidth;  
      }  
      public static void main(String[] args) 
      {  
          BinaryTree bt = new BinaryTree();  
          //Add nodes to the binary tree  
          bt.root = new Node(1);  
          bt.root.left = new Node(2);  
          bt.root.right = new Node(3);  
          bt.root.left.left = new Node(4);  
          bt.root.left.right = new Node(5);  
          bt.root.right.left = new Node(6);  
          bt.root.right.right = new Node(7);  
          bt.root.left.left.left = new Node(8);  
          //Display the maximum width of given tree  
          System.out.println("Maximum width of the binary tree: " + bt.findMaximumWidth());  
      }  
}  

输出

Maximum width of the binary tree: 4

查找二叉树的最大元素

查找二叉树的最大元素涉及递归地比较树节点中的值以确定最高值。它对于各种算法至关重要，有助于高效的搜索操作和理解树的结构。

BinaryTreeMaxElement.java

// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the maximum element in a binary tree
public class BinaryTreeMaxElement {
    // Method to find the maximum element in the binary tree
    public int findMax(TreeNode root) {
        // Base case: if the root is null, return the minimum possible value
        if (root == null)
            return Integer.MIN_VALUE;
        // Recursively find the maximum value in left and right subtrees
        int leftMax = findMax(root.left);   // Maximum value in the left subtree
        int rightMax = findMax(root.right); // Maximum value in the right subtree
        // Compare the root's value with the maximum values from left and right subtrees
        int max = Math.max(root.val, Math.max(leftMax, rightMax)); // Overall maximum value in the tree
        return max; // Return the maximum value found
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);         // Root node with value 1
        root.left = new TreeNode(3);             // Left child of root with value 3
        root.right = new TreeNode(2);            // Right child of root with value 2
        root.left.left = new TreeNode(4);       // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);      // Right child of node with value 3, value 5
        BinaryTreeMaxElement solution = new BinaryTreeMaxElement(); // Create an instance of BinaryTreeMaxElement
        int maxElement = solution.findMax(root); // Find the maximum element in the binary tree
        // Print the maximum element found
        System.out.println("Maximum element in the binary tree is: " + maxElement); // Output: 5
    }
}

输出

Maximum element in the binary tree is: 5

时间复杂度：O(n)

空间复杂度：O(n)

查找二叉树的高度

树的高度是一个基本指标，用于衡量从根到任何叶节点的*最长路径*的长度。它量化了树结构的深度，反映了其整体大小和复杂性。

BinaryTreeHeight.java

// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the height of a binary tree
public class BinaryTreeHeight {
    // Method to find the height of the binary tree
    public int findHeight(TreeNode root) {
        // Base case: if the root is null, the height is 0
        if (root == null)
            return 0;
        // Recursively find the height of the left and right subtrees
        int leftHeight = findHeight(root.left);    // Height of the left subtree
        int rightHeight = findHeight(root.right);  // Height of the right subtree
        // The height of the tree is the maximum of the heights of its left and right subtrees, plus 1
        int height = Math.max(leftHeight, rightHeight) + 1;
        return height; // Return the height of the tree
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        BinaryTreeHeight solution = new BinaryTreeHeight();  // Create an instance of BinaryTreeHeight
        int height = solution.findHeight(root);  // Find the height of the binary tree
        // Print the height of the tree
        System.out.println("Height of the binary tree is: " + height);  // Output: 3
    }
}

输出

Height of the binary tree is: 3

时间复杂度：O(n)，其中 n 是树中的节点数。

辅助空间复杂度：O(h)，其中 h 是树的高度。

查找二叉树的最深节点

查找树的最深节点涉及识别离根节点最远的节点。该节点位于树的最大深度处，并且没有子节点。

DeepestNodeInBinaryTree.java

import java.util.LinkedList;
import java.util.Queue;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the deepest node in a binary tree
public class DeepestNodeInBinaryTree {
    // Method to find the deepest node in the binary tree
    public TreeNode findDeepestNode(TreeNode root) {
        // Base case: if the root is null, return null
        if (root == null)
            return null;
        TreeNode deepestNode = null; // Initialize the variable to store the deepest node found
        Queue<TreeNode> queue = new LinkedList<>(); // Queue for level order traversal
        queue.offer(root); // Add the root node to the queue
        // Perform level order traversal
        while (!queue.isEmpty()) {
            deepestNode = queue.poll(); // Remove and retrieve the front of the queue
            // Add left child to the queue if it exists
            if (deepestNode.left != null)
                queue.offer(deepestNode.left);
            // Add right child to the queue if it exists
            if (deepestNode.right != null)
                queue.offer(deepestNode.right);
        }
        return deepestNode; // Return the deepest node found
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        DeepestNodeInBinaryTree solution = new DeepestNodeInBinaryTree();  // Create an instance of DeepestNodeInBinaryTree
        TreeNode deepestNode = solution.findDeepestNode(root);  // Find the deepest node in the binary tree
        // Print the deepest node found
        System.out.println("Deepest node in the binary tree is: " + deepestNode.val);  // Output: 4
    }
}

输出

Deepest node in the binary tree is: 5

时间复杂度：O(n)

辅助空间复杂度：O(w)

树的左视图

二叉树的左视图是指从左侧看树时可见的节点。它包括从根到最左叶节点的*每一层的第一个节点*。

LeftViewOfBinaryTree.java

import java.util.*;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the left view of a binary tree
public class LeftViewOfBinaryTree {
    // Method to get the left view of the binary tree
    public List<Integer> leftView(TreeNode root) {
        List<Integer> result = new ArrayList<>(); // List to store the left view nodes
        if (root == null)
            return result; // If the root is null, return an empty result list
        Queue<TreeNode> queue = new LinkedList<>(); // Queue for level order traversal
        queue.offer(root); // Add the root node to the queue
        // Perform level order traversal
        while (!queue.isEmpty()) {
            int levelSize = queue.size(); // Number of nodes at the current level
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll(); // Remove and retrieve the front of the queue
                // Add the first node of each level to the result
                if (i == 0) {
                    result.add(node.val);
                }
                // Add left child to the queue if it exists
                if (node.left != null) {
                    queue.offer(node.left);
                }
                // Add right child to the queue if it exists
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return result; // Return the left view of the binary tree
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5        LeftViewOfBinaryTree solution = new LeftViewOfBinaryTree();  // Create an instance of LeftViewOfBinaryTree
        List<Integer> leftView = solution.leftView(root);  // Get the left view of the binary tree
        // Print the left view of the tree
        System.out.println("Left view of the binary tree is: " + leftView);  // Output: [1, 3, 4]
    }
}

输出

Left view of the binary tree is: [1, 3, 4]

时间复杂度：O(n)（线性，其中 n 是二叉树中的节点数）

辅助空间复杂度：O(m)，其中 m 是二叉树中任何层的*最大节点数*。

二叉树的右视图

二叉树的右视图是指从右侧看树时*可见的节点集合*。它包括*每一层的最顶端节点*，使我们能够看到*每一层*的*最右侧节点*。

RightViewOfBinaryTree.java

import java.util.*;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the right view of a binary tree
public class RightViewOfBinaryTree {
    // Method to get the right view of the binary tree
    public List<Integer> rightView(TreeNode root) {
        List<Integer> result = new ArrayList<>(); // List to store the right view nodes
        if (root == null)
            return result; // If the root is null, return an empty result list
        Queue<TreeNode> queue = new LinkedList<>(); // Queue for level order traversal
        queue.offer(root); // Add the root node to the queue
        // Perform level order traversal
        while (!queue.isEmpty()) {
            int levelSize = queue.size(); // Number of nodes at the current level
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll(); // Remove and retrieve the front of the queue
                // Add the last node of each level to the result
                if (i == levelSize - 1) {
                    result.add(node.val);
                }
                // Add left child to the queue if it exists
                if (node.left != null) {
                    queue.offer(node.left);
                }
                // Add right child to the queue if it exists
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return result; // Return the right view of the binary tree
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        RightViewOfBinaryTree solution = new RightViewOfBinaryTree();  // Create an instance of RightViewOfBinaryTree
        List<Integer> rightView = solution.rightView(root);  // Get the right view of the binary tree
        // Print the right view of the tree
        System.out.println("Right view of the binary tree is: " + rightView);  // Output: [1, 2, 5]
    }
}

输出

Right view of the binary tree is: [1, 2, 5]

时间复杂度：O(n)，其中 n 是二叉树中的节点数。

辅助空间复杂度：O(m)，其中 m 是二叉树中*任何层*的*最大节点数*。

二叉树的顶视图

二叉树的顶视图是指从*上方*看树时*可见的节点*。它包括在*每个垂直层*上*最先遇到*的节点，从根开始。

TopViewOfBinaryTree.java

import java.util.*;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the top view of a binary tree
public class TopViewOfBinaryTree {
    // Inner class to store node with its horizontal distance
    class NodeWithHD {
        TreeNode node;
        int hd; // Horizontal distance from the root
        NodeWithHD(TreeNode node, int hd) {
            this.node = node;
            this.hd = hd;
        }
    }
    // Method to get the top view of the binary tree
    public List<Integer> topView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result; // If the root is null, return an empty result list
        }
        Map<Integer, Integer> topViewMap = new TreeMap<>(); // To store the first node at each horizontal distance
        Queue<NodeWithHD> queue = new LinkedList<>(); // Queue for level order traversal
        queue.offer(new NodeWithHD(root, 0)); // Add the root node with horizontal distance 0
        // Perform level order traversal
        while (!queue.isEmpty()) {
            NodeWithHD temp = queue.poll(); // Remove and retrieve the front of the queue
            int hd = temp.hd;
            TreeNode node = temp.node;
            // If the horizontal distance is not already present in the map, add it
            if (!topViewMap.containsKey(hd)) {
                topViewMap.put(hd, node.val);
            }
            // Add left child to the queue with horizontal distance hd-1
            if (node.left != null) {
                queue.offer(new NodeWithHD(node.left, hd - 1));
            }
            // Add right child to the queue with horizontal distance hd+1
            if (node.right != null) {
                queue.offer(new NodeWithHD(node.right, hd + 1));
            }
        }
        // Extract the top view nodes from the map
        for (Map.Entry<Integer, Integer> entry : topViewMap.entrySet()) {
            result.add(entry.getValue());
        }
        return result; // Return the top view of the binary tree
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        TopViewOfBinaryTree solution = new TopViewOfBinaryTree();  // Create an instance of TopViewOfBinaryTree
        List<Integer> topView = solution.topView(root);  // Get the top view of the binary tree
        // Print the top view of the tree
        System.out.println("Top view of the binary tree is: " + topView);  // Output: [4, 3, 1, 2]
    }
}

输出

Top view of the binary tree is: [4, 3, 1, 2]

时间复杂度：O(N)

辅助空间复杂度：O(N)

树的底视图

二叉树的底视图是指从*底部*向上看树时*可见的节点*。它显示*树的最低层节点*，同时考虑它们与根的*水平距离*。

BottomViewOfBinaryTree.java

import java.util.*;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the bottom view of a binary tree
public class BottomViewOfBinaryTree {
    // Inner class to store node with its horizontal distance
    class NodeWithHD {
        TreeNode node;
        int hd; // Horizontal distance from the root
        NodeWithHD(TreeNode node, int hd) {
            this.node = node;
            this.hd = hd;
        }
    }
    // Method to get the bottom view of the binary tree
    public List<Integer> bottomView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result; // If the root is null, return an empty result list
        }
        Map<Integer, Integer> bottomViewMap = new TreeMap<>(); // To store the last node at each horizontal distance
        Queue<NodeWithHD> queue = new LinkedList<>(); // Queue for level order traversal
        queue.offer(new NodeWithHD(root, 0)); // Add the root node with horizontal distance 0
        // Perform level order traversal
        while (!queue.isEmpty()) {
            NodeWithHD temp = queue.poll(); // Remove and retrieve the front of the queue
            int hd = temp.hd;
            TreeNode node = temp.node;
            // Update the node value at each horizontal distance
            bottomViewMap.put(hd, node.val);
            // Add left child to the queue with horizontal distance hd-1
            if (node.left != null) {
                queue.offer(new NodeWithHD(node.left, hd - 1));
            }
            // Add right child to the queue with horizontal distance hd+1
            if (node.right != null) {
                queue.offer(new NodeWithHD(node.right, hd + 1));
            }
        }
        // Extract the bottom view nodes from the map
        for (Map.Entry<Integer, Integer> entry : bottomViewMap.entrySet()) {
            result.add(entry.getValue());
        }
        return result; // Return the bottom view of the binary tree
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        BottomViewOfBinaryTree solution = new BottomViewOfBinaryTree();  // Create an instance of BottomViewOfBinaryTree
        List<Integer> bottomView = solution.bottomView(root);  // Get the bottom view of the binary tree
        // Print the bottom view of the tree
        System.out.println("Bottom view of the binary tree is: " + bottomView);  // Output: [4, 3, 5, 2]
    }
}

输出

Bottom view of the binary tree is: [4, 3, 5, 2]

时间复杂度：O(N)

辅助空间复杂度：O(N)

树的镜像

树的镜像，也称为镜像树或反转树，是通过*交换原始树中每个节点的左右子节点*而形成的二叉树。这种变换会产生一个*结构沿垂直轴反转*的树，其中*每个节点的子节点都被镜像*。

MirrorImageOfBinaryTree.java

// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the mirror image of a binary tree
public class MirrorImageOfBinaryTree {
    // Method to find the mirror image of the binary tree
    public TreeNode mirrorTree(TreeNode root) {
        if (root == null) {
            return null; // Base case: if root is null, return null
        }
        // Swap left and right subtrees recursively
        TreeNode temp = root.left;
        root.left = mirrorTree(root.right);
        root.right = mirrorTree(temp);
        return root;
    }
    // Method to print the tree using inorder traversal (for verification)
    public void printInorder(TreeNode root) {
        if (root != null) {
            printInorder(root.left);
            System.out.print(root.val + " ");
            printInorder(root.right);
        }
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        MirrorImageOfBinaryTree solution = new MirrorImageOfBinaryTree();  // Create an instance of MirrorImageOfBinaryTree
        System.out.println("Original tree:");
        solution.printInorder(root);  // Print the inorder traversal of the original tree
        System.out.println();
        TreeNode mirrorRoot = solution.mirrorTree(root);  // Get the mirror image of the binary tree
        System.out.println("Mirror image of the tree:");
        solution.printInorder(mirrorRoot);  // Print the inorder traversal of the mirror image tree
        System.out.println();
    }
}

输出

Original tree:
4 3 5 1 2 
Mirror image of the tree:
2 1 5 3 4

时间复杂度：O(n)

辅助空间复杂度：O(h)

序列化二叉树

树的序列化涉及将二叉树*转换为可以存储或传输并稍后重建的格式*，同时*保留其结构*。此过程通常使用*遍历方法*（例如前序遍历），并*包含 null 节点的标记*。下面是一个实现此方法的 Java 程序。

SerializeDeserializeBinaryTree.java

import java.util.*;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to serialize and deserialize a binary tree
public class SerializeDeserializeBinaryTree {
    // Serialize a tree to a string
    public String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        serializeHelper(root, sb);
        return sb.toString();
    }
    // Helper function to serialize the tree
    private void serializeHelper(TreeNode root, StringBuilder sb) {
        if (root == null) {
            sb.append("null").append(" "); // Use "null" to represent null nodes
            return;
        }
        sb.append(root.val).append(" "); // Append the value of the node
        serializeHelper(root.left, sb);  // Recursively serialize the left subtree
        serializeHelper(root.right, sb); // Recursively serialize the right subtree
    }
    // Deserialize a string to a tree
    public TreeNode deserialize(String data) {
        if (data == null || data.isEmpty()) {
            return null;
        }
        Queue<String> nodes = new LinkedList<>();
        nodes.addAll(Arrays.asList(data.split(" ")));
        return deserializeHelper(nodes);
    }
    // Helper function to deserialize the tree
    private TreeNode deserializeHelper(Queue<String> nodes) {
        String val = nodes.poll();
        if (val.equals("null")) {
            return null;
        }
        TreeNode node = new TreeNode(Integer.parseInt(val));
        node.left = deserializeHelper(nodes);
        node.right = deserializeHelper(nodes);
        return node;
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        SerializeDeserializeBinaryTree solution = new SerializeDeserializeBinaryTree();  // Create an instance of SerializeDeserializeBinaryTree
        // Serialize the binary tree
        String serializedString = solution.serialize(root);
        System.out.println("Serialized tree: " + serializedString);
        // Deserialize the serialized string
        TreeNode deserializedRoot = solution.deserialize(serializedString);
        // Print the inorder traversal of the deserialized tree to verify
        System.out.print("Inorder traversal of deserialized tree: ");
        solution.printInorder(deserializedRoot);
        System.out.println();
    }
    // Method to print the tree using inorder traversal (for verification)
    public void printInorder(TreeNode root) {
        if (root != null) {
            printInorder(root.left);
            System.out.print(root.val + " ");
            printInorder(root.right);
        }
    }
}

输出

Serialized tree: 1 3 4 null null 5 null null 2 null null 
Inorder traversal of deserialized tree: 4 3 5 1 2

时间复杂度：O(n)，其中 n 是二叉树中的节点数。

辅助空间：O(n)，其中 n 是二叉树中的节点数。

二叉树的应用

搜索算法：二叉搜索树（BST）支持高效的搜索操作。搜索特定元素可以在 O(log n) 的时间复杂度内完成，其中 n 是节点数，这比在未排序数据中进行*线性搜索*更快。
排序算法：二叉树是高效排序算法（如二叉搜索树排序和堆排序）的基础。这些算法利用树的结构来组织数据并有效地执行排序操作。
数据库系统：二叉树用于数据库系统中存储和管理数据。每个节点代表一个记录，允许高效的搜索操作和处理大型数据集。B 树及其变体通常用于数据库中的索引。
文件系统：二叉树可用于实现文件系统，其中每个节点代表一个目录或文件。这种结构允许在文件系统中进行高效的导航、组织和搜索。
压缩算法：霍夫曼编码是一种流行的压缩算法，它使用二叉树根据字符在输入数据中的频率为其分配可变长度的代码。这通过减小整体大小来实现有效的数据压缩。
决策树：在机器学习中，决策树用于分类和回归分析。每个节点代表基于属性的决策，树的结构有助于通过从根到叶节点的遍历来做出预测。
游戏 AI：二叉树在游戏 AI 中用于表示游戏中的可能走法。AI 算法搜索树来评估和选择最佳可能走法，从而提高像国际象棋或井字游戏这样的游戏的决策过程。

二叉树的优点

高效搜索：二叉树支持高效的搜索操作，因为每个节点最多有两个子节点，可以使用*二分搜索算法*。这使得搜索操作的时间复杂度为 O(log n)。
有序遍历：二叉树的结构支持各种遍历方法，例如中序、前序和后序遍历。这允许按特定顺序对节点执行操作，例如按*排序顺序*打印节点。
内存效率：与其他树结构相比，二叉树在内存效率方面相对较高，因为每个节点只需要两个指针。这使得它们适合在内存中存储大量数据，同时保持高效的搜索操作。
快速插入和删除：二叉树支持时间复杂度为 O(log n) 的插入和删除操作。这使得它们成为数据库系统等应用程序中使用的动态数据结构的理想选择。
易于实现：二叉树易于实现和理解，使其成为各种应用程序的流行选择。
有效的排序：二叉树可用于实现高效的排序算法，例如堆排序和二叉搜索树排序。

二叉树的缺点

结构受限：二叉树仅限于每个节点有两个子节点，这可能不适用于需要*超过两个子节点*的应用程序。在这种情况下，不同的树结构可能更合适。
不平衡树：不平衡二叉树，其中一个子树比另一个大得多，可能导致*低效的搜索操作*。如果树没有正确平衡或数据以非随机顺序插入，则可能发生这种情况。
空间效率低下：由于每个节点需要两个子指针，与*其他数据结构*相比，二叉树可能*空间效率低下*，对于大型树来说会导致显著的内存开销。
最坏情况下的性能缓慢：在最坏的情况下，二叉树可能变得*退化*，类似于*链表*，其中每个节点只有一个子节点。在这种情况下，搜索操作会*下降到 O(n) 的时间复杂度*。
复杂的平衡算法：维护平衡二叉树通常需要*复杂的算法*，例如 AVL 树和红黑树中使用的算法。这些平衡机制可能*难以实现*并且会增加*额外的开销*，使其不太适合某些应用程序。

下一个主题查找-最接近目标-的神秘函数-的值-在-java

Java 二叉树

二叉树

二叉树示例

二叉树的类型

Java 中的二叉树实现

使用 LinkedList 实现二叉树

算法

二叉树操作

Java 程序在二叉树中插入节点

Java 程序在 Java 中删除节点

算法

Java 程序在二叉树中搜索节点

算法

二叉树遍历

注意：除了上述三种遍历方式，还有一种遍历方式称为边界遍历。

Java 程序遍历中序、前序和后序遍历

Java 程序查找二叉树中的最大节点

Java 程序查找二叉树中的最小节点

算法

Java 程序查找二叉树的最大宽度

算法

查找二叉树的最大元素

查找二叉树的高度

查找二叉树的最深节点

树的左视图

二叉树的右视图

二叉树的顶视图

树的底视图

树的镜像

序列化二叉树

二叉树的应用

二叉树的优点

二叉树的缺点

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 二叉树

二叉树

二叉树示例

二叉树的类型

Java 中的二叉树实现

使用 LinkedList 实现二叉树

算法

二叉树操作

Java 程序在二叉树中插入节点

Java 程序在 Java 中删除节点

算法

Java 程序在二叉树中搜索节点

算法

二叉树遍历

注意：除了上述三种遍历方式，还有一种遍历方式称为边界遍历。

Java 程序遍历中序、前序和后序遍历

Java 程序查找二叉树中的最大节点

Java 程序查找二叉树中的最小节点

算法

Java 程序查找二叉树的最大宽度

算法

查找二叉树的最大元素

查找二叉树的高度

查找二叉树的*最深*节点

树的*左视图*

二叉树的*右视图*

二叉树的*顶视图*

树的*底视图*

树的*镜像*

序列化二叉树

二叉树的应用

二叉树的优点

二叉树的缺点

相关帖子

Java 中从第一个节点到最后一个节点的受限路径数量

Java 中的串行通信

flatMap() Method in Java 8

Java Spring vs. Struts

DoubleBuffer flip() methods in Java with Examples

No Main Manifest Attribute

Java vs Kotlin

Java 中将 List 转换为 Stream 的程序

Java 中的静态多态

MVC Architecture in Java

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器

查找二叉树的最深节点

树的左视图

二叉树的右视图

二叉树的顶视图

树的底视图

树的镜像