Пример #1
0
		/// <summary> Insert into the tree. Does nothing if item already present.
		/// </summary>
		/// <param name="item">the item to insert.
		/// </param>
		public virtual void  Insert(IComparable item)
		{
			current = parent = grand = header;
			nullNode.element = item;

			while (current.element.CompareTo(item) != 0)
			{
				great = grand; grand = parent; parent = current;
				current = item.CompareTo(current.element) < 0?current.left:current.right;

				// Check if two red children; fix if so
				if (current.left.color == RED && current.right.color == RED)
					handleReorient(item);
			}

			// Insertion fails if already present
			if (current != nullNode)
				return ;
			current = new RedBlackNode(item, nullNode, nullNode);

			// Attach to parent
			if (item.CompareTo(parent.element) < 0)
				parent.left = current;
			else
				parent.right = current;
			handleReorient(item);
		}
Пример #2
0
		/// <summary> Double rotate binary tree node: first right child
		/// with its left child; then node k1 with new right child.
		/// For AVL trees, this is a double rotation for case 3.
		/// </summary>
		internal static RedBlackNode doubleWithRightChild(RedBlackNode k1)
		{
			k1.right = withLeftChild(k1.right);
			return withRightChild(k1);
		}
Пример #3
0
		/// <summary> Construct the tree.
		/// </summary>
		/// <param name="negInf">a value less than or equal to all others.
		/// </param>
		public RedBlackTree(IComparable negInf)
		{
			header = new RedBlackNode(negInf);
			header.left = header.right = nullNode;
		}
Пример #4
0
		/// <summary> Rotate binary tree node with right child.
		/// For AVL trees, this is a single rotation for case 4.
		/// </summary>
		internal static RedBlackNode withRightChild(RedBlackNode k1)
		{
			RedBlackNode k2 = k1.right;
			k1.right = k2.left;
			k2.left = k1;
			return k2;
		}
Пример #5
0
		/// <summary> Double rotate binary tree node: first left child
		/// with its right child; then node k3 with new left child.
		/// For AVL trees, this is a double rotation for case 2.
		/// </summary>
		internal static RedBlackNode doubleWithLeftChild(RedBlackNode k3)
		{
			k3.left = withRightChild(k3.left);
			return withLeftChild(k3);
		}
Пример #6
0
		/// <summary> Rotate binary tree node with left child.
		/// For AVL trees, this is a single rotation for case 1.
		/// </summary>
		internal static RedBlackNode withLeftChild(RedBlackNode k2)
		{
			RedBlackNode k1 = k2.left;
			k2.left = k1.right;
			k1.right = k2;
			return k1;
		}
Пример #7
0
		internal RedBlackNode(IComparable theElement, RedBlackNode lt, RedBlackNode rt)
		{
			element = theElement;
			left = lt;
			right = rt;
			color = RedBlackTree.BLACK;
		}
Пример #8
0
//		// Test program
//		[STAThread]
//		public static void  Main(System.String[] args)
//		{
//			RedBlackTree t = new RedBlackTree(new MyInteger(System.Int32.MinValue));
//			int NUMS = 40000;
//			int GAP = 307;
//
//			System.Console.Out.WriteLine("Checking... (no more output means success)");
//
//			for (int i = GAP; i != 0; i = (i + GAP) % NUMS)
//				t.Insert(new MyInteger(i));
//
//			if (NUMS < 40)
//				t.PrintTree();
//			if (((MyInteger) (t.FindMin())).intValue() != 1 || ((MyInteger) (t.FindMax())).intValue() != NUMS - 1)
//				System.Console.Out.WriteLine("FindMin or FindMax error!");
//
//			for (int i = 1; i < NUMS; i++)
//				if (((MyInteger) (t.Find(new MyInteger(i)))).intValue() != i)
//					System.Console.Out.WriteLine("Find error1!");
//		}
		static RedBlackTree()
		{
			nullNode = new RedBlackNode(null);
			nullNode.left = nullNode.right = nullNode;
		}
Пример #9
0
		/// <summary> Internal routine that performs a single or double rotation.
		/// Because the result is attached to the parent, there are four cases.
		/// Called by handleReorient.
		/// </summary>
		/// <param name="item">the item in handleReorient.
		/// </param>
		/// <param name="parent">the parent of the root of the rotated subtree.
		/// </param>
		/// <returns> the root of the rotated subtree.</returns>
		private RedBlackNode rotate(IComparable item, RedBlackNode parent)
		{
			if (item.CompareTo(parent.element) < 0)
				return parent.left = item.CompareTo(parent.left.element) < 0?rotateWithLeftChild(parent.left):rotateWithRightChild(parent.left);
				// LR
			else
				return parent.right = item.CompareTo(parent.right.element) < 0?rotateWithLeftChild(parent.right):rotateWithRightChild(parent.right);
			// RR
		}
Пример #10
0
		/// <summary> Internal method to print a subtree in sorted order.
		/// </summary>
		/// <param name="t">the node that roots the tree.
		///
		/// </param>
		private void PrintTree(RedBlackNode t)
		{
			if (t != nullNode)
			{
				PrintTree(t.left);
				System.Console.Out.WriteLine(t.element);
				PrintTree(t.right);
			}
		}