public void Test1(int[] bstArray, bool expectedResult)
{
BSTTreeNode root = BinarySearchTreeGenerator.GenerateFromArray(bstArray, false);
BinarySearchTreeValidationSolution solution = new BinarySearchTreeValidationSolution();
bool result = solution.Solve(root);
result.Should().Be(expectedResult);
}
public void Test1(int[] bstArray, int[] expectedResult)
{
BSTTreeNode root = BinarySearchTreeGenerator.GenerateFromArray(bstArray, false);
FindModeInBinarySearchTreeSolution solution = new FindModeInBinarySearchTreeSolution();
int[] result = solution.Solve(root);
result.Should().NotBeNull();
result.Length.Should().Be(expectedResult.Length);
//Assuming that the expectedResult array will be sorted
for (int i = 0; i < result.Length; i++)
{
result[i].Should().Be(expectedResult[i]);
}
}
public void MergeSingleNodeTrees()
{
const int firstRootValue = 5;
const int secondRootValue = 10;
BSTTreeNode firstRoot = new BSTTreeNode(firstRootValue);
BSTTreeNode secondRoot = new BSTTreeNode(secondRootValue);
BinaryTreeMergeSolution solution = new BinaryTreeMergeSolution();
BSTTreeNode mergedRoot = solution.Solve(firstRoot, secondRoot);
mergedRoot.Should().NotBeNull();
mergedRoot.left.Should().BeNull();
mergedRoot.right.Should().BeNull();
mergedRoot.val.Should().Be(firstRootValue + secondRootValue);
}
public void Test3(int k, int expectedResult)
{
int[] array =
{
45, 30, 46, 10, 36, -1, 49, 8, 24, 34, 42, 48, -1, 4, 9, 14, 25, 31, 35, 41, 43, 47, -1, 0, 6, -1, -1,
11, 20, -1, 28, -1, 33, -1, -1, 37, -1, -1, 44, -1, -1, -1, 1, 5, 7, -1, 12, 19, 21, 26, 29, 32, -1, -1,
38, -1, -1, -1, 3, -1, -1, -1, -1, -1, 13, 18, -1, -1, 22, -1, 27, -1, -1, -1, -1, -1, 39, 2, -1, -1,
-1, 15, -1, -1, 23, -1, -1, -1, 40, -1, -1, -1, 16, -1, -1, -1, -1, -1, 17
};
BSTTreeNode root = BinarySearchTreeGenerator.GenerateFromArray(array);
KthSmallestElementSolution solution = new KthSmallestElementSolution();
int result = solution.Solve(root, k);
result.Should().Be(expectedResult);
}
public void Test1(int k, int expectedResult)
{
BSTTreeNode root = new BSTTreeNode(3);
BSTTreeNode rootLeft = new BSTTreeNode(1);
root.left = rootLeft;
BSTTreeNode rootRight = new BSTTreeNode(4);
root.right = rootRight;
BSTTreeNode rootLeftRight = new BSTTreeNode(2);
rootLeft.right = rootLeftRight;
KthSmallestElementSolution solution = new KthSmallestElementSolution();
int result = solution.Solve(root, k);
result.Should().Be(expectedResult);
}
public void Merge_RootWithLeftChild_RootWithoutChildren()
{
const int firstRootValue = 5;
const int secondRootValue = 10;
const int leftChildValue = 2;
BSTTreeNode firstRoot = new BSTTreeNode(firstRootValue);
BSTTreeNode secondRoot = new BSTTreeNode(secondRootValue);
BSTTreeNode leftChild = new BSTTreeNode(leftChildValue);
firstRoot.left = leftChild;
BinaryTreeMergeSolution solution = new BinaryTreeMergeSolution();
BSTTreeNode mergedRoot = solution.Solve(firstRoot, secondRoot);
mergedRoot.Should().NotBeNull();
mergedRoot.left.Should().NotBeNull();
mergedRoot.left.val.Should().Be(leftChildValue);
mergedRoot.left.left.Should().BeNull();
mergedRoot.left.right.Should().BeNull();
mergedRoot.right.Should().BeNull();
mergedRoot.val.Should().Be(firstRootValue + secondRootValue);
}
public void MergeCustomTrees()
{
//create left tree
BSTTreeNode leftTreeRoot = new BSTTreeNode(1);
BSTTreeNode leftTreeNode1 = new BSTTreeNode(3);
leftTreeRoot.left = leftTreeNode1;
BSTTreeNode leftTreeNode2 = new BSTTreeNode(2);
leftTreeRoot.right = leftTreeNode2;
BSTTreeNode lefTreeNode3 = new BSTTreeNode(5);
leftTreeNode1.left = lefTreeNode3;
//create right child
BSTTreeNode rightTreeRoot = new BSTTreeNode(2);
BSTTreeNode rightTreeNode1 = new BSTTreeNode(1);
rightTreeRoot.left = rightTreeNode1;
BSTTreeNode rightTreeNode2 = new BSTTreeNode(3);
rightTreeRoot.right = rightTreeNode2;
BSTTreeNode rightTreeNode3 = new BSTTreeNode(4);
rightTreeNode1.right = rightTreeNode3;
BSTTreeNode rightTreeNode4 = new BSTTreeNode(7);
rightTreeNode2.right = rightTreeNode4;
BinaryTreeMergeSolution solution = new BinaryTreeMergeSolution();
BSTTreeNode mergedRoot = solution.Solve(leftTreeRoot, rightTreeRoot);
mergedRoot.Should().NotBeNull();
mergedRoot.val.Should().Be(3);
BSTTreeNode mergedRootLeft = mergedRoot.left;
mergedRootLeft.Should().NotBeNull();
mergedRootLeft.val.Should().Be(4);
BSTTreeNode mergedRootRight = mergedRoot.right;
mergedRootRight.Should().NotBeNull();
mergedRootRight.val.Should().Be(5);
BSTTreeNode mergedRootLeftLeft = mergedRootLeft.left;
mergedRootLeftLeft.Should().NotBeNull();
mergedRootLeftLeft.val.Should().Be(5);
mergedRootLeftLeft.left.Should().BeNull();
mergedRootLeftLeft.right.Should().BeNull();
BSTTreeNode mergedRootLeftRight = mergedRootLeft.right;
mergedRootLeftRight.Should().NotBeNull();
mergedRootLeftRight.val.Should().Be(4);
mergedRootLeftRight.left.Should().BeNull();
mergedRootLeftRight.right.Should().BeNull();
mergedRootRight.left.Should().BeNull();
BSTTreeNode mergedRootRightRight = mergedRootRight.right;
mergedRootRightRight.Should().NotBeNull();
mergedRootRightRight.val.Should().Be(7);
mergedRootRightRight.left.Should().BeNull();
mergedRootRightRight.right.Should().BeNull();
}
