C implementation of left leaning reactor

I'm Xiaobai Please correct me if there is any mistake

Code up

using System;
// data structure

namespace DataStructure
{
    /// <summary>
    /// Node of left leaning pile
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class LeftistNode<T> where T : IComparable
    {
        public LeftistNode<T> LeftNode { get; set; }
        public LeftistNode<T> RightNode { get; set; }

        public T Key { get; set; }

        public int NPL { get; set; }

        public LeftistNode(LeftistNode<T> leftNode, LeftistNode<T> rightNode, T key)
        {
            LeftNode = leftNode;
            RightNode = rightNode;
            NPL = 0;
            Key = key;
        }
    }

    /// <summary>
    /// Left leaning reactor Apply to ： The most valuable question 、 Simulation problem 、 The problem of greed
    /// </summary>
    /// Include parent node The left child node The right child node Key value and Zero distance
    /// Zero distance ： The length from a node to the nearest dissatisfied node Dissatisfied nodes refer to the left and right child nodes of the node At least one bit is empty   The zero distance of the dissatisfied node is 0 Empty node 0 A distance of -1
    /// Basic properties of left leaning pile
    /// 1. The key value of a node is less than or equal to the key value of its left and right nodes
    /// 2. The zero distance of the left node is greater than that of the right node
    /// 3. The zero distance of the node is equal to the zero distance with children plus 1

    public class LeftistHeap<T> where T : IComparable
    {
        public LeftistNode<T> mRootNode;

        public LeftistHeap()
        {
            mRootNode = null;
        }

        /// <summary>
        /// external Insert
        /// </summary>
        /// <param name="key"></param>
        public void Inset(T key)
        {
            LeftistNode<T> node = new LeftistNode<T>(null, null, key);
            Inset(node);
        }

        /// <summary>
        /// Inside Insert
        /// </summary>
        /// <param name="insetNode"></param>
        private void Inset(LeftistNode<T> insetNode)
        {
            if (insetNode != null)
                this.mRootNode = MergeLeftistHeap(this.mRootNode, insetNode);
        }

        /// <summary>
        /// Delete external
        /// </summary>
        /// <param name="key"></param>
        public void Remove(T key)
        {
            LeftistNode<T> node = new LeftistNode<T>(null, null, key);
            Remove(node);
        }

        /// <summary>
        /// Delete
        /// </summary>
        /// <param name="removeNode"></param>
        private void Remove(LeftistNode<T> removeNode)
        {

        }

        /// <summary>
        /// Merge
        /// </summary>
        /// <param name="heap"></param>
        /// <param name="otherHeap"></param>
        /// <returns></returns>
        ///(01) If an empty left leaning heap is merged with a non empty left leaning heap , Returns a non empty left leaning heap .
        ///(02) If both left leaning piles are not empty , Then compare the two root nodes , Take the root node of the smaller heap as the new root node . take " The right child of the root node of the smaller heap " and " A lot " A merger . 
        ///(03) If the right child of the new pile NPL > Left child's NPL, Then exchange left and right children .
        ///(04) Set the root node of the new heap NPL = Right side pile NPL + 1
        private LeftistNode<T> MergeLeftistHeap(LeftistNode<T> heap, LeftistNode<T> otherHeap)
        {
            if (heap == null)
                return otherHeap;
            if (otherHeap == null)
                return heap;

            LeftistNode<T> newRootNode = heap;

            LeftistNode<T> bigRootNode = otherHeap;

            int cmp = heap.Key.CompareTo(otherHeap.Key);

            if (cmp > 0)
            {
                newRootNode = otherHeap;
                bigRootNode = heap;
            }
            else
            {
                newRootNode = heap;
                bigRootNode = otherHeap;
            }
            newRootNode.RightNode = MergeLeftistHeap(newRootNode.RightNode, bigRootNode);

            if (newRootNode.LeftNode == null || newRootNode.LeftNode.NPL < newRootNode.RightNode.NPL)
            {
                LeftistNode<T> tempNode = newRootNode.LeftNode;
                newRootNode.LeftNode = newRootNode.RightNode;
                newRootNode.RightNode = tempNode;
            }
            if (newRootNode.LeftNode == null || newRootNode.RightNode == null)
                newRootNode.NPL = 0;
            else
                newRootNode.NPL = newRootNode.LeftNode.NPL > newRootNode.RightNode.NPL
                    ? newRootNode.LeftNode.NPL + 1
                    : newRootNode.RightNode.NPL + 1;

            return newRootNode;
        }

