コード例 #1
0
ファイル: TreeNode.cs プロジェクト: mukundsh/Playground
        public static TreeNode BuildBalancedTreeFromSortedArray(int[] arr, int startIndex, int endIndex)
        {
            if (startIndex > endIndex)
            {
                return null;
            }

            int mid = (startIndex + endIndex) / 2;
            TreeNode root = new TreeNode(arr[mid]);
            root.Left = BuildBalancedTreeFromSortedArray(arr, startIndex, mid - 1);
            root.Right = BuildBalancedTreeFromSortedArray(arr, mid + 1, endIndex);
            return root;
        }
コード例 #2
0
ファイル: TreeNode.cs プロジェクト: mukundsh/Playground
        public static bool DoesPathWithHeightKExist(TreeNode root, int k)
        {
            if (k < 0)
            {
                return false;
            }

            if (root == null)
            {
                return false;
            }

            if ((root.Left == null && root.Right == null) && k == 0)
            {
                return true;
            }

            return DoesPathWithHeightKExist(root.Left, k - 1) || DoesPathWithHeightKExist(root.Right, k - 1);
        }
コード例 #3
0
ファイル: TreeNode.cs プロジェクト: mukundsh/Playground
        public static List<TreeNode> GetTreeNodesAtKthLevel2(TreeNode root, int k)
        {
            List<TreeNode> result = new List<TreeNode>();

            Queue<TreeNode> oddLevelNodes = new Queue<TreeNode>();

            Queue<TreeNode> evenLevelNodes = new Queue<TreeNode>();

            if (root == null)
            {
                return null;
            }

            if (k == 0)
            {
                result.Add(root);
                return result;
            }

            if (root.Left != null)
            {
                oddLevelNodes.Enqueue(root.Left);
            }

            if (root.Right != null)
            {
                oddLevelNodes.Enqueue(root.Right);
            }

            int currentLevel = 1;
            while (currentLevel < k)
            {
                bool isCurrentLevelOdd = currentLevel % 2 != 1;
                if (isCurrentLevelOdd)
                {
                    while (evenLevelNodes.Count != 0)
                    {
                        var node = evenLevelNodes.Dequeue();
                        if (node.Left != null)
                        {
                            oddLevelNodes.Enqueue(node.Left);
                        }

                        if (node.Right != null)
                        {
                            oddLevelNodes.Enqueue(node.Right);
                        }
                    }
                }
                else
                {
                    while (oddLevelNodes.Count != 0)
                    {
                        var node = oddLevelNodes.Dequeue();
                        if (node.Left != null)
                        {
                            evenLevelNodes.Enqueue(node.Left);
                        }

                        if (node.Right != null)
                        {
                            evenLevelNodes.Enqueue(node.Right);
                        }
                    }
                }

                currentLevel++;
            }

            if (k % 2 == 0)
            {
                return evenLevelNodes.ToArray().ToList();
            }

            return oddLevelNodes.ToArray().ToList();
        }
コード例 #4
0
ファイル: TreeNode.cs プロジェクト: mukundsh/Playground
 public static List<TreeNode> GetTreeNodesAtKthLevel(TreeNode root, int k)
 {
     Dictionary<int, List<TreeNode>> levelToNodesLookup = new Dictionary<int, List<TreeNode>>();
     return null;
 }
コード例 #5
0
ファイル: TreeNode.cs プロジェクト: mukundsh/Playground
        private static void PrintRightViewOfTree(TreeNode root, Dictionary<int, TreeNode> levelToTreeNodeMap, int level)
        {
            if (root == null)
            {
                return;
            }

            if (root.Right != null)
            {
                if (!levelToTreeNodeMap.ContainsKey(level + 1))
                {
                    levelToTreeNodeMap[level + 1] = root.Right;
                }

                PrintRightViewOfTree(root.Right, levelToTreeNodeMap, level + 1);
            }

            if (root.Left != null)
            {
                if (!levelToTreeNodeMap.ContainsKey(level + 1))
                {
                    levelToTreeNodeMap[level + 1] = root.Left;
                }

                PrintRightViewOfTree(root.Left, levelToTreeNodeMap, level + 1);
            }
        }
コード例 #6
0
ファイル: TreeNode.cs プロジェクト: mukundsh/Playground
        private static void InOrderTraversalVariant(TreeNode root, Dictionary<int, List<TreeNode>> distanceToNodesLookup, int currentDistance)
        {
            if (root == null)
            {
                return;
            }

            if (!distanceToNodesLookup.ContainsKey(currentDistance))
            {
                distanceToNodesLookup[currentDistance] = new List<TreeNode>();
            }

            distanceToNodesLookup[currentDistance].Add(root);
            InOrderTraversalVariant(root.Left, distanceToNodesLookup, currentDistance - 1);
            InOrderTraversalVariant(root.Right, distanceToNodesLookup, currentDistance + 1);
        }
コード例 #7
0
ファイル: TreeNode.cs プロジェクト: mukundsh/Playground
        public static void PrintVertically(TreeNode root)
        {
            Dictionary<int, List<TreeNode>> distanceToNodesLookup = new Dictionary<int, List<TreeNode>>();

            InOrderTraversalVariant(root, distanceToNodesLookup, 0);

            List<TreeNode>[] array = distanceToNodesLookup.Values.ToArray();
            int[] keys = distanceToNodesLookup.Keys.ToArray();
            Array.Sort(keys, array);

            foreach (List<TreeNode> treeNodes in array)
            {
                Console.WriteLine(string.Join(" ", treeNodes.Select(s => s.Data)));
            }
        }
コード例 #8
0
ファイル: TreeNode.cs プロジェクト: mukundsh/Playground
        public static void PrintRightViewOfTree(TreeNode root)
        {
            if (root == null)
            {
                return;
            }

            Dictionary<int, TreeNode> levelToTreeNodeMap = new Dictionary<int, TreeNode>();
            levelToTreeNodeMap.Add(0, root);
            PrintRightViewOfTree(root, levelToTreeNodeMap, 0);

            foreach (KeyValuePair<int, TreeNode> keyValuePair in levelToTreeNodeMap)
            {
                Console.WriteLine("{0} : {1}", keyValuePair.Key, keyValuePair.Value.Data);
            }
        }