Structure.BSTree（二叉树、排序树、平衡树、SB树）

最新推荐文章于 2024-07-12 11:40:39 发布

qq_34690598

最新推荐文章于 2024-07-12 11:40:39 发布

阅读量1.2k

点赞数

分类专栏：数据结构文章标签： Java 数据结构二叉树平衡树

本文链接：https://blog.csdn.net/qq_34690598/article/details/51175115

版权

数据结构专栏收录该内容

5 篇文章 0 订阅

订阅专栏

二叉树

BBTree 最优二叉树，包含Huffman编码

BSTree 二叉排序树

SBT SizedBalancedTree 平衡树的一种，acm竞赛中比较常用的数据结构，请参考陈启峰大牛的论文,见SBT文件夹。比红黑树代码少了3/4

package Structure.BSTree;
import java.util.Collections;
import java.util.Vector;
import java.util.Stack;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
class NodeInfo implements Comparable<NodeInfo>
{
	char letter_;
	int num_;
	public NodeInfo(char letter,int num){letter_ = letter ; num_ = num;}
	@Override
	public int compareTo(NodeInfo o) {
		// TODO Auto-generated method stub
		return num_ - o.num_;
	}
}

public class BBTree{
	private TreeNode<NodeInfo> root_;
	public BBTree(){root_ = null;}
	
	public void BuildBestTree(Vector<NodeInfo> v)
	{
		int size = v.size();
		for(int i = 0 ; i < size-1;++i)
		{
			Collections.sort(v);
			NodeInfo one = v.get(0);
			NodeInfo two = v.get(1);
			NodeInfo root = new NodeInfo(' ',(one.num_+two.num_));
			if(root_ == null)
			{
				root_ = new TreeNode<NodeInfo>(root,null,null);
				root_.left_ = new TreeNode<NodeInfo>(one,null,null);
				root_.right_ = new TreeNode<NodeInfo>(two,null,null);
			}
			else
			{
				TreeNode<NodeInfo> n = new TreeNode<NodeInfo>(root,null,root_);
				n.left_ = new TreeNode<NodeInfo>(one,null,null);
				root_ = n;
			}
			v.remove(one);
			v.remove(two);
			v.add(root);
		}
	}
	
	public void HuffmanCode()
	{
		Stack<Count<NodeInfo> > stack = new Stack<Count<NodeInfo> >();
		stack.push(new Count<NodeInfo>(root_));
		while(!stack.isEmpty())
		{
			Count<NodeInfo> cur = stack.peek();
			if(cur.num == 0)
			{
				if(cur.node_.left_ != null) stack.push(new Count<NodeInfo>(cur.node_.left_));
				cur.num++;
			}
			else if(cur.num == 1)
			{
				if(cur.node_.right_ != null) stack.push(new Count<NodeInfo>(cur.node_.right_));
				cur.num++;
			}
			else if(cur.num == 2)
			{
				if(cur.node_.data_.letter_ != ' ')
				{
					StringBuffer s = new StringBuffer();
					for(int i = 0 ; i < stack.size() -1 ; ++i)
					{
						Count<NodeInfo> father = stack.get(i);
						Count<NodeInfo> son = stack.get(i+1);
						if(father.node_.right_ == son.node_)
						{
							s.append('1');
						}
						else if(father.node_.left_ == son.node_)
						{
							s.append('0');
						}
					}
					System.out.println(cur.node_.data_.letter_ + ": " + s);
				}
				stack.pop();
			}
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector<NodeInfo> v = new Vector<NodeInfo>();
		v.add(new NodeInfo('C',2));
		v.add(new NodeInfo('E',7));
		v.add(new NodeInfo('S',4));
		v.add(new NodeInfo('T',5));
		
		BBTree tree = new BBTree();
		tree.BuildBestTree(v);
		
		System.out.println();
		tree.HuffmanCode();
	}

}

package Structure.BSTree;
import java.util.Iterator;
import java.util.Stack;
import java.util.LinkedList;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
class TreeNode<E extends Comparable<E> >
{
	TreeNode<E> left_;
	TreeNode<E> right_;
	E data_;
	public TreeNode(E data,TreeNode<E> left,TreeNode<E> right)
	{
		data_ = data;
		left_ = left;
		right_ = right;
	}
}

class Count<E extends Comparable<E> >
{
	TreeNode<E> node_;
	int num;
	public Count(TreeNode<E> node){node_ = node; num = 0;}
}

public class BSTree<E extends Comparable<E> > {
	private TreeNode<E> root_;
	public BSTree(){root_ = null;}
	
	public TreeNode<E> GetRoot(){return root_;}
	
	public E FindKth(int kth)
	{
		return FindKth(root_,kth);
	}
	
	public void Insert(E value)
	{
		root_ = Insert(root_,value);
	}
	