        /// <summary>
        /// Merge
        /// </summary>
        /// <param name="otherHeap"></param>
        public void MergeLeftistHeap(LeftistHeap<T> otherHeap)
        {
            this.mRootNode = MergeLeftistHeap(this.mRootNode, otherHeap.mRootNode);
        }

        /// <summary>
        /// Exchange value
        /// </summary>
        /// <param name="node"></param>
        /// <param name="otherNode"></param>
        public void ChangeKey(LeftistNode<T> node, LeftistNode<T> otherNode)
        {
            T temp = node.Key;
            node.Key = otherNode.Key;
            otherNode.Key = temp;
        }

        /// <summary>
        /// The former sequence traversal
        /// </summary>
        /// <param name="heap"></param>
        void PreorderLeftist(LeftistNode<T> root)
        {
            if (root == null) return;
            Console.WriteLine(root.Key);
            PreorderLeftist(root.LeftNode);
            PreorderLeftist(root.RightNode);
        }

        /// <summary>
        /// The former sequence traversal
        /// </summary>
        public void PreorderLeftist()
        {
            if (mRootNode != null)
                PreorderLeftist(mRootNode);
        }

        /// <summary>
        /// In the sequence traversal
        /// </summary>
        /// <param name="heap"></param>
        void InorderLeftist(LeftistNode<T> heap)
        {
            if (heap == null) return;

            PreorderLeftist(heap.LeftNode);
            Console.WriteLine(heap.Key);
            PreorderLeftist(heap.RightNode);
        }

        /// <summary>
        /// In the sequence traversal
        /// </summary>
        public void InorderLeftist()
        {
            if (mRootNode != null)
                InorderLeftist(mRootNode);
        }

        /// <summary>
        /// After the sequence traversal
        /// </summary>
        /// <param name="heap"></param>
        void PostorderLeftist(LeftistNode<T> heap)
        {
            if (heap == null) return;

            PreorderLeftist(heap.LeftNode);
            PreorderLeftist(heap.RightNode);
            Console.WriteLine(heap.Key);
        }

        /// <summary>
        /// After the sequence traversal
        /// </summary>
        public void PostorderLeftist()
        {
            if (mRootNode != null)
                PostorderLeftist(mRootNode);
        }

        /// <summary>
        /// Find the minimum
        /// There is a return 1 No return 0
        /// </summary>
        /// <param name="heap"></param>
        /// <returns></returns>
        public int LeftistMinimum(LeftistNode<T> heap, ref T minKey)
        {
            if (heap == null)
                return 0;
            else
                minKey = heap.Key;

            return 1;

        }

        /// <summary>
        /// Delete
        /// </summary>
        /// <param name="rootNode"></param>
        public void Destroy(LeftistNode<T> rootNode)
        {
            if (rootNode == null) return;

            if (rootNode.LeftNode != null)
                Destroy(rootNode.LeftNode);
            if (rootNode.RightNode != null)
                Destroy(rootNode.RightNode);

            rootNode = null;
        }

        private void Print(LeftistNode<T> node, int direction)
        {
            if (direction == -1)
                Console.WriteLine("NPL ：{0}   Key: {1}    Direction ：{2}", node.NPL.ToString(), node.Key.ToString(),
                    "Root");
            else if (direction == 0)
                Console.WriteLine("NPL ：{0}   Key: {1}    Direction ：{2}", node.NPL.ToString(), node.Key.ToString(),
                    "Left");
            else
                Console.WriteLine("NPL ：{0}   Key: {1}    Direction ：{2}", node.NPL.ToString(), node.Key.ToString(),
                    "Right");
        }

        private void Print(LeftistNode<T> root)
        {

            if (root.LeftNode != null)
            {
                Print(root.LeftNode, 0);
                Print(root.LeftNode);
            }
            if (root.RightNode != null)
            {
                Print(root.RightNode, 1);
                Print(root.RightNode);
            }
        }

        public void Print()
        {
            Print(mRootNode, -1);
            Print(mRootNode);
        }
    }
}