脚踏实地-算法与数据结构-树

树和图都有点难，以后慢慢修改维护。

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

namespace 源代码
{
    class TreeNode
    {
        public TreeNode lc;
        public TreeNode rc;
        public int value;
        /*
         * 如果用三叉链表表示
         * 
         * 则加入public TreeNode par  表示指向父节点
         * */
        public TreeNode(int value)
        {
            this.value = value;
        }


    }

    class BinaryTreeDs
    {
        public TreeNode head;
        public int Num;
        public BinaryTreeDs()
        {
            Num = 0;
        }
        /// <summary>
        /// 将ti作为新节点的左子树，或者右子树
        /// </summary>
        /// <param name="value"></param>
        /// <param name="t1"></param>
        public void InsertRLC(int value,TreeNode t1)
        {
            TreeNode t = new TreeNode(value);
            t.lc = t1;
        }

        public void Insert(int value, TreeNode t1)
        {
            TreeNode t = new TreeNode(value);
            t.lc = t1;
            t.rc = t1.rc;
        }
        /// <summary>
        /// 遍历并找到某一个节点this.value=value的节点
        /// </summary>
        /// <param name="boot"></param>
        /// <param name="value"></param>
        public TreeNode  Search(TreeNode root, int value)
        {
            TreeNode t = root;
            if (!t.value.Equals(value))
            {
                return t ;
            }

            if (t.lc != null)
            {
                return Search(t.lc, value);
            }
            if (t.rc != null)
            {
                return Search(t.rc, value);
            }
            return null;
        }
        /// <summary>
        /// 二叉树的三种遍历方式
        /// </summary>
        /// <param name="t"></param>
        public void inorder(TreeNode t)
        {
            //中序遍历
            if (t.lc != null)
            {
                inorder(t.lc);
                Console.WriteLine(t.lc.value);
                inorder(t.rc);
                //先序遍历

                Console.WriteLine(t.lc.value);
                inorder(t.lc);
                inorder(t.rc);

                //后序遍历
                inorder(t.lc);
                inorder(t.rc);
                Console.WriteLine(t.lc.value);
            }
        }

        /*
         * 哈夫曼树的构造方法，
         * 1  排序，选择权值最小的两个节点，构成左右子树，大的都左，小的都右。
         * 2 两个权值加上，放到原来的里面构成新的节点还是比较找到两个最小的
         */

        /*
         * 至于树就要用到多重链表发来表示了，主要有两个
         * 1 每个节点的指针域等于节点的个数
         * 2 每个节点的指针域  自己做自己的（不太好操作）
         * 
         */
        class DSnode
        {
            public int value;
            public DSnode(int value)
            {
                this.value = value;
            }
            public DSnode [] Fnext;
            public DSnode par;
        }
        class DSnodeLianshi
        {
            public int value=20;
            public int ChildNum=0;
            public DSnodeLianshi(int value, int i)
            {
                this.value = value;
                ChildNum = i;
                for (int i = 0; i < ChildNum ; i++)
                {

                }
                //动态创建数组大小的两种方式  或者用list方法都行
                DSnode[] s = new DSnode[ChildNum];
            }
            //DSnode[] Child=new DSnode[value];
        }


        /// <summary>
        /// 双亲表示法 借助数组的帮助，顺序存储自己构造的类型
        /// 两个字段，一个用来表示孩子的数据，另外一个用来表示
        /// 父节点在数组中的索引的位置。
        /// </summary>
        class ParNode
         {
            public int value;
            public int ParPisthion;
            public ParNode(int value,int i)
            {
                this.value = value;
                this.ParPisthion = i;
            }
        }
        /// <summary>
        /// 孩子链表表示法
        /// 用于个数组一个个的放入节点，然后用一个指针指向他的第一个孩子节点
        /// 
        /// 这个孩子节点在单独一个节点链表，孩子节点有两个信息，第一是所在数组
        /// 中的索引位置，第二是直线下一个孩子节点的索引域
        /// </summary>
        class ChildNode
        {
            public int value;//存放节点所在数组位置的索引
            public ChildNode(int value)
            {
                this.value = value;
            }
            public ChildNode next;//存放指向下一个节点的索引下一个节点
            
        }
        /// <summary>
        /// 孩子双亲表示法，结合上面两种的方式
        ///   孩子节点用三个字段表示
        ///   1 本身的值
        ///   2 节点的父亲在 节点数组中的位置索引
        ///   3 指向第一个孩子节点的索引的位置
        ///   
        /// 至于孩子节点的链表表示的class就与上面那个想通了
        /// 
        /// </summary>
        class ChildParentNode
        {
      public int value;//存放节点所在数组位置的索引
            public ChildParentNode(int value)
            {
                this.value = value;
            }
            public ChildNode next;
            public int PerSuoYin;
        }
        /// <summary>
        /// 孩子兄弟表示法
        /// 节点用三个域表示
        /// 1 表示自己
        /// 2 指向自己第一个孩子
        /// 3 指向自己紧挨着的下一个兄弟，没有就为空
        /// </summary>
        class ChildBroNode
        {
            public int value;
            public ChildBroNode FiChild;
            public ChildBroNode Fibro;

        }
        /// <summary>
        /// 树的遍历，有三种 先序遍历，后序遍历，层序遍历
        /// </summary>
        /// <param name="t"></param>
        public void PreOrder(TreeNode t)
        {
            if (t == null)
            {
                return;
            }
            Console.WriteLine(t.value );
            for (int i = 0; i < t.ChildLength; i++)//孩子的个数，没有做
            {
                     PreOrder (t.Child[i]);
            }

        }
        /// <summary>
        /// 后序遍历   森林的遍历方式也有两种吧
        /// </summary>
        /// <param name="t"></param>
        public void PreOrder(TreeNode t)
        {
            if (t == null)
            {
                return;
            }
           
            for (int i = 0; i < t.ChildLength; i++)//孩子的个数，没有做
            {
                PreOrder(t.Child[i]);
            }
            Console.WriteLine(t.value);
        }

    }
}