Python from_values Beispiele

Beispiel #1

from unittest import TestCase

from leetcodepy.binary_tree_level_order_traversal import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()
SOLUTION2 = Solution2()

ROOT1 = trees.from_values(3, 9, 20, None, None, 15, 7)
EXPECTED1 = [[3], [9, 20], [15, 7]]

ROOT2 = trees.from_values(1)
EXPECTED2 = [[1]]

ROOT3 = trees.from_values()
EXPECTED3 = []


class TestBinaryTreeLevelOrderTraversal(TestCase):
    def test1(self):
        self.assertListEqual(EXPECTED1, SOLUTION1.levelOrder(ROOT1))
        self.assertListEqual(EXPECTED2, SOLUTION1.levelOrder(ROOT2))
        self.assertListEqual(EXPECTED3, SOLUTION1.levelOrder(ROOT3))

    def test2(self):
        self.assertListEqual(EXPECTED1, SOLUTION2.levelOrder(ROOT1))
        self.assertListEqual(EXPECTED2, SOLUTION2.levelOrder(ROOT2))
        self.assertListEqual(EXPECTED3, SOLUTION2.levelOrder(ROOT3))

Beispiel #2

from unittest import TestCase

from leetcodepy.construct_binary_tree_from_preorder_and_inorder_traversal import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()

PREORDER1 = [3, 9, 20, 15, 7]
INORDER1 = [9, 3, 15, 20, 7]
EXPECTED1 = trees.from_values(3, 9, 20, None, None, 15, 7)

PREORDER2 = [-1]
INORDER2 = [-1]
EXPECTED2 = trees.from_values(-1)


class TestConstructBinaryTreeFromPreorderAndInorderTraversal(TestCase):
    def test1(self):
        self.assertTrue(trees.equals(EXPECTED1, SOLUTION1.buildTree(PREORDER1, INORDER1)))
        self.assertTrue(trees.equals(EXPECTED2, SOLUTION1.buildTree(PREORDER2, INORDER2)))

Beispiel #3

from unittest import TestCase

from leetcodepy.binary_tree_maximum_path_sum import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()

ROOT1 = trees.from_values(1, 2, 3)
EXPECTED1 = 6

ROOT2 = trees.from_values(-10, 9, 20, None, None, 15, 7)
EXPECTED2 = 42


class TestBinaryTreeMaximumPathSum(TestCase):
    def test1(self):
        self.assertEqual(EXPECTED1, SOLUTION1.maxPathSum(ROOT1))
        self.assertEqual(EXPECTED2, SOLUTION1.maxPathSum(ROOT2))

Beispiel #4

from unittest import TestCase

from leetcodepy.convert_sorted_list_to_binary_search_tree import *
from leetcodepy.utils import linked_lists, trees

SOLUTION1 = Solution1()

HEAD1 = linked_lists.from_values(-10, -3, 0, 5, 9)
EXPECTED1 = trees.from_values(0, -3, 9, -10, None, 5)

HEAD2 = linked_lists.from_values()
EXPECTED2 = trees.from_values()


class TestConvertSortedListToBinarySearchTree(TestCase):
    def test1(self):
        self.assertTrue(
            trees.equals(EXPECTED1, SOLUTION1.sortedListToBST(HEAD1)))
        self.assertTrue(
            trees.equals(EXPECTED2, SOLUTION1.sortedListToBST(HEAD2)))

Beispiel #5

Datei: test_binary_tree_postorder_traversal.py Projekt: qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.binary_tree_postorder_traversal import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()
SOLUTION2 = Solution2()
SOLUTION3 = Solution3()

ROOT1 = trees.from_values(1, None, 2, 3)
EXPECTED1 = [3, 2, 1]

ROOT2 = trees.from_values()
EXPECTED2 = []

ROOT3 = trees.from_values(1)
EXPECTED3 = [1]


class TestBinaryTreePostorderTraversal(TestCase):
    def test1(self):
        self.assertListEqual(EXPECTED1, SOLUTION1.postorderTraversal(ROOT1))
        self.assertListEqual(EXPECTED2, SOLUTION1.postorderTraversal(ROOT2))
        self.assertListEqual(EXPECTED3, SOLUTION1.postorderTraversal(ROOT3))

    def test2(self):
        self.assertListEqual(EXPECTED1, SOLUTION2.postorderTraversal(ROOT1))
        self.assertListEqual(EXPECTED2, SOLUTION2.postorderTraversal(ROOT2))
        self.assertListEqual(EXPECTED3, SOLUTION2.postorderTraversal(ROOT3))

    def test3(self):

Beispiel #6

Datei: test_flatten_binary_tree_to_linked_list.py Projekt: qianbinbin/leetcode

