c# 二叉树的创建和各种问题

最近学习了下二叉树，结合网上的各位大神提供的方法，写了个c#的二叉树创建和其他一些方法。

感谢http://blog.csdn.net/luckyxiaoqiang/article/details/7518888#comments WalkingInTheWind博主的博客，学到很多。

二叉树的结构：

public class Node
{
public object Value { get; set; }
public Node Node_left { get; set; }
public Node Node_right { get; set; }

public Node(object value, Node lchild, Node rchild)
{
Value = value;
Node_left = lchild;
Node_right = rchild;
}
public Node(object val)
{
Value = val;
Node_left = null;
Node_right = null;
}
public Node()
{
Value = null;
Node_left = null;
Node_right = null;
}
}

创建二叉树的方法 可以拓展，比如应用的时候传入字符串来创建二叉树什么的

public void BinaryTree(Node node)
{
//二叉树value附值，具体怎么附值根据实际情况自己更改
//附值代码地方 ***--**
if (node.Value == null || String.IsNullOrEmpty(node.Value.ToString()))
return;
node.Node_left = new Node();
BinaryTree(node.Node_left);
if (node.Node_left.Value == null)
node.Node_left = null;
node.Node_right = new Node();
BinaryTree(node.Node_right);
if (node.Node_right.Value == null)
node.Node_right = null;
}

前序遍历

//前序遍历
public void FirstTraversal(Node node)
{
if (node.Value == null)
return;
Console.WriteLine(node.Value);
FirstTraversal(node.Node_left);
FirstTraversal(node.Node_right);
}

中序遍历

//中序遍历
public void MiddleTraversal(Node node)
{
if (node.Value == null)
return;
MiddleTraversal(node.Node_left);
Console.WriteLine(node.Value);
MiddleTraversal(node.Node_right);
}

后序遍历

//后序遍历
public void LastTraversal(Node node)
{
if (node.Value == null)
return;
LastTraversal(node.Node_left);
LastTraversal(node.Node_right);
Console.WriteLine(node.Value);
}

层级遍历

//层级遍历
public void LevelTraversal(Node node)
{
Queue<object> queue = new Queue<object>();
queue.Enqueue(node);
while (queue.Count > 0)
{
Node n = queue.Dequeue() as Node;
Console.WriteLine(node.Value);
if (node.Node_left != null)
{
queue.Enqueue(node.Node_left);
}
if (node.Node_right != null)
{
queue.Enqueue(node.Node_right);
}
}
}

其他面试会遇到的问题

1.求二叉树节点个数

2.求二叉树深度

3.求二叉树第K层节点个数

4.叶子节点个数

5.判断两个二叉树结构是否相同

6.判断二叉树是不是平衡二叉树

7.二叉树的镜像

8.如何判断是不是完全二叉树

//求二叉树中的节点个数
public int GetNodeNum(Node node)
{
if (node.Value == null)
return 0;
return GetNodeNum(node.Node_left) + GetNodeNum(node.Node_right) + 1;
}

//求二叉树的深度
public int GetNodeDepth(Node node)
{
if (node.Value == null)
return 0;
int leftDepth = GetNodeNum(node.Node_left);
int rightDepth = GetNodeNum(node.Node_right);
int depth = leftDepth > rightDepth ? (leftDepth + 1) : (rightDepth + 1);//include current node, so +1
return depth;
}

//求二叉树第K层的节点个数
public int GetNodeNumOnLevel(Node node, int k)
{
if (node == null || k < 1)
return 0;
if (k == 1)
return 1;
int leftNum = GetNodeNumOnLevel(node.Node_left, k - 1);
int rightNum = GetNodeNumOnLevel(node.Node_right, k - 1);
return (leftNum + rightNum);
}

//求二叉树中叶子节点的个数
public int GetLeafNodeNum(Node node)
{
if (node == null)
return 0;
if (node.Node_left == null && node.Node_right == null)
return 1;
int numleft = GetLeafNodeNum(node.Node_left);
int numright = GetLeafNodeNum(node.Node_right);
return (numleft + numright);
}

//判断两棵二叉树是否结构相同
public bool AreSameStruct(Node n1, Node n2)
{
if (n1 == null && n2 == null)
return true;
else if (n1 == null || n2 == null)
return false;
bool leftsame = AreSameStruct(n1.Node_left, n2.Node_left);
bool rightsame = AreSameStruct(n1.Node_right, n2.Node_right);
return (leftsame && rightsame);
}

//判断二叉树是不是平衡二叉树
public bool BalanceTree(Node node, out int height)
{
if (node == null)
{
height = 0;
return true;
}
int heightleft = 0;
bool resultleft = BalanceTree(node.Node_left, out heightleft);
int heightright = 0;
bool resultright = BalanceTree(node.Node_right, out heightright);
if (resultleft && resultright && Math.Abs(heightleft - heightright) < 1)
{
height = Math.Max(heightleft, heightright) + 1;
return true;
}
else
{
height = Math.Max(heightleft, heightright) + 1; ;
return false;
}
}

//求二叉树的镜像
public Node TreeMirror(Node node)
{
if (node == null)
return null;
Node leftnode = TreeMirror(node.Node_left);
Node rightnode = TreeMirror(node.Node_right);
node.Node_left = rightnode;
node.Node_right = leftnode;
return node;
}

//判断二叉树是不是完全二叉树
public bool IsCompleteBinaryTree(Node node)
{
if (node == null)
return false;
Queue<object> queue = new Queue<object>();
queue.Enqueue(node);
bool mustHaveNoChild = false;
bool result = true;
while (queue.Count>0)
{
Node n = queue.Dequeue() as Node;
if (mustHaveNoChild)
{
if (node.Node_left != null || node.Node_right != null)
{
result = false;
break;
}
}
else
{
if (node.Node_left != null && node.Node_right != null)
{
queue.Enqueue(node.Node_left);
queue.Enqueue(node.Node_right);
}
else if (node.Node_left != null && node.Node_right == null)
{
mustHaveNoChild = true;
queue.Enqueue(node.Node_left);
}
else if (node.Node_left == null && node.Node_right != null)
{
result = false;
break;
}
else
{
mustHaveNoChild = true;
}
}
}
return result;
}