	public boolean Remove(E value)
	{
		TreeNode<E> node = FindNode(root_,value);
		if( node != null)
		{
			root_ = Remove(root_,node);
			return true;
		}else return false;
	}
	
	public void InPrintByStack()
	{
		Stack<Count<E> > stack = new Stack<Count<E> >();
		stack.push(new Count<E>(root_));
		while(!stack.isEmpty())
		{
			Count<E> cur = stack.peek();
			if(cur.num == 1)
			{
				stack.pop();
				System.out.print(cur.node_.data_+ " ");
				if(cur.node_.right_ != null)
					stack.push(new Count<E>(cur.node_.right_));
			}
			else if(cur.num == 0)
			{
				if(cur.node_.left_ != null)
					stack.push(new Count<E>(cur.node_.left_));
				cur.num++;
			}
		}
		System.out.println();
	}
	
	public void PrePrintByStack()
	{
		Stack<TreeNode<E> > stack = new Stack<TreeNode<E>>();
		stack.push(root_);
		while(!stack.isEmpty())
		{
			TreeNode<E> cur = stack.peek();stack.pop();
			if(cur.right_ != null ) stack.push(cur.right_);
			if(cur.left_ != null) stack.push(cur.left_);
			System.out.print(cur.data_+" ");
		}
		System.out.println();
	}
	
	public void PostPrintByStack()
	{
		Stack<Count<E> > stack = new Stack<Count<E> >();
		stack.push(new Count<E>(root_));
		while(!stack.isEmpty())
		{
			Count<E> cur = stack.peek();
			if(cur.num == 2)
			{
				stack.pop();
				System.out.print(cur.node_.data_ + " ");
			}
			else if(cur.num == 1)
			{
				if(cur.node_.right_ != null)
					stack.push(new Count<E>(cur.node_.right_));
				cur.num++;
			}
			else if(cur.num == 0)
			{
				if(cur.node_.left_ != null)
					stack.push(new Count<E>(cur.node_.left_));
				cur.num++;
			}
		}
		System.out.println();
	}
	
	public void LevelPrintByQueue()
	{
		LevelPrintByQueue(root_);
	}
	
	public void PrePrint()
	{
		PrePrint(root_);
	}
	
	public void InPrint()
	{
		InPrint(root_);
	}
	
	public void PostPrint()
	{
		PostPrint(root_);
	}
	
	public int Height(){return Height(root_);}
	public int Size(){return Size(root_);}
	
	private void LevelPrintByQueue(TreeNode<E> root)
	{
		if(root == null) return;
		LinkedList<TreeNode<E>> upLevel = new LinkedList<TreeNode<E>>();
		LinkedList<TreeNode<E>> downLevel = new LinkedList<TreeNode<E>>();
		upLevel.add(root);
		while(!upLevel.isEmpty())
		{
			Iterator<TreeNode<E>> it = upLevel.iterator();
			while(it.hasNext())
			{
				TreeNode<E> temp = it.next();
				if(temp.left_ != null) downLevel.add(temp.left_);
				if(temp.right_ != null) downLevel.add(temp.right_);
			}
			while(!upLevel.isEmpty())
			{
				TreeNode<E> temp = upLevel.removeFirst();
				System.out.print(temp.data_+" ");
			}
			upLevel = downLevel;
			downLevel = new LinkedList<TreeNode<E>>();
		}
	}
	
	private E FindKth(TreeNode<E> root,int kth)
	{
		if(root == null) return null;
		int lcount = Size(root.left_);
		if(lcount + 1 == kth){return  root.data_;}
		else if( lcount + 1 > kth)
		{
			return FindKth(root.left_,kth);
		}else 
			return FindKth(root.right_,kth-lcount-1);
	}
	
	private TreeNode<E> Remove(TreeNode<E> root,TreeNode<E> node)
	{
		if(root == null) return null;
		else
		{
			if(root.data_.compareTo(node.data_) == 0 )
			{
				if(root.left_ == null) 
				{
					root = root.right_;
				}
				else if(root.right_ == null)
				{
					root = root.left_;
				}
				else
				{
					TreeNode<E> t = FindMin(root.right_);
					root.right_ = Remove(root.right_,t);
					t.left_ = root.left_;
					t.right_ = root.right_;
					root = t;
				}
			}
			else if(root.data_.compareTo(node.data_) > 0)
			{
				root.left_ = Remove(root.left_,node);
			}else
			{
				root.right_ = Remove(root.right_,node);
			}
		}
		return root;
	}
	
	private TreeNode<E> FindNode(TreeNode<E> root,E value)
	{
		if(root == null) return null;
		if(root.data_.compareTo(value) == 0) return root;
		else
		{
			if(root.data_.compareTo(value) > 0) return FindNode(root.left_,value);
			else return FindNode(root.right_,value);
		}
	}
	
	private TreeNode<E> FindMin(TreeNode<E> root)
	{
		if(root.left_ == null) return root;
		else
		{
			TreeNode<E> t = root.left_;
			while(t.left_ != null) t = t.left_;
			return t;
		}
	}
	
	private void PostPrint(TreeNode<E> root)
	{
		if(root == null) return;
		PostPrint(root.left_);
		PostPrint(root.right_);
		System.out.print(root.data_+" ");
	}
	
	private void InPrint(TreeNode<E> root)
	{
		if(root == null) return;
		InPrint(root.left_);
		System.out.print(root.data_ +" ");
		InPrint(root.right_);
	}
	
	private void PrePrint(TreeNode<E> root)
	{
		if(root == null) return;
		System.out.print(root.data_ +" ");
		PrePrint(root.left_);
		PrePrint(root.right_);
	}
	
	private int MaxOfTwo(Integer first,Integer second)
	{
		return (first.compareTo(second)<= 0)?second:first;
	}
	
	private int Height(TreeNode<E> root)
	{
		if(root == null) return 0;
		else 
		return 1+MaxOfTwo(Height(root.left_),Height(root.right_));
	}
	
	private int Size(TreeNode<E> root)
	{
		if(root == null) return 0;
		else
		return Size(root.left_)+Size(root.right_)+1;
	}
	
	private TreeNode<E> Insert(TreeNode<E> root,E value)
	{
		if(root == null)
		{
			root = new TreeNode<E>(value,null,null);
		}
		else
		{
			if(root.data_.compareTo(value) >= 0)
			{
				root.left_ = Insert(root.left_,value);
			}
			else{ root.right_ = Insert(root.right_,value);}
		}
		return root;
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BSTree<Integer> tree = new BSTree<Integer>();
		tree.Insert(40);
		tree.Insert(20);
		tree.Insert(30);
		tree.Insert(50);
		tree.Insert(80);
		tree.Insert(100);
		tree.Insert(10);
		tree.Insert(60);
		tree.Insert(70);
		
		tree.InPrint();
		System.out.println();
		tree.PrePrint();
		System.out.println();
		tree.PostPrint();
		System.out.println();
		
		System.out.println(tree.Size());
		System.out.println(tree.Height());
		
		tree.Remove(0);
		tree.InPrint();
		System.out.println();
		
		tree.Remove(40);
		tree.InPrint();
		System.out.println();
		
		tree.Remove(30);
		tree.InPrint();
		System.out.println();
		
		tree.Remove(80);
		tree.InPrint();
		System.out.println();
		
		tree.Insert(10);
		tree.InPrint();
		System.out.println();
		
		tree.Remove(10);
		tree.InPrint();
		System.out.println();
		
		tree.Remove(10);
		tree.InPrint();
		System.out.println();
		System.out.println();
		
		tree.PrePrintByStack();
		tree.PrePrint();
		System.out.println();
		System.out.println();
		
		tree.PostPrintByStack();
		tree.PostPrint();
		System.out.println();
		System.out.println();
		
		tree.InPrintByStack();
		tree.InPrint();
		System.out.println();
		
		tree.LevelPrintByQueue();
	}

}

package Structure.BSTree;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
class SBTreeNode<E extends Comparable<E>> {
	E key;
	SBTreeNode<E> leftChild;
	SBTreeNode<E> rightChild;
	int size;

	public SBTreeNode(E value) {
		key = value;
		leftChild = rightChild = null;
		size = 1;
	}
}

class SBTree<E extends Comparable<E>> {
	private SBTreeNode<E> root;

	public SBTreeNode<E> getRoot() {
		return root;
	}

	public SBTree() {
		root = null;
	}

	public void Insert(E v) {
		root = Insert(root, v);
	}
	
	public void Delete(E v)
	{
		SBTreeNode<E> n = Find(root,v);
		if(n != null)
		{
			root = Delete(root, n);
		}
	}
	
	public boolean Find(E v)
	{
		SBTreeNode<E> n = Find(root,v);
		return n != null ?true:false;
	}
	public E Select(int i)
	{
		SBTreeNode<E> s = Select(root,i);
		return s.key;
	}
	
	public int Size(){return Size(root);}
	public void PreOrder(){PreOrder(root);}
	public E FindMin(){return FindMin(root).key;}
	public E FindMax(){return FindMax(root).key;}
	
	private void PreOrder(SBTreeNode<E> t)
	{
		if(t == null) return;
		PreOrder(t.leftChild);
		System.out.print(t.key+", ");
		PreOrder(t.rightChild);
	}

	private SBTreeNode<E> LR(SBTreeNode<E> t) {
		SBTreeNode<E> k = t.rightChild;
		t.rightChild = k.leftChild;
		k.leftChild = t;
		k.size = Size(t);
		UpdateSize(t);
		return k;
	}
	
	private SBTreeNode<E> RR(SBTreeNode<E> t) {
		SBTreeNode<E> k = t.leftChild;
		t.leftChild = k.rightChild;
		k.rightChild = t;
		k.size = Size(t);
		UpdateSize(t);
		return k;
	}

	private int Size(SBTreeNode<E> t) {
		return t == null ? 0 : t.size;
	}
	
	private void UpdateSize(SBTreeNode<E> t)
	{
		if(t == null) return;
		t.size = Size(t.leftChild) + Size(t.rightChild) + 1;
	}

	private SBTreeNode<E> Maintain(SBTreeNode<E> t, boolean flag)
	{
		if( t == null) return t;
		if( flag == false)
		{
			if( t.leftChild != null )
			{
				if ( Size(t.leftChild.leftChild) > Size(t.rightChild))
					t = RR(t);
				else if( Size(t.leftChild.rightChild) > Size(t.rightChild))
				{
					t.leftChild = LR(t.leftChild);
					t = RR(t);
				}
				else return t;
			}
			else return t;
		}
		else
		{
			if(t.rightChild != null)
			{
				if( Size(t.rightChild.rightChild) > Size(t.leftChild))
					t = LR(t);
				else if( Size(t.rightChild.leftChild) > Size(t.leftChild))
				{
					t.rightChild = RR(t.rightChild);
					t = LR(t);
				}
				else return t;
			}
			else return t;
			
		}
		t.leftChild = Maintain(t.leftChild,false);
		t.rightChild = Maintain(t.rightChild,true);
		t = Maintain(t,false);
		t = Maintain(t,true);
		return t;
	}
	
	private SBTreeNode<E> Insert(SBTreeNode<E> t, E v) {
		if( t == null)
			t = new SBTreeNode<E>(v);
		else
		{
			t.size = t.size + 1;
			if( v.compareTo(t.key) < 0 )
				t.leftChild = Insert(t.leftChild,v);
			else
				t.rightChild = Insert(t.rightChild,v);
		}
		t = Maintain(t, v.compareTo(t.key) >= 0 );
		return t;
	}
	
	private SBTreeNode<E> Select(SBTreeNode<E> x, int i)
	{
		int r = Size(x.leftChild) + 1;
		if( i == r)
			return x;
		else if( i < r)
			return Select(x.leftChild,i);
		else return Select(x.rightChild, i - r);
	}
	
	private SBTreeNode<E> FindMin(SBTreeNode<E> t)
	{
		while( t.leftChild != null)
			t = t.leftChild;
		return t;
	}
	
	private SBTreeNode<E> FindMax(SBTreeNode<E> t)
	{
		while(t.rightChild != null)
			t = t.rightChild;
		return t;
	}
	
	private SBTreeNode<E> Delete(SBTreeNode<E> t,SBTreeNode<E> k)
	{
		if( t == null) return t;
		if( (k.key.compareTo(t.key) == 0) && (t.size == k.size) )
		{
			if(t.rightChild == null)
			{
				k = t.leftChild;
				t = k;
			}
			else
			{
				SBTreeNode<E> tmp = FindMin(t.rightChild);
				t.rightChild = Delete(t.rightChild,tmp);
				tmp.leftChild = t.leftChild;
				tmp.rightChild = t.rightChild;
				t = tmp;
			}
		}
		else
		{
			if( k.key.compareTo(t.key) <= 0)
				t.leftChild = Delete(t.leftChild,k);
			else
				t.rightChild = Delete(t.rightChild,k);
		}
		UpdateSize(t);
		return t;
	}
	
	private SBTreeNode<E> Find(SBTreeNode<E> t,E v)
	{
		if(t == null) return null;
		if( t.key == v) return t;
		else if( t.key.compareTo(v) < 0) return Find(t.rightChild,v);
		else return Find(t.leftChild,v);
	}
}

public class SBT {
	public static void main(String[] args)
	{
		SBTree<Integer> sbt = new SBTree<Integer>();
		sbt.Insert(10);
		sbt.Insert(11);
		sbt.Insert(12);
		sbt.Insert(5);
		sbt.Insert(9);
		sbt.Insert(18);
		sbt.Insert(22);
		sbt.Insert(17);
		
		sbt.PreOrder();
		System.out.println();
		System.out.println(sbt.Select(sbt.Size()));
		System.out.println(sbt.Find(5));
		System.out.println(sbt.Find(6));
		System.out.println(sbt.Find(22));
		
		sbt.Delete(18);
		sbt.PreOrder();
		System.out.println();
		System.out.println(sbt.FindMax());
		System.out.println(sbt.FindMin());
	}
}