您的位置:首页 > 其它

二叉查找树(一)

2011-04-11 23:22 281 查看
  闲着无事,写写二叉查找树用C#的简单实现。
  二叉查找树是二叉树的一种特别类型,特点是小值在父节点的左边,其余值在其右边,对排序、值查找有很好的支持。据说应用很广泛,但是我还没在项目中用到过。
  1,结构分析
  树由节点组成,首先对节点结构进行分析。这里使用双向链表的思想来确定节点与节点间的关系。
    a,属性:
      1,父级节点
      2,左子节点
      3,右子节点
      4,节点数据
为了方便,还加上HasChild属性、重写ToString方法。下面是泛型代码:

public class TreeNode<T>
{
public T Data
{
get;
set;
}

public TreeNode<T> Parent
{
get;
set;
}

public TreeNode<T> Left
{
get;
set;
}

public TreeNode<T> Right
{
get;
set;
}

public bool HasChild
{
get
{
if (this.Left != null || this.Right != null)
{
return true;
}
return false;
}
}

public override string ToString()
{
return string.Format("Data:{0} Parent:{1} Left:{2} Right:{3} HasChild:{4}", Data, Parent == null ? "null" : Parent.Data.ToString(), Left == null ? "null" : Left.Data.ToString(), Right == null ? "null" : Right.Data.ToString(), HasChild.ToString());
}
}


  然后,对树本身结构进行分析。为了防止数据结构在外部被破坏,3个属性都为只读。
    a,私有字段:
      1,根节点
    a,只读属性:
      1,节点数量
      2,最大值
      3,最小值
    b,方法
      1,插入
      2,查找
      3,删除
      5,遍历

  2,算法分析

  插入:
    a,如果根节点为null,设为根节点。
    b,把根节点设为当前节点,如果新节点的值小于当前节点的值,把当前节点设为当前节点的左子节点。反侧,设为其右子节点。直到当前节点的左(右)子节点为null,把新节点插入到这个位置,并把新节点的父级节点设为当前节点。
    c,节点数量加1。

public void Insert(T item)
{
TreeNode<T> node = new TreeNode<T>()
{
Data = item
};
if (root == null)
{
root = node;
}
else
{
TreeNode<T> current = root;
while (current != null)
{
if (current.Data.CompareTo(item) > -1)
{
if (current.Left == null)
{
node.Parent = current;
current.Left = node;
current = null;
}
else
{
current = current.Left;
}
}
else
{
if (current.Right == null)
{
node.Parent = current;
current.Right = node;
current = null;
}
else
{
current = current.Right;
}
}
}
}
count++;
}


  
  最大值、最小值:二叉查找树找最大值和最小值是再容易不过的事了,最底层最左的节点有最小值,最右的节点有最大值。

public T Min
{
get
{
TreeNode<T> current = root;
while (current.Left != null)
{
current = current.Left;
}
return current.Data;
}
}

public T Max
{
get
{
TreeNode<T> current = root;
while (current.Right != null)
{
current = current.Right;
}
return current.Data;
}
}


  
  查找特定值:
    a,把根节点设为当前节点,如果查找值等于当前节点的值,返回当前节点。
    b,如果查找的值小于当前节点的值,把当前节点设为其右子节点。反侧,设为其左子节点。直到当前节点为null,返回null。

public TreeNode<T> Find(T item)
{
TreeNode<T> current = root;
while (!current.Data.Equals(item))
{
if (current.Data.CompareTo(item) < 0)
{
current = current.Right;
}
else
{
current = current.Left;
}
if (current == null)
{
return null;
}
}
return current;
}


  
  遍历:
  二叉查找树常用的3种遍历方法:中序遍历、先序遍历和后序遍历。中序遍历是按照值的升序顺序访问所有节点的,虽然我很想写清楚这3个方法,无赖语文不怎么好,直接上代码吧。

/// <summary>
/// 中序遍历
/// </summary>
/// <param name="node"></param>
private void InOrder(TreeNode<T> node)
{
if (node != null)
{
InOrder(node.Left);
Console.Write(node.Data.ToString() + " ");
InOrder(node.Right);
}
}

/// <summary>
/// 先序遍历
/// </summary>
/// <param name="node"></param>
private void PreOrder(TreeNode<T> node)
{
if (node != null)
{
Console.Write(node.Data.ToString() + " ");
InOrder(node.Left);
InOrder(node.Right);
}
}

/// <summary>
/// 后序遍历
/// </summary>
/// <param name="node"></param>
private void PostOrder(TreeNode<T> node)
{
if (node != null)
{
InOrder(node.Left);
InOrder(node.Right);
Console.Write(node.Data.ToString() + " ");
}
}


    

  删除:
  由于二叉查找树特殊的结构,删除时需要对树进行重构,因此删除算法是比较复杂的。
    a,要删除的节点如果没有子节点,直接删除(去除引用)。
    b,如果有一个子节点,用子节点顶替该节点位置。
    c,如果有两个子节点,使用中序遍历,用该节点的右子节点的最左节点顶替该节点位置。
    d,节点数量减1。
其实删除和顶替,还可以分解为更细的算法步骤,为了理解,所以就不说那么细,直接看代码:

public void Remove(T item)
{
TreeNode<T> current = this.Find(item);
if (current == null)
{
return;
}
this.count--;
bool isLeftNode = false;
if (current != root)
{
isLeftNode = current.Parent.Data.CompareTo(item) == 1;
}
if (current.HasChild)
{
if (current.Left != null && current.Right != null)
{
TreeNode<T> temp = current.Right;
TreeNode<T> node = current.Right;
while (temp != null)
{
node = temp;
temp = temp.Left;
}
if (node.HasChild)
{
node.Right.Parent = node.Parent;
node.Parent.Left = node.Right;
}
else
{
node.Parent.Left = null;
}
node.Parent = current.Parent;

if (node != current.Right)
{
node.Right = current.Right;
current.Right.Parent = node;
}

node.Left = current.Left;
current.Left.Parent = node;

if (current != root)
{
if (isLeftNode)
{
current.Parent.Left = node;
}
else
{
current.Parent.Right = node;
}
}
else
{
this.root = node;
}
}
else
{
if (current == root)
{
this.root = current.Left == null ? current.Right : current.Left;
}
else
{
if (isLeftNode)
{
current.Parent.Left = current.Left == null ? current.Right : current.Left;
}
else
{
current.Parent.Right = current.Right == null ? current.Left : current.Right;
}
}
}
}
else
{
if (current == this.root)
{
this.root = null;
}
else if (isLeftNode)
{
current.Parent.Left = null;
}
else
{
current.Parent.Right = null;
}
}
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: