重新整理数据结构与算法(c#)—— 平衡二叉树[二十三]

前言

因为有些树是这样子的:

这样子的树有个坏处就是查询效率低，因为左边只有一层，而右边有3层，这就说明如果查找一个数字大于根元素的数字，那么查询判断就更多。

解决方法就是降低两边的层数差距:

变成这样。

那么如何这样做呢？

如果右边比左边层次大于1，进行左旋转规格:

如果左边比右边层次大于1，进行右旋转:

为什么是这样处理呢?

我拿左旋转来说:

左边是1，右边是3，那么需要右边的给一层给左边。

这时候就是6作为根节点，6作为根节点，本身呢，就是一颗二叉树。

这时候呢，6大于4，所以4在6的右边，而6的左节点肯定大于4（原理的根节点）小于6，所以作为4的左节点代替，4也就成了6的左节点。

右旋转同理。

旋转会出现的问题

就是这样通过右旋转之后，可能达不到目标。

看上面这张图，右旋转后还是不平衡，为什么会这样呢？原因是这样的，我们来看下本质问题，右旋转干了什么？右旋转其实是重新分配元素的过程。

看我这种图红色部分，其实是将红色部门分给了右边，这时候会存在元素个数差异过大的问题。

那么这时候该怎么办呢?

要让红框部分进行左旋转才行，那么看代码吧。

正文

节点模型:

public class Node
{
	public Node left;

	public Node right;

	int value;

	public int Value { get => value; set => this.value = value; }

	public Node(int value)
	{
		this.Value = value;
	}
	//中序排序
	public void infixOrder()
	{
		if (this.left != null)
		{
			this.left.infixOrder();
		}
		Console.WriteLine(this);
		if (this.right != null)
		{
			this.right.infixOrder();
		}
	}
	//左子树高度
	public int leftHeight() {
		if (left == null)
		{
			return 0;
		}
		return this.left.height();
	}
	//右子树高度
	public int rightHeight() {
		if (right == null)
		{
			return 0;
		}
		return this.right.height();
	}
	//计算高度
	public int height()
	{
		return Math.Max(left==null?0:this.left.height(),right==null?0:this.right.height())+1;
	}
	//进行左旋转
	private void leftRotate()
	{
		Node newNode = new Node(value);
		newNode.left = left;
		newNode.right = right.left;
		//将右节点变成根节点
		value =right.value;
		//原先右节点被抛弃
		right=right.right;
		//左节点设置为
		left = newNode;
	}
	//进行右旋转
	private void rightRotate()
	{
		Node newNode = new Node(value);
		newNode.left = left.right;
		newNode.right = right;
		value = this.left.value;
		left = left.left;
		right = newNode;
	}
	public override string ToString()
	{
		return Value.ToString();
	}
	//增加元素
	public void addNode(Node node)
	{
		if (node.Value < this.Value)
		{
			if (this.left == null)
			{
				this.left = node;
			}
			else
			{
				this.left.addNode(node);
			}
		}
		else {
			if (this.right == null)
			{
				this.right = node;
			}else {
				this.right.addNode(node);
			}
		}
		if (rightHeight() > leftHeight() + 1)
		{
			if (right.leftHeight() > right.rightHeight())
			{
				right.rightRotate();

			}
			this.leftRotate();
		}
		else if (leftHeight() > rightHeight() + 1)
		{
			if (left.rightHeight() > left.leftHeight())
			{
				left.leftRotate();
			}
			this.rightRotate();
		}
	}
	public Node searchParentNode(int value)
	{
		if ((this.left != null && this.left.value == value || (this.right != null && this.right.value == value)))
		{
			return this;
		}
		else
		{
			if (this.value < value && this.left != null)
			{
				return this.left.searchParentNode(value);
			}
			else if (this.value >= value && this.right != null)
			{
				return this.right.searchParentNode(value);
			}
			else
			{
				return null;
			}
		}
	}
	//查找元素
	public Node searchNode(int value)
	{
		if (this.Value == value)
		{
			return this;
		}
		if (this.Value > value)
		{
			if (this.left != null)
			{
				return this.right.searchNode(value);
			}
			else
			{
				return null;
			}
		}
		else
		{
			if (this.left != null)
			{
				return this.left.searchNode(value);
			}
			else
			{
				return null;
			}
		}
	}
}

树模型:

public class BinarySortTree
{
	//根节点
	Node root;

	internal Node Root { get => root; set => root = value; }

	public BinarySortTree(Node root)
	{
		this.Root = root;
	}

	public BinarySortTree() : this(null)
	{

	}

	public void add(Node node)
	{
		if (Root == null)
		{
			Root = node;
		}
		else
		{
			this.Root.addNode(node);
		}
	}

	public void infixOrder()
	{
		if (Root == null)
		{
			Console.WriteLine("root 为空");
		}
		else
		{
			Root.infixOrder();
		}
	}

	public Node searchNode(int value)
	{
		if (Root==null)
		{
			Console.WriteLine("root 为空");
		}
		return Root.searchNode(value);
	}

	public int delRightTreeMin(Node node)
	{
		Node tagert = node;
		while (tagert.left!=null)
		{
			tagert = tagert.left;
		}
		delNode(tagert.Value);
		return tagert.Value;
	}

	public Node searchParentNode(int value)
	{
		if (Root != null)
		{
			return Root.searchParentNode(value);
		}
		return null;
	}

	public void delNode(int value)
	{
		if (Root == null)
		{
			return;
		}
		Node node=searchNode(value);
		if (node == null)
		{
			return;
		}
		if (node.Value == Root.Value)
		{
			Root = null;
			return;
		}
		Node parent = searchParentNode(value);
		if (node.left == null && node.right == null)
		{
			if (parent.left.Value == value)
			{
				parent.left = null;
			}
			else
			{
				parent.right = null;
			}
		}
		else if (node.left != null && node.right != null)
		{
			 //删除左边最大值或者右边最小值,然后修改值为删除的值
			 parent.right.Value=delRightTreeMin(node.right);
		}
		else
		{
			if (node.left != null)
			{
				if (parent.left.Value == value)
				{
					parent.left = node.left;
				}
				else
				{
					parent.right = node.left;
				}
			}
			else {
				if (parent.left.Value == value)
				{
					parent.left = node.right;
				}
				else
				{
					parent.right = node.right;
				}
			}
		}
	}
}

测试代码:

static void Main(string[] args)
{
	int[] arr = { 10, 11, 7, 6, 8, 9 };
	BinarySortTree binarySortTree = new BinarySortTree();
	//循环的添加结点到二叉排序树
	for (int i = 0; i < arr.Length; i++)
	{
		binarySortTree.add(new Node(arr[i]));
	}
	//中序遍历后的数据
	Console.WriteLine("树的高度=" + binarySortTree.Root.height()); //3
	Console.WriteLine("树的左子树高度=" + binarySortTree.Root.leftHeight()); // 2
	Console.WriteLine("树的右子树高度=" + binarySortTree.Root.rightHeight()); // 2
	Console.WriteLine("当前的根结点=" + binarySortTree.Root);//8
	Console.Read();
}

结果: