递归和非递归输出二叉查找树中所有的节点

首先，我们先来了解一下什么是二叉查找树。

二叉查找树：（1）它是一个二叉树，关于二叉树的概念（每个树节点顶多只有2个子节点，也就是left-child和right-child，并且子节点是有左右之分的）。（2）对于二叉查找树中的每一个节点，它的左节点的value<=根节点的value<=右节点的value

首先我们定义树的数据结构，如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ArithmeticLibrary
{
    public class MyNode
    {
        public int _value;      //节点的value
        public MyNode parent;    //指向root节点
        public MyNode left;   //指向left-child
        public MyNode right;  //指向right-child
    }
}

创建一个二叉查找树，如下：（很简单的创建，本文的重点是在如何递归输出和非递归输出二叉查找树的所有的节点）

 private static MyNode CreateTree()
        {
            MyNode t = new MyNode();
            t._value = 5;
            t.parent = null;
            t.left = null;
            t.right = null;

             MyNode node1=null;

           node1= new MyNode();
            node1._value = 1;
            node1.parent = t;
            node1.left = null;
            node1.right = null;
            t.left = node1;

            MyNode node2 = null;
            node2 = new MyNode();
            node2._value = 3;
            node2.parent = node1;
            node2.left = null;
            node2.right = null;
            node1.right = node2;

            MyNode node3 = null;
            node3= new MyNode();
            node3._value = 2;
            node3.parent = node2;
            node3.left = null;
            node3.right = null;
            node2.left = node3;

            MyNode node4 = null;
            node4 = new MyNode();
            node4._value = 4;
            node4.parent = node2;
            node4.left = null;
            node4.right = null;
            node2.right = node4;

            MyNode node5 = null;
            node5 = new MyNode();
            node5._value =10;
            node5.parent = t;
            node5.left = null;
            node5.right = null;
            t.right = node5;

            MyNode node6 = null;
            node6 = new MyNode();
            node6._value = 6;
            node6.parent = node5;
            node6.left = null;
            node6.right = null;
            node5.left = node6;

            MyNode node7 = null;
            node7 = new MyNode();
            node7._value = 12;
            node7.parent = node5;
            node7.left = null;
            node7.right = null;
            node5.right = node7;

            return t;
        }
如果看这个创建程序看不出图形化的树的结构，你可以按照程序手动的画出树的结构。

递归的输出上面二叉查找树的所有的节点（中序遍历）：

关于二叉树的遍历，有先序遍历，中序遍历，后序遍历。关于中序遍历遍历的定义：先遍历树的左节点，然后根节点，最后右节点。

递归的代码如下：

 private static void InputNodeValue(MyNode node)
        {
            if (node.left == null && node.right==null)
            {
                Console.WriteLine(node._value);
                return; 
            }
            if (node.left != null)
            {
                InputNodeValue(node.left);
            }
            Console.WriteLine(node._value);
            if (node.right!=null)
            {
                InputNodeValue(node.right);
            }
           
        }
可以看出算法的时间复杂度为O(n)

如果采用非递归的方法，此时我们是借用了stack这个辅助的数据结构来做的，代码如下：

 private static void Non_InputNodeValue(MyNode root)
        {
            Stack<MyNode> stack = new Stack<MyNode>();
            if (root != null)
            {
                stack.Push(root);
            }
            while(stack.Count!=0)
            {
                MyNode node = stack.Pop();
                Console.WriteLine(node._value);
                if (node.right != null)
                {
                    stack.Push(node.right);
                }
                if (node.left != null)
                {
                    stack.Push(node.left);
                }
            }
        }
完整的程序还少了一个main函数，如下：

 static void Main(string[] args)
        {
            MyNode root = CreateTree();
            InputNodeValue(root);//递归输出
            Console.WriteLine("********************************************************");
            Non_InputNodeValue(root); //非递归输出，借用了stack
            Console.ReadLine();
        }

转载于:https://www.cnblogs.com/chenping-987123/archive/2010/09/25/1834341.html