Пример #1
0
        public void LevelOrderTraversing()
        {
            BinarySearchTreeNode         root  = Root;
            Queue <BinarySearchTreeNode> queue = new Queue <BinarySearchTreeNode>();

            queue.Enqueue(root);
            while (queue.Count != 0)
            {
                BinarySearchTreeNode curNode = queue.Dequeue();
                Console.Write($"{curNode.Data} ");
                if (curNode.LeftChild != null)
                {
                    queue.Enqueue(curNode.LeftChild);
                }
                if (curNode.RightChild != null)
                {
                    queue.Enqueue(curNode.RightChild);
                }
            }
        }
Пример #2
0
        public BinarySearchTreeNode FindNode(long dataToFind, BinarySearchTreeNode root)
        {
            BinarySearchTreeNode curNode = root;

            while (curNode != null)
            {
                if (curNode.Data == dataToFind)
                {
                    return(curNode);
                }
                else if (dataToFind < curNode.Data)
                {
                    curNode = curNode.LeftChild;
                }
                else
                {
                    curNode = curNode.RightChild;
                }
            }
            return(null);
        }
Пример #3
0
        public void AddNewNode(long data)
        {
            BinarySearchTreeNode newNode = new BinarySearchTreeNode();

            newNode.Data = data;

            if (Root == null)
            {
                Root      = new BinarySearchTreeNode();
                Root.Data = data;
                return;
            }

            BinarySearchTreeNode currentNode = Root;

            while (true)
            {
                if (data < currentNode.Data)
                {
                    if (currentNode.LeftChild == null)
                    {
                        currentNode.LeftChild            = newNode;
                        currentNode.LeftChild.ParentNode = currentNode;
                        return;
                    }
                    currentNode = currentNode.LeftChild;
                }
                else
                {
                    if (currentNode.RightChild == null)
                    {
                        currentNode.RightChild            = newNode;
                        currentNode.RightChild.ParentNode = currentNode;
                        return;
                    }
                    currentNode = currentNode.RightChild;
                }
            }
        }
Пример #4
0
 public BinarySearchTree()
 {
     Root = null;
 }
Пример #5
0
        public void GetMedianOfBST(long numberOfNodes)
        {
            if (numberOfNodes == 1)
            {
                Console.WriteLine(Root.Data);
                return;
            }
            long firstMedian  = 0;
            long secondMedian = 0;

            long medianNodeCountFirst  = numberOfNodes / 2;
            long medianNodeCountSecond = medianNodeCountFirst + 1;



            BinarySearchTreeNode curNode = Root;

            while (curNode != null)
            {
                if (curNode.LeftChild == null)
                {
                    medianNodeCountSecond--;
                    if (medianNodeCountSecond == 0)
                    {
                        secondMedian = curNode.Data;
                        break;
                    }
                    else
                    {
                        firstMedian = curNode.Data;
                    }
                    curNode = curNode.RightChild;
                    medianNodeCountFirst--;
                }
                else
                {
                    BinarySearchTreeNode rightMostNodeInLeftSubTree = curNode.LeftChild;

                    while (rightMostNodeInLeftSubTree.RightChild != null && rightMostNodeInLeftSubTree.RightChild != curNode)
                    {
                        rightMostNodeInLeftSubTree = rightMostNodeInLeftSubTree.RightChild;
                    }

                    if (rightMostNodeInLeftSubTree.RightChild == null)
                    {
                        rightMostNodeInLeftSubTree.RightChild = curNode;
                        curNode = curNode.LeftChild;
                    }
                    else
                    {
                        rightMostNodeInLeftSubTree.RightChild = null;
                        medianNodeCountSecond--;
                        if (medianNodeCountSecond == 0)
                        {
                            secondMedian = curNode.Data;
                            break;
                        }
                        else
                        {
                            firstMedian = curNode.Data;
                        }

                        curNode = curNode.RightChild;
                    }
                }
            }

            if (numberOfNodes % 2 == 0)
            {
                Console.WriteLine((firstMedian + secondMedian) / 2);
            }
            else
            {
                Console.WriteLine(secondMedian);
            }
        }
Пример #6
0
 public BinarySearchTreeNode()
 {
     LeftChild  = null;
     ParentNode = null;
     RightChild = null;
 }