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 }