DS二叉排序树之查找

时间限制: 1 Sec  内存限制: 128 MB

题目描述

给出一个数据序列，建立二叉排序树，并实现查找功能

对二叉排序树进行中序遍历，可以得到有序的数据序列

输入

第一行输入t，表示有t个数据序列

第二行输入n，表示首个序列包含n个数据

第三行输入n个数据，都是自然数且互不相同，数据之间用空格隔开

第四行输入m，表示要查找m个数据

从第五行起，输入m行，每行一个要查找的数据，都是自然数

以此类推输入下一个示例

输出

第一行输出有序的数据序列，对二叉排序树进行中序遍历可以得到

从第二行起，输出查找结果，如果查找成功输出查找次数，如果查找失败输出-1

以此类推输出下一个示例的结果

样例输入

1

6

22 33 55 66 11 44

7

11

22

33

44

55

66

77

样例输出

11 22 33 44 55 66

2

1

2

4

3

4

-1 

Solution：

import java.util.*;
public class Main{
	public static void main(String args[]){
		Scanner scanner = new Scanner(System.in);
		int t = scanner.nextInt();
		for (int i = 0; i <t ; i++) {
			BST bst = new BST();//创建二叉排序树
			int n = scanner.nextInt();
			for (int j = 0; j <n ; j++) {//将结点加入到二叉排序树中
				bst.add(new Node(scanner.nextInt()));
			}
			bst.midShow();//中序遍历进行输出
			System.out.println();
			int m = scanner.nextInt();
			for (int j = 0; j <m ; j++) {
				// 搜索结点
				Node node = bst.search(scanner.nextInt());
				if (node == null){
					System.out.println(-1);// 找不到，则输出 -1
				}else {
					System.out.println(node.count);//找到了，则输出搜索次数
				}
			}
		}
	}
}

/**
 * 二叉树结点
 */
class Node{
	int value;
	Node left;
	Node right;
	int count = 1;
	public Node(int value){
		this.value = value;
	}

	/**
	 * 往二叉树中插入结点
	 * @param node
	 */
	public void add(Node node){
		if (node == null){
			return;
		}
		/*
		如果插入的结点的值小于当前结点的值，则该插入的结点应该向左走
		 */
		if (node.value<this.value){
			// 该结点的左孩子为空，则正好放入插入结点
			if (this.left == null){
				this.left = node;
			}else {
				//该结点的左孩子非空，则插入结点需要加入到左孩子树中
				this.left.add(node);
			}
		}else {
			//右边同理，右孩子为空，直接放入插入结点
			if (this.right== null){
				this.right = node;
			}else {
				// 右孩子非空，则插入结点需要加入到右孩子树中
				this.right.add(node);
			}
		}
	}

	/**
	 * 中序遍历，将二叉树中的结点，按照从小到大的顺序输出
	 * @param node
	 */
	public void midShow(Node node){
		if (node == null){
			return;
		}
		midShow(node.left);//遍历左子树
		System.out.print(node.value+" ");//输出当前结点值
		midShow(node.right);//遍历右子树
	}

	/**
	 * 传入值，搜索对应的结点，返回结点
	 * @param value
	 * @return 如果找不到，返回空
	 */
	public Node search(int value){
		// 找到了，直接返回当前结点
		if (this.value == value){
			return this;
		}else if (value<this.value){ // 要搜索的值小于当前结点的值，向左子树中进行查找
			if (left == null){// 左子树为空，说明找不到
				return null;
			}
			left.count = this.count+1;
			return left.search(value);// 非空，递归查找
		}else {// 同理，要搜索的值大于当前结点的值，向右子树中进行查找
			if (right == null){
				return null;
			}
			right.count = this.count+1;
			return right.search(value);
		}
	}

}

class BST{
	Node root;

	/**
	 * 往二叉排序树中加入结点
	 * @param node
	 */
	public void add(Node node){
		if (root == null){
			root =node;
		}else {
			root.add(node);
		}
	}

	/**
	 * 中序遍历二叉排序树
	 */
	public void midShow(){
		if (root!=null){
			root.midShow(root);
		}
	}

	/**
	 * 在二叉排序树中查找
	 * @param value
	 * @return
	 */
	public Node search(int value){
		if (root == null){
			return null;
		}else {
			return root.search(value);
		}
	}

}