数据结构

zsxxn

Java编程泛型类BinaryTree（二叉树），BinaryTree的基本功能设计要求：构建二叉树、前序遍历、中序遍历、后序遍历、层序遍历、获取总结点个数、获取叶子结点个数、获取第n层结点个数、获取二叉树的深度、插入指定元素结点、删除指定元素结点、查找指定元素结点。

isdkz

1. import java.util.LinkedList;
   
2. import java.util.Queue;
   
3. 
   
4. public class BinaryTree<T> {
   
5.     private TreeNode<T> root;
   
6. 
   
7.     // 构建二叉树
   
8.     public void buildTree(T[] values) {
   
9.         if (values == null || values.length == 0) {
   
10.             return;
    
11.         }
    
12.         root = buildTree(values, 0);
    
13.     }
    
14. 
    
15.     private TreeNode<T> buildTree(T[] values, int index) {
    
16.         if (index < values.length) {
    
17.             TreeNode<T> node = new TreeNode<>(values[index]);
    
18.             node.left = buildTree(values, 2 * index + 1);
    
19.             node.right = buildTree(values, 2 * index + 2);
    
20.             return node;
    
21.         }
    
22.         return null;
    
23.     }
    
24. 
    
25.     // 前序遍历
    
26.     public void preOrderTraversal() {
    
27.         preOrderTraversal(root);
    
28.     }
    
29. 
    
30.     private void preOrderTraversal(TreeNode<T> node) {
    
31.         if (node != null) {
    
32.             System.out.print(node.value + " ");
    
33.             preOrderTraversal(node.left);
    
34.             preOrderTraversal(node.right);
    
35.         }
    
36.     }
    
37. 
    
38.     // 中序遍历
    
39.     public void inOrderTraversal() {
    
40.         inOrderTraversal(root);
    
41.     }
    
42. 
    
43.     private void inOrderTraversal(TreeNode<T> node) {
    
44.         if (node != null) {
    
45.             inOrderTraversal(node.left);
    
46.             System.out.print(node.value + " ");
    
47.             inOrderTraversal(node.right);
    
48.         }
    
49.     }
    
50. 
    
51.     // 后序遍历
    
52.     public void postOrderTraversal() {
    
53.         postOrderTraversal(root);
    
54.     }
    
55. 
    
56.     private void postOrderTraversal(TreeNode<T> node) {
    
57.         if (node != null) {
    
58.             postOrderTraversal(node.left);
    
59.             postOrderTraversal(node.right);
    
60.             System.out.print(node.value + " ");
    
61.         }
    
62.     }
    
63. 
    
64.     // 层序遍历
    
65.     public void levelOrderTraversal() {
    
66.         if (root == null) {
    
67.             return;
    
68.         }
    
69.         Queue<TreeNode<T>> queue = new LinkedList<>();
    
70.         queue.offer(root);
    
71.         while (!queue.isEmpty()) {
    
72.             TreeNode<T> node = queue.poll();
    
73.             System.out.print(node.value + " ");
    
74.             if (node.left != null) {
    
75.                 queue.offer(node.left);
    
76.             }
    
77.             if (node.right != null) {
    
78.                 queue.offer(node.right);
    
79.             }
    
80.         }
    
81.     }
    
82. 
    
83.     // 获取总结点个数
    
84.     public int getNodeCount() {
    
85.         return getNodeCount(root);
    
86.     }
    
87. 
    
88.     private int getNodeCount(TreeNode<T> node) {
    
89.         if (node == null) {
    
90.             return 0;
    
91.         }
    
92.         return 1 + getNodeCount(node.left) + getNodeCount(node.right);
    
93.     }
    
94. 
    
95.     // 获取叶子结点个数
    
96.     public int getLeafNodeCount() {
    
97.         return getLeafNodeCount(root);
    
98.     }
    
99. 
    
100.     private int getLeafNodeCount(TreeNode<T> node) {
     
101.         if (node == null) {
     
102.             return 0;
     
103.         }
     
104.         if (node.left == null && node.right == null) {
     
105.             return 1;
     
106.         }
     
107.         return getLeafNodeCount(node.left) + getLeafNodeCount(node.right);
     
108.     }
     
109. 
     
110.     // 获取第n层结点个数
     
111.     public int getNodeCountAtLevel(int level) {
     
112.         return getNodeCountAtLevel(root, level);
     
113.     }
     
114. 
     
115.     private int getNodeCountAtLevel(TreeNode<T> node, int level) {
     
116.         if (node == null || level < 1) {
     
117.             return 0;
     
118.         }
     
119.         if (level == 1) {
     
120.             return 1;
     
121.         }
     
122.         return getNodeCountAtLevel(node.left, level - 1) + getNodeCountAtLevel(node.right, level - 1);
     
123.     }
     
124. 
     
125.     // 获取二叉树的深度
     
126.     public int getDepth() {
     
127.         return getDepth(root);
     
128.     }
     
129. 
     
130.     private int getDepth(TreeNode<T> node) {
     
131.         if (node == null) {
     
132.             return 0;
     
133.         }
     
134.         int leftDepth = getDepth(node.left);
     
135.         int rightDepth = getDepth(node.right);
     
136.         return 1 + Math.max(leftDepth, rightDepth);
     
137.     }
     
138. 
     
139.     // 插入指定元素结点
     
140.     public void insertNode(T value) {
     
141.         if (root == null) {
     
142.             root = new TreeNode<>(value);
     
143.         } else {
     
144.             insertNode(root, value);
     
145.         }
     
146.     }
     
147. 
     
148.     private void insertNode(TreeNode<T> node, T value) {
     
149.         if (node.left == null) {
     
150.             node.left = new TreeNode<>(value);
     
151.         } else if (node.right == null) {
     
152.             node.right = new TreeNode<>(value);
     
153.         } else {
     
154.             insertNode(node.left, value);
     
155.         }
     
156.     }
     
157. 
     
158.     // 删除指定元素结点
     
159.     public void deleteNode(T value) {
     
160.         if (root == null) {
     
161.             return;
     
162.         }
     
163.         if (root.value.equals(value)) {
     
164.             root = null;
     
165.         } else {
     
166.             deleteNode(root, value);
     
167.         }
     
168.     }
     
169. 
     
170.     private void deleteNode(TreeNode<T> node, T value) {
     
171.         if (node == null) {
     
172.             return;
     
173.         }
     
174.         if (node.left != null && node.left.value.equals(value)) {
     
175.             node.left = null;
     
176.         } else if (node.right != null && node.right.value.equals(value)) {
     
177.             node.right = null;
     
178.         } else {
     
179.             deleteNode(node.left, value);
     
180.             deleteNode(node.right, value);
     
181.         }
     
182.     }
     
183. 
     
184.     // 查找指定元素结点
     
185.     public boolean searchNode(T value) {
     
186.         return searchNode(root, value);
     
187.     }
     
188. 
     
189.     private boolean searchNode(TreeNode<T> node, T value) {
     
190.         if (node == null) {
     
191.             return false;
     
192.         }
     
193.         if (node.value.equals(value)) {
     
194.             return true;
     
195.         }
     
196.         return searchNode(node.left, value) || searchNode(node.right, value);
     
197.     }
     
198. 
     
199.     private static class TreeNode<T> {
     
200.         T value;
     
201.         TreeNode<T> left;
     
202.         TreeNode<T> right;
     
203. 
     
204.         TreeNode(T value) {
     
205.             this.value = value;
     
206.             this.left = null;
     
207.             this.right = null;
     
208.         }
     
209.     }
     
210. }
     

复制代码

Mike_python小

[/code]java
import java.util.LinkedList;
import java.util.Queue;

public class TreeNode<T> {
    T val;
    TreeNode<T> left;
    TreeNode<T> right;

    public TreeNode(T val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

public class BinaryTree<T> {
    private TreeNode<T> root;

    public void insert(T value) {
        if (root == null) {
            root = new TreeNode<>(value);
        } else {
            insert(root, value);
        }
    }

    private void insert(TreeNode<T> node, T value) {
        Queue<TreeNode<T>> queue = new LinkedList<>();
        queue.add(node);
        
        while (!queue.isEmpty()) {
            TreeNode<T> current = queue.poll();
            if (current.left == null) {
                current.left = new TreeNode<>(value);
                break;
            } else {
                queue.add(current.left);
            }
            
            if (current.right == null) {
                current.right = new TreeNode<>(value);
                break;
            } else {
                queue.add(current.right);
            }
        }
    }

    public void delete(T value) {
        // 实现删除指定元素结点的逻辑
    }

    public TreeNode<T> find(T value) {
        return find(root, value);
    }

    private TreeNode<T> find(TreeNode<T> node, T value) {
        if (node == null || node.val.equals(value)) {
            return node;
        }
        
        TreeNode<T> left = find(node.left, value);
        if (left != null) {
            return left;
        }
        
        TreeNode<T> right = find(node.right, value);
        return right;
    }

    // 其他方法实现略...

    // 获取总结点个数
    public int getNodeCount() {
        return getNodeCount(root);
    }

    private int getNodeCount(TreeNode<T> node) {
        if (node == null) {
            return 0;
        }
        return 1 + getNodeCount(node.left) + getNodeCount(node.right);
    }

    // 获取叶子结点个数
    public int getLeafNodeCount() {
        return getLeafNodeCount(root);
    }

    private int getLeafNodeCount(TreeNode<T> node) {
        if (node == null) {
            return 0;
        }
        if (node.left == null && node.right == null) {
            return 1;
        }
        return getLeafNodeCount(node.left) + getLeafNodeCount(node.right);
    }

    // 获取第n层结点个数
    public int getNodeCountAtLevel(int level) {
        return getNodeCountAtLevel(root, level);
    }

    private int getNodeCountAtLevel(TreeNode<T> node, int level) {
        if (node == null || level < 1) {
            return 0;
        }
        if (level == 1) {
            return 1;
        }
        return getNodeCountAtLevel(node.left, level - 1) + getNodeCountAtLevel(node.right, level - 1);
    }

    // 获取二叉树的深度
    public int getDepth() {
        return getDepth(root);
    }

    private int getDepth(TreeNode<T> node) {
        if (node == null) {
            return 0;
        }
        int leftDepth = getDepth(node.left);
        int rightDepth = getDepth(node.right);
        return Math.max(leftDepth, rightDepth) + 1;
    }

    // 前序遍历
    public void preOrderTraversal() {
        preOrderTraversal(root);
        System.out.println(); // 换行
    }

    private void preOrderTraversal(TreeNode<T> node) {
        if (node != null) {
            System.out.print(node.val + " ");
            preOrderTraversal(node.left);
            preOrderTraversal(node.right);
        }
    }

    // 中序遍历
    public void inOrderTraversal() {
        inOrderTraversal(root);
        System.out.println(); // 换行
    }

    private void inOrderTraversal(TreeNode<T> node) {
        if (node != null) {
            inOrderTraversal(node.left);
            System.out.print(node.val + " ");
            inOrderTraversal(node.right);
        }
    }

    // 后序遍历
    public void postOrderTraversal() {
        postOrderTraversal(root);
        System.out.println(); // 换行
    }

    private void postOrderTraversal(TreeNode<T> node) {
        if (node != null) {
            postOrderTraversal(node.left);
            postOrderTraversal(node.right);
            System.out.print(node.val + " ");
        }
    }

    // 层序遍历
    public void levelOrderTraversal() {
        Queue<TreeNode<T>> queue = new LinkedList<>();
        if (root != null) {
            queue.add(root);
        }

        while (!queue.isEmpty()) {
            TreeNode<T> node = queue.poll();
            System.out.print(node.val + " ");
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
        System.out.println(); // 换行
    }
}
[/code]

这个BinaryTree类实现了二叉树的基本功能，包括构建二叉树、前序遍历、中序遍历、后序遍历、层序遍历、获取总结点个数、获取叶子结点个数、获取第n层结点个数、获取二叉树的深度、插入指定元素结点、删除指定元素结点、查找指定元素结点等。希望这个例子能够帮助你完成Java编程中泛型类BinaryTree的基本功能设计。

liuhongrun2022

在Java中，实现一个二叉树类（BinaryTree）需要定义一个内部类（TreeNode）来表示树的节点。每个TreeNode对象有一个元素以及两个指向子节点的引用（左子节点和右子节点）。以下是一个基本的实现，包含了包含了构建二叉树、前序遍历、中序遍历、后序遍历、层序遍历、获取总结点个数、获取叶子结点个数、获取第n层结点个数、获取二叉树的深度、插入指定元素结点、删除指定元素结点和查找指定元素结点的功能。

1. import java.util.*;
3. public class BinaryTree<T> {
4.     private TreeNode<T> root;
6.     private static class TreeNode<T> {
7.         T data;
8.         TreeNode<T> left;
9.         TreeNode<T> right;
11.         TreeNode(T data) {
12.             this.data = data;
13.         }
14.     }
16.     public BinaryTree() {
17.         root = null;
18.     }
20.     // 根据需要自行实现构建二叉树的方法，例如通过数组构建
22.     // 前序遍历
23.     public void preOrderTraversal(TreeNode<T> node) {
24.         if (node == null) return;
25.         System.out.println(node.data);
26.         preOrderTraversal(node.left);
27.         preOrderTraversal(node.right);
28.     }
30.     // 中序遍历
31.     public void inOrderTraversal(TreeNode<T> node) {
32.         if (node == null) return;
33.         inOrderTraversal(node.left);
34.         System.out.println(node.data);
35.         inOrderTraversal(node.right);
36.     }
38.     // 后序遍历
39.     public void postOrderTraversal(TreeNode<T> node) {
40.         if (node == null) return;
41.         postOrderTraversal(node.left);
42.         postOrderTraversal(node.right);
43.         System.out.println(node.data);
44.     }
46.     // 层序遍历
47.     public void levelOrderTraversal(TreeNode<T> node) {
48.         Queue<TreeNode<T>> queue = new LinkedList<>();
49.         queue.add(node);
51.         while(!queue.isEmpty()) {
52.             TreeNode<T> curr = queue.poll();
53.             System.out.println(curr.data);
55.             if(curr.left != null) queue.add(curr.left);
56.             if(curr.right != null) queue.add(curr.right);
57.         }
58.     }
60.     // 获取总节点个数
61.     // 获取叶子节点个数
62.     // 获取第n层节点个数
63.     // 获取二叉树的深度
64.     // 插入指定元素节点
65.     // 删除指定元素节点
66.     // 查找指定元素节点
67.     // 以上功能根据需要自行实现
68. }

复制代码

本示例只包含了基本的遍历功能，其它的功能如获取总节点个数、获取叶子节点个数、获取第n层节点个数、获取二叉树的深度、插入指定元素节点、删除指定元素节点和查找指定元素节点需要你根据具体需求进行实现。