java实现二叉树
1 import java.util.ArrayList; 2 import java.util.List; 3 4 public class BinarySearchTree { 5 6 // 树的根结点 7 private TreeNode root = null; 8 9 // 遍历结点列表 10 private List<TreeNode> nodelist = new ArrayList<TreeNode>(); 11 12 private class TreeNode { 13 14 private int key; 15 private TreeNode leftChild; 16 private TreeNode rightChild; 17 private TreeNode parent; 18 19 public TreeNode(int key, TreeNode leftChild, TreeNode rightChild, 20 TreeNode parent) { 21 this.key = key; 22 this.leftChild = leftChild; 23 this.rightChild = rightChild; 24 this.parent = parent; 25 } 26 27 public int getKey() { 28 return key; 29 } 30 31 public String toString() { 32 String leftkey = (leftChild == null ? "" : String 33 .valueOf(leftChild.key)); 34 String rightkey = (rightChild == null ? "" : String 35 .valueOf(rightChild.key)); 36 return "(" + leftkey + " , " + key + " , " + rightkey + ")"; 37 } 38 39 } 40 41 /** 42 * isEmpty: 判断二叉查找树是否为空;若为空,返回 true ,否则返回 false . 43 * 44 */ 45 public boolean isEmpty() { 46 if (root == null) { 47 return true; 48 } else { 49 return false; 50 } 51 } 52 53 /** 54 * TreeEmpty: 对于某些二叉查找树操作(比如删除关键字)来说,若树为空,则抛出异常。 55 */ 56 public void TreeEmpty() throws Exception { 57 if (isEmpty()) { 58 throw new Exception("树为空!"); 59 } 60 } 61 62 /** 63 * search: 在二叉查找树中查询给定关键字 64 * 65 * @param key 66 * 给定关键字 67 * @return 匹配给定关键字的树结点 68 */ 69 public TreeNode search(int key) { 70 TreeNode pNode = root; 71 while (pNode != null && pNode.key != key) { 72 if (key < pNode.key) { 73 pNode = pNode.leftChild; 74 } else { 75 pNode = pNode.rightChild; 76 } 77 } 78 return pNode; 79 } 80 81 /** 82 * minElemNode: 获取二叉查找树中的最小关键字结点 83 * 84 * @return 二叉查找树的最小关键字结点 85 * @throws Exception 86 * 若树为空,则抛出异常 87 */ 88 public TreeNode minElemNode(TreeNode node) throws Exception { 89 if (node == null) { 90 throw new Exception("树为空!"); 91 } 92 TreeNode pNode = node; 93 while (pNode.leftChild != null) { 94 pNode = pNode.leftChild; 95 } 96 return pNode; 97 } 98 99 /** 100 * maxElemNode: 获取二叉查找树中的最大关键字结点 101 * 102 * @return 二叉查找树的最大关键字结点 103 * @throws Exception 104 * 若树为空,则抛出异常 105 */ 106 public TreeNode maxElemNode(TreeNode node) throws Exception { 107 if (node == null) { 108 throw new Exception("树为空!"); 109 } 110 TreeNode pNode = node; 111 while (pNode.rightChild != null) { 112 pNode = pNode.rightChild; 113 } 114 return pNode; 115 } 116 117 /** 118 * successor: 获取给定结点在中序遍历顺序下的后继结点 119 * 120 * @param node 121 * 给定树中的结点 122 * @return 若该结点存在中序遍历顺序下的后继结点,则返回其后继结点;否则返回 null 123 * @throws Exception 124 */ 125 public TreeNode successor(TreeNode node) throws Exception { 126 if (node == null) { 127 return null; 128 } 129 130 // 若该结点的右子树不为空,则其后继结点就是右子树中的最小关键字结点 131 if (node.rightChild != null) { 132 return minElemNode(node.rightChild); 133 } 134 // 若该结点右子树为空 135 TreeNode parentNode = node.parent; 136 while (parentNode != null && node == parentNode.rightChild) { 137 node = parentNode; 138 parentNode = parentNode.parent; 139 } 140 return parentNode; 141 } 142 143 /** 144 * precessor: 获取给定结点在中序遍历顺序下的前趋结点 145 * 146 * @param node 147 * 给定树中的结点 148 * @return 若该结点存在中序遍历顺序下的前趋结点,则返回其前趋结点;否则返回 null 149 * @throws Exception 150 */ 151 public TreeNode precessor(TreeNode node) throws Exception { 152 if (node == null) { 153 return null; 154 } 155 156 // 若该结点的左子树不为空,则其前趋结点就是左子树中的最大关键字结点 157 if (node.leftChild != null) { 158 return maxElemNode(node.leftChild); 159 } 160 // 若该结点左子树为空 161 TreeNode parentNode = node.parent; 162 while (parentNode != null && node == parentNode.leftChild) { 163 node = parentNode; 164 parentNode = parentNode.parent; 165 } 166 return parentNode; 167 } 168 169 /** 170 * insert: 将给定关键字插入到二叉查找树中 171 * 172 * @param key 173 * 给定关键字 174 */ 175 public void insert(int key) { 176 TreeNode parentNode = null; 177 TreeNode newNode = new TreeNode(key, null, null, null); 178 TreeNode pNode = root; 179 if (root == null) { 180 root = newNode; 181 return; 182 } 183 while (pNode != null) { 184 parentNode = pNode; 185 if (key < pNode.key) { 186 pNode = pNode.leftChild; 187 } else if (key > pNode.key) { 188 pNode = pNode.rightChild; 189 } else { 190 // 树中已存在匹配给定关键字的结点,则什么都不做直接返回 191 return; 192 } 193 } 194 if (key < parentNode.key) { 195 parentNode.leftChild = newNode; 196 newNode.parent = parentNode; 197 } else { 198 parentNode.rightChild = newNode; 199 newNode.parent = parentNode; 200 } 201 202 } 203 204 /** 205 * insert: 从二叉查找树中删除匹配给定关键字相应的树结点 206 * 207 * @param key 208 * 给定关键字 209 */ 210 public void delete(int key) throws Exception { 211 TreeNode pNode = search(key); 212 if (pNode == null) { 213 throw new Exception("树中不存在要删除的关键字!"); 214 } 215 delete(pNode); 216 } 217 218 /** 219 * delete: 从二叉查找树中删除给定的结点. 220 * 221 * @param pNode 222 * 要删除的结点 223 * 224 * 前置条件: 给定结点在二叉查找树中已经存在 225 * @throws Exception 226 */ 227 private void delete(TreeNode pNode) throws Exception { 228 if (pNode == null) { 229 return; 230 } 231 if (pNode.leftChild == null && pNode.rightChild == null) { // 该结点既无左孩子结点,也无右孩子结点 232 TreeNode parentNode = pNode.parent; 233 if (pNode == parentNode.leftChild) { 234 parentNode.leftChild = null; 235 } else { 236 parentNode.rightChild = null; 237 } 238 return; 239 } 240 if (pNode.leftChild == null && pNode.rightChild != null) { // 该结点左孩子结点为空,右孩子结点非空 241 TreeNode parentNode = pNode.parent; 242 if (pNode == parentNode.leftChild) { 243 parentNode.leftChild = pNode.rightChild; 244 pNode.rightChild.parent = parentNode; 245 } else { 246 parentNode.rightChild = pNode.rightChild; 247 pNode.rightChild.parent = parentNode; 248 } 249 return; 250 } 251 if (pNode.leftChild != null && pNode.rightChild == null) { // 该结点左孩子结点非空,右孩子结点为空 252 TreeNode parentNode = pNode.parent; 253 if (pNode == parentNode.leftChild) { 254 parentNode.leftChild = pNode.leftChild; 255 pNode.rightChild.parent = parentNode; 256 } else { 257 parentNode.rightChild = pNode.leftChild; 258 pNode.rightChild.parent = parentNode; 259 } 260 return; 261 } 262 // 该结点左右孩子结点均非空,则删除该结点的后继结点,并用该后继结点取代该结点 263 TreeNode successorNode = successor(pNode); 264 delete(successorNode); 265 pNode.key = successorNode.key; 266 } 267 268 /** 269 * inOrderTraverseList: 获得二叉查找树的中序遍历结点列表 270 * 271 * @return 二叉查找树的中序遍历结点列表 272 */ 273 public List<TreeNode> inOrderTraverseList() { 274 if (nodelist != null) { 275 nodelist.clear(); 276 } 277 inOrderTraverse(root); 278 return nodelist; 279 } 280 281 /** 282 * inOrderTraverse: 对给定二叉查找树进行中序遍历 283 * 284 * @param root 285 * 给定二叉查找树的根结点 286 */ 287 private void inOrderTraverse(TreeNode root) { 288 if (root != null) { 289 inOrderTraverse(root.leftChild); 290 nodelist.add(root); 291 inOrderTraverse(root.rightChild); 292 } 293 } 294 295 /** 296 * toStringOfOrderList: 获取二叉查找树中关键字的有序列表 297 * 298 * @return 二叉查找树中关键字的有序列表 299 */ 300 public String toStringOfOrderList() { 301 StringBuilder sbBuilder = new StringBuilder(" [ "); 302 for (TreeNode p : inOrderTraverseList()) { 303 sbBuilder.append(p.key); 304 sbBuilder.append(" "); 305 } 306 sbBuilder.append("]"); 307 return sbBuilder.toString(); 308 } 309 310 /** 311 * 获取该二叉查找树的字符串表示 312 */ 313 public String toString() { 314 StringBuilder sbBuilder = new StringBuilder(" [ "); 315 for (TreeNode p : inOrderTraverseList()) { 316 sbBuilder.append(p); 317 sbBuilder.append(" "); 318 } 319 sbBuilder.append("]"); 320 return sbBuilder.toString(); 321 } 322 323 public TreeNode getRoot() { 324 return root; 325 } 326 327 public static void testNode(BinarySearchTree bst, TreeNode pNode) 328 throws Exception { 329 System.out.println("本结点: " + pNode); 330 System.out.println("前趋结点: " + bst.precessor(pNode)); 331 System.out.println("后继结点: " + bst.successor(pNode)); 332 } 333 334 public static void testTraverse(BinarySearchTree bst) { 335 System.out.println("二叉树遍历:" + bst); 336 System.out.println("二叉查找树转换为有序列表: " + bst.toStringOfOrderList()); 337 } 338 339 public static void main(String[] args) { 340 try { 341 BinarySearchTree bst = new BinarySearchTree(); 342 System.out.println("查找树是否为空? " + (bst.isEmpty() ? "是" : "否")); 343 int[] keys = new int[] { 15, 6, 18, 3, 7, 13, 20, 2, 9, 4 }; 344 for (int key : keys) { 345 bst.insert(key); 346 } 347 System.out.println("查找树是否为空? " + (bst.isEmpty() ? "是" : "否")); 348 TreeNode minkeyNode = bst.minElemNode(bst.getRoot()); 349 System.out.println("最小关键字: " + minkeyNode.getKey()); 350 testNode(bst, minkeyNode); 351 TreeNode maxKeyNode = bst.maxElemNode(bst.getRoot()); 352 System.out.println("最大关键字: " + maxKeyNode.getKey()); 353 testNode(bst, maxKeyNode); 354 System.out.println("根结点关键字: " + bst.getRoot().getKey()); 355 testNode(bst, bst.getRoot()); 356 testTraverse(bst); 357 System.out.println("****************************** "); 358 testTraverse(bst); 359 } catch (Exception e) { 360 System.out.println(e.getMessage()); 361 e.printStackTrace(); 362 } 363 } 364 365 }