def ROOT3():
    return trees.from_values(0)

Beispiel #7

from unittest import TestCase

from leetcodepy.symmetric_tree import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()
SOLUTION2 = Solution2()

ROOT1 = trees.from_values(1, 2, 2, 3, 4, 4, 3)
EXPECTED1 = True

ROOT2 = trees.from_values(1, 2, 2, None, 3, None, 3)
EXPECTED2 = False


class TestSymmetricTree(TestCase):
    def test1(self):
        self.assertEqual(EXPECTED1, SOLUTION1.isSymmetric(ROOT1))
        self.assertEqual(EXPECTED2, SOLUTION1.isSymmetric(ROOT2))

    def test2(self):
        self.assertEqual(EXPECTED1, SOLUTION2.isSymmetric(ROOT1))
        self.assertEqual(EXPECTED2, SOLUTION2.isSymmetric(ROOT2))

Beispiel #8

Datei: test_recover_binary_search_tree.py Projekt: qianbinbin/leetcode

def ROOT2():
    return trees.from_values(3, 1, 4, None, None, 2)

Beispiel #9

Datei: test_recover_binary_search_tree.py Projekt: qianbinbin/leetcode

def ROOT1():
    return trees.from_values(1, 3, None, None, 2)

Beispiel #10

Datei: test_same_tree.py Projekt: qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.same_tree import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()

P1, Q1 = trees.from_values(1, 2, 3), trees.from_values(1, 2, 3)
EXPECTED1 = True

P2, Q2 = trees.from_values(1, 2), trees.from_values(1, None, 2)
EXPECTED2 = False

P3, Q3 = trees.from_values(1, 2, 1), trees.from_values(1, 1, 2)
EXPECTED3 = False


class TestSameTree(TestCase):
    def test1(self):
        self.assertEqual(EXPECTED1, SOLUTION1.isSameTree(P1, Q1))
        self.assertEqual(EXPECTED2, SOLUTION1.isSameTree(P2, Q2))
        self.assertEqual(EXPECTED3, SOLUTION1.isSameTree(P3, Q3))

Beispiel #11

Datei: test_recover_binary_search_tree.py Projekt: qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.recover_binary_search_tree import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()


def ROOT1():
    return trees.from_values(1, 3, None, None, 2)


EXPECTED1 = trees.from_values(3, 1, None, None, 2)


def ROOT2():
    return trees.from_values(3, 1, 4, None, None, 2)


EXPECTED2 = trees.from_values(2, 1, 4, None, None, 3)


class TestRecoverBinarySearchTree(TestCase):
    def test1(self):
        root1 = ROOT1()
        SOLUTION1.recoverTree(root1)
        self.assertTrue(trees.equals(EXPECTED1, root1))

        root2 = ROOT2()
        SOLUTION1.recoverTree(root2)
        self.assertTrue(trees.equals(EXPECTED2, root2))

Beispiel #12

from unittest import TestCase

from leetcodepy.validate_binary_search_tree import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()
SOLUTION2 = Solution2()
SOLUTION3 = Solution3()

ROOT1 = trees.from_values(2, 1, 3)
EXPECTED1 = True

ROOT2 = trees.from_values(5, 1, 4, None, None, 3, 6)
EXPECTED2 = False


class TestValidateBinarySearchTree(TestCase):
    def test1(self):
        self.assertEqual(EXPECTED1, SOLUTION1.isValidBST(ROOT1))
        self.assertEqual(EXPECTED2, SOLUTION1.isValidBST(ROOT2))

    def test2(self):
        self.assertEqual(EXPECTED1, SOLUTION2.isValidBST(ROOT1))
        self.assertEqual(EXPECTED2, SOLUTION2.isValidBST(ROOT2))

    def test3(self):
        self.assertEqual(EXPECTED1, SOLUTION3.isValidBST(ROOT1))
        self.assertEqual(EXPECTED2, SOLUTION3.isValidBST(ROOT2))

Beispiel #13

from unittest import TestCase

from leetcodepy.path_sum import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()

ROOT1 = trees.from_values(5, 4, 8, 11, None, 13, 4, 7, 2, None, None, None, 1)
TARGETSUM1 = 22
EXPECTED1 = True

ROOT2 = trees.from_values(1, 2, 3)
TARGETSUM2 = 5
EXPECTED2 = False

ROOT3 = trees.from_values()
TARGETSUM3 = 0
EXPECTED3 = False


class TestPathSum(TestCase):
    def test1(self):
        self.assertEqual(EXPECTED1, SOLUTION1.hasPathSum(ROOT1, TARGETSUM1))
        self.assertEqual(EXPECTED2, SOLUTION1.hasPathSum(ROOT2, TARGETSUM2))
        self.assertEqual(EXPECTED3, SOLUTION1.hasPathSum(ROOT3, TARGETSUM3))

Beispiel #14

Datei: test_balanced_binary_tree.py Projekt: qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.balanced_binary_tree import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()

ROOT1 = trees.from_values(3, 9, 20, None, None, 15, 7)
EXPECTED1 = True

ROOT2 = trees.from_values(1, 2, 2, 3, 3, None, None, 4, 4)
EXPECTED2 = False

ROOT3 = trees.from_values()
EXPECTED3 = True


class TestBalancedBinaryTree(TestCase):
    def test1(self):
        self.assertEqual(EXPECTED1, SOLUTION1.isBalanced(ROOT1))
        self.assertEqual(EXPECTED2, SOLUTION1.isBalanced(ROOT2))
        self.assertEqual(EXPECTED3, SOLUTION1.isBalanced(ROOT3))

Beispiel #15

Datei: test_flatten_binary_tree_to_linked_list.py Projekt: qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.flatten_binary_tree_to_linked_list import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()
SOLUTION2 = Solution2()


def ROOT1():
    return trees.from_values(1, 2, 5, 3, 4, None, 6)


EXPECTED1 = trees.from_values(1, None, 2, None, 3, None, 4, None, 5, None, 6)


def ROOT2():
    return trees.from_values()


EXPECTED2 = trees.from_values()


def ROOT3():
    return trees.from_values(0)


EXPECTED3 = trees.from_values(0)


class TestFlattenBinaryTreeToLinkedList(TestCase):

Beispiel #16

Datei: test_sum_root_to_leaf_numbers.py Projekt: qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.sum_root_to_leaf_numbers import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()

ROOT1 = trees.from_values(1, 2, 3)
EXPECTED1 = 25

ROOT2 = trees.from_values(4, 9, 0, 5, 1)
EXPECTED2 = 1026


class TestSumRootToLeafNumbers(TestCase):
    def test1(self):
        self.assertEqual(EXPECTED1, SOLUTION1.sumNumbers(ROOT1))
        self.assertEqual(EXPECTED2, SOLUTION1.sumNumbers(ROOT2))

Beispiel #17

Datei: test_flatten_binary_tree_to_linked_list.py Projekt: qianbinbin/leetcode

def ROOT2():
    return trees.from_values()

Beispiel #18

Datei: test_minimum_depth_of_binary_tree.py Projekt: qianbinbin/leetcode

from unittest import TestCase

from leetcodepy.minimum_depth_of_binary_tree import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()
SOLUTION2 = Solution2()

ROOT1 = trees.from_values(3, 9, 20, None, None, 15, 7)
EXPECTED1 = 2

ROOT2 = trees.from_values(2, None, 3, None, 4, None, 5, None, 6)
EXPECTED2 = 5


class TestMinimumDepthOfBinaryTree(TestCase):
    def test1(self):
        self.assertEqual(EXPECTED1, SOLUTION1.minDepth(ROOT1))
        self.assertEqual(EXPECTED2, SOLUTION1.minDepth(ROOT2))

    def test2(self):
        self.assertEqual(EXPECTED1, SOLUTION2.minDepth(ROOT1))
        self.assertEqual(EXPECTED2, SOLUTION2.minDepth(ROOT2))

Beispiel #19

Datei: test_flatten_binary_tree_to_linked_list.py Projekt: qianbinbin/leetcode

def ROOT1():
    return trees.from_values(1, 2, 5, 3, 4, None, 6)

Beispiel #20

from unittest import TestCase

from leetcodepy.unique_binary_search_trees_ii import *
from leetcodepy.utils import trees

SOLUTION1 = Solution1()

N1 = 3
EXPECTED1 = [
    trees.from_values(1, None, 2, None, 3),
    trees.from_values(1, None, 3, 2),
    trees.from_values(2, 1, 3),
    trees.from_values(3, 1, None, None, 2),
    trees.from_values(3, 2, None, 1)
]

N2 = 1
EXPECTED2 = [trees.from_values(1)]


class TestUniqueBinarySearchTreesII(TestCase):
    def test1(self):
        actual1 = SOLUTION1.generateTrees(N1)
        self.assertEqual(len(EXPECTED1), len(actual1))
        for i in range(len(EXPECTED1)):
            self.assertTrue(trees.equals(EXPECTED1[i], actual1[i]))

        actual2 = SOLUTION1.generateTrees(N2)
        self.assertEqual(len(EXPECTED2), len(actual2))
        for i in range(len(EXPECTED2)):
            self.assertTrue(trees.equals(EXPECTED2[i], actual2[i]))