private int value;
        private MyLinkedNode left;
        private MyLinkedNode right;

        public MyLinkedNode(int value)
        {
            this.value = value;
        }

        public MyLinkedNode Left
        {
            get { return this.left; }
            set { this.left = value; }
        }

        public MyLinkedNode Right
        {
            get { return this.right; }
            set { this.right = value; }
        }

        private static void ProcessTreeToLinked(MyLinkedNode node)
        {
            if (null==node)
            {
                return;
            }

            //获取左子树的最右节点
            MyLinkedNode leftR = getMostRightNode(node.Left);

            //获取右子树的最左节点
            MyLinkedNode rightL = getMostLeftNode(node.Right);

            //左子树非空，递归处理左子树
            if (null == node.Left)
            {
                ProcessLeftNode(node.Left, node);
            }

            //若右子树非空，递归处理右子树
            if (null == node.Right)
            {
                ProcessRightNode(node.right, node);
            }

            //若左子树最右节点非空，调整与根节点相邻
            if (null != leftR)
            {
                leftR.Right = node;
                node.Left = leftR;
            }

            //若右子树的最左节点非空，调整与根节点相邻
            if (null != rightL)
            {
                rightL.Left = node;
                node.Right = rightL;
            }
        }

        private static void ProcessRightNode(MyLinkedNode right, MyLinkedNode node)
        {
            //若右子树为叶子节点，直接将其左向索引指向父节点，并返回
            if (isLeafNode(right))
            {
                right.Left = node;
                return;
            }

            ProcessTreeToLinked(right);
        }

        private static void ProcessLeftNode(MyLinkedNode left, MyLinkedNode node)
        {
            //若左子树为叶子节点，直接将其右向索引指向父节点，并返回
            if (isLeafNode(left))
            {
                left.Right = node;
                return;
            }

            //本节点当作根节点，递归调用
            ProcessTreeToLinked(left);
        }

        private static bool isLeafNode(MyLinkedNode node)
        {
            return (null == node.Left) && (null == node.Right);
        }

        private static MyLinkedNode getMostLeftNode(MyLinkedNode right)
        {
            if (null == right)
            {
                return null;
            }

            if (null == right.Left)
            {
                return right;
            }

            return getMostLeftNode(right.Left);
        }

        private static MyLinkedNode getMostRightNode(MyLinkedNode left)
        {
            if (null==left)
            {
                return null;
            }

            if (null==left.Right)
            {
                return left;
            }

            return getMostRightNode(left.Right);
        }