package test;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Stack;
import org.apache.poi.util.SystemOutLogger;
public class BST {
Node root = null;
private class Node{
private int key;
private String value;
private int N;
private Node left,right;
Node(int key, String value, int n) {
this.key = key;
this.value = value;
this.N= n;
}
}
public static void main(String[] args) {
BST bst = new BST();
bst.put(3, "three");
bst.put(6, "six");
bst.put(1, "one");
bst.put(8, "eight");
bst.put(2, "two");
bst.put(7, "seven");
System.out.println(bst.size());
System.out.println(bst.min());
System.out.println(bst.max());
System.out.println(bst.floor(4));
System.out.println("inOrder");
bst.inOrder();
System.out.println("inOrder2");
bst.inOrder2();
//bst.delete(7);
//bst.inOrder();
System.out.println("perOrder");
bst.perOrder();
System.out.println("perOrder2");
bst.perOrder2();
System.out.println("postOrder");
bst.postOrder();
System.out.println("postOrder2");
bst.postOrder2();
}
int size() {
if(root == null)
return 0;
return root.N;
}
int size(Node node) {
return node==null?0:node.N;
}
public void put(int key, String value) {
root = put(root, key, value);
}
public Node put(Node node, int key, String value) {
if(node == null) {
node = new Node(key, value, 1);
return node;
}else {
if(node.key > key) {
node.left = put(node.left, key, value);
//node.N++;
}else if(node.key < key){
node.right = put(node.right, key, value);
//node.N++;
}else {
node.value = value;
}
}
node.N = size(node.left) + size(node.right) + 1;
return node;
}
public Node deleteMin(Node node) {
if(node == null)
return node;
if(node.left == null) {
return node.right;
}
if(node.left != null) {
node.left = deleteMin(node.left);
}
return node;
}
public void delete(int key){
root = delete(root, key);
}
public Node delete(Node node, int key) {
//Node n = get(key);
if(node == null)
return null;
if(node.key == key) {
//左右子树均为空
if(node.left == null && node.right == null) {
return null;
}else if(node.left == null) {
node = node.right;
}else if(node.right == null){
node = node.left;
}else {
Node tmp = node;
node = min(node.right);
node.right = deleteMin(node.right);
node.left = tmp.left;
}
}
if(node.key > key) {
node.left = delete(node.left, key);
}else {
node.right = delete(node.right, key);
}
node.N = size(node.left) + size(node.right) + 1;
return node;
}
public int min() {
return min(root).key;
}
public Node min(Node node) {
if(node.left == null)
return node;
else {
do {
node = node.left;
}while(node.left != null);
return node;
}
}
public int max() {
return max(root).key;
}
public Node max(Node node) {
if(node.right == null)
return node;
else {
do {
node = node.right;
}while(node.right != null);
return node;
}
}
public int floor(int key) {
return floor(root, key)==null ?0 : floor(root, key).key;
}
public Node floor(Node node, int key) {
if(node == null)
return node;
Node t = null;
if(node.key == key)
return node;
if(node.key < key) {
t = floor(node.right, key);
}else {
t = floor(node.left, key);
}
if(t == null)
return node;
else
return t;
}
public Node get(int key) {
return get(root, key);
}
public Node get(Node node, int key) {
if(node == null || node.key == key)
return node;
else {
if(node.key > key) {
return get(node.left, key);
}else {
return get(node.right, key);
}
}
}
public int select(int k) {
Node ret = select(root, k);
if(ret == null)
return -9999;
return ret.key;
}
public Node select(Node node, int k) {
if(node == null)
return null;
int t = size(node.left);
if(t == k) {
return node;
}else if(t < k) {
return select(node.right, k-t-1);
}else{
return select(node.left, k);
}
}
public void perOrder() {
preOrder(root);
}
public void preOrder(Node node) {
if(node != null) {
System.out.println(node.value);
preOrder(node.left);
preOrder(node.right);
}
}
public void perOrder2() {
Stack<Node> stack = new Stack<>();
Node node = root;
if(node != null) {
stack.push(node);
System.out.println(node.value);
while(node.left != null) {
node = node.left;
stack.push(node);
System.out.println(node.value);
}
}
while(!stack.isEmpty()) {
Node n = stack.pop();
if(n.right != null) {
stack.push(n.right);
System.out.println(n.right.value);
n = n.right;
while(n.left != null) {
n = n.left;
stack.push(n);
System.out.println(n.value);
}
}
}
}
public void inOrder() {
inOrder(root);
}
public void inOrder(Node node) {
if(node != null) {
inOrder(node.left);
System.out.println(node.value);
inOrder(node.right);
}
}
public void inOrder2() {
Stack<Node> stack = new Stack<>();
Node node = root;
while(node != null) {
stack.push(node);
node = node.left;
}
while(!stack.isEmpty()) {
Node n = stack.pop();
System.out.println(n.value);
if(n.right != null) {
stack.push(n.right);
n = n.right;
while(n.left != null) {
n = n.left;
stack.push(n);
}
}
}
}
public void postOrder() {
postOrder(root);
}
public void postOrder(Node node) {
if(node != null) {
postOrder(node.left);
postOrder(node.right);
System.out.println(node.value);
}
}
public void postOrder2() {
LinkedList<Node> ll = new LinkedList<>();
Stack<Node> stack = new Stack<>();
Node node = root;
if(node != null) {
stack.push(node);
ll.add(node);
//System.out.println(node.value);
while(node.right != null) {
node = node.right;
stack.push(node);
ll.add(node);
//System.out.println(node.value);
}
}
while(!stack.isEmpty()) {
Node n = stack.pop();
if(n.left != null) {
stack.push(n.left);
ll.add(n.left);
//System.out.println(n.left.value);
n = n.left;
while(n.right != null) {
n = n.right;
stack.push(n);
ll.add(n);
//System.out.println(n.value);
}
}
}
Collections.reverse(ll);
for (Node n : ll) {
System.out.println(n.value);
}
}
}
Java实现二叉排序树及遍历
最新推荐文章于 2021-06-22 11:20:05 发布