java 字符串叉_二叉搜索树的字符串表示

我一直在尝试为二叉搜索树编写一个递归字符串方法,该方法返回具有预订路径信息的树的多行表示 .

每个节点都应该以一系列字符开头,这些字符显示从根到该节点的路径 . 我不确定如何使用每个连续调用一个字符扩展的字符串前缀参数 .

该方法应该能够重现这个例子:

树:

15

/ \

12 18

/ / \

10 16 20

\ \

11 17

预期打印输出:

15

<12

<<10

<<>11

>18

><16

><>17

>>20

我是递归的新手,到目前为止,我的实际打印输出在经过几个小时的代码处理后还不够接近:

18

<17

<10

>15

<11

>12

16

20

这是我的树节点类正常工作:

/**

* A single binary tree node.

*

* Each node has both a left or right child, which can be null.

*/

public class TreeNode {

private E data;

private TreeNode left;

private TreeNode right;

/**

* Constructs a new node with the given data and references to the

* given left and right nodes.

*/

public TreeNode(E data, TreeNode left, TreeNode right) {

this.data = data;

this.left = left;

this.right = right;

}

/**

* Constructs a new node containing the given data.

* Its left and right references will be set to null.

*/

public TreeNode(E data) {

this(data, null, null);

}

/** Returns the item currently stored in this node. */

public E getData() {

return data;

}

/** Overwrites the item stored in this Node with the given data item. */

public void setData(E data) {

this.data = data;

}

/**

* Returns this Node's left child.

* If there is no left left, returns null.

*/

public TreeNode getLeft() {

return left;

}

/** Causes this Node to point to the given left child Node. */

public void setLeft(TreeNode left) {

this.left = left;

}

/**

* Returns this nodes right child.

* If there is no right child, returns null.

*/

public TreeNode getRight() {

return right;

}

/** Causes this Node to point to the given right child Node. */

public void setRight(TreeNode right) {

this.right = right;

}

}

这是我的二叉搜索树类,底部附近有toFullString()方法:

import java.util.*;

/**

* A binary search tree (BST) is a sorted ADT that uses a binary

* tree to keep all elements in sorted order. If the tree is

* balanced, performance is very good: O(n lg n) for most operations.

* If unbalanced, it performs more like a linked list: O(n).

*/

public class BinarySearchTree> {

private TreeNode root = null;

private int size = 0;

/** Creates an empty tree. */

public BinarySearchTree() {

}

public BinarySearchTree(Collection col) {

List list = new ArrayList(col);

Collections.shuffle(list);

for (int i = 0; i < list.size() ; i++) {

add(list.get(i));

}

}

/** Adds the given item to this BST. */

public void add(E item) {

this.size++;

if (this.root == null) {

//tree is empty, so just add item

this.root = new TreeNode(item);

}else {

//find where to insert, with pointer to parent node

TreeNode parent = null;

TreeNode curr = this.root;

boolean wentLeft = true;

while (curr != null) { //will execute at least once

parent = curr;

if (item.compareTo(curr.getData()) <= 0) {

curr = curr.getLeft();

wentLeft = true;

}else {

curr = curr.getRight();

wentLeft = false;

}

}

//now add new node on appropriate side of parent

curr = new TreeNode(item);

if (wentLeft) {

parent.setLeft(curr);

}else {

parent.setRight(curr);

}

}

}

/** Returns the greatest (earliest right-most node) of the given tree. */

private E findMax(TreeNode n) {

if (n == null) {

return null;

}else if (n.getRight() == null) {

//can't go right any more, so this is max value

return n.getData();

}else {

return findMax(n.getRight());

}

}

/**

* Returns item from tree that is equivalent (according to compareTo)

* to the given item. If item is not in tree, returns null.

*/

public E get(E item) {

return get(item, this.root);

}

/** Finds it in the subtree rooted at the given node. */

private E get(E item, TreeNode node) {

if (node == null) {

return null;

}else if (item.compareTo(node.getData()) < 0) {

return get(item, node.getLeft());

}else if (item.compareTo(node.getData()) > 0) {

return get(item, node.getRight());

}else {

//found it!

return node.getData();

}

}

/**

* Removes the first equivalent item found in the tree.

* If item does not exist to be removed, throws IllegalArgumentException().

*/

public void remove(E item) {

this.root = remove(item, this.root);

}

private TreeNode remove(E item, TreeNode node) {

if (node == null) {

//didn't find item

throw new IllegalArgumentException(item + " not found in tree.");

}else if (item.compareTo(node.getData()) < 0) {

//go to left, saving resulting changes made to left tree

node.setLeft(remove(item, node.getLeft()));

return node;

}else if (item.compareTo(node.getData()) > 0) {

//go to right, saving any resulting changes

node.setRight(remove(item, node.getRight()));

return node;

}else {

//found node to be removed!

if (node.getLeft() == null && node.getRight() == null) {

//leaf node

return null;

}else if (node.getRight() == null) {

//has only a left child

return node.getLeft();

}else if (node.getLeft() == null) {

//has only a right child

return node.getRight();

}else {

//two children, so replace the contents of this node with max of left tree

E max = findMax(node.getLeft()); //get max value

node.setLeft(remove(max, node.getLeft())); //and remove its node from tree

node.setData(max);

return node;

}

}

}

/** Returns the number of elements currently in this BST. */

public int size() {

return this.size;

}

/**

* Returns a single-line representation of this BST's contents.

* Specifically, this is a comma-separated list of all elements in their

* natural Comparable ordering. The list is surrounded by [] characters.

*/

@Override

public String toString() {

return "[" + toString(this.root) + "]";

}

private String toString(TreeNode n) {

//would have been simpler to use Iterator... but not implemented yet.

if (n == null) {

return "";

}else {

String str = "";

str += toString(n.getLeft());

if (!str.isEmpty()) {

str += ", ";

}

str += n.getData();

if (n.getRight() != null) {

str += ", ";

str += toString(n.getRight());

}

return str;

}

}

public String toFullString() {

StringBuilder sb = new StringBuilder();

toFullString(root, sb);

return sb.toString();

}

/**

* Preorder traversal of the tree that builds a string representation

* in the given StringBuilder.

* @param n root of subtree to be traversed

* @param sb StringBuilder in which to create a string representation

*/

private void toFullString(TreeNode n, StringBuilder sb)

{

if (n == null)

{

return;

}

sb.append(n.getData().toString());

sb.append("\n");

if (n.getLeft() != null) {

sb.append("

} else if (n.getRight() != null) {

sb.append(">");

}

if (n.getLeft() != null || n.getRight() != null)

{

toFullString(n.getLeft(), sb);

toFullString(n.getRight(), sb);

}

}

/**

* Tests the BST.

*/

public static void main(String[] args) {

Collection collection = new ArrayList();

collection.add(15);

collection.add(12);

collection.add(18);

collection.add(10);

collection.add(16);

collection.add(20);

collection.add(11);

collection.add(17);

BinarySearchTree bst = new BinarySearchTree(collection);

//System.out.println(bst);

String temp = bst.toFullString();

System.out.println(temp);

}

}

任何有关递归toFullString方法的帮助将不胜感激 .

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值