Apuntes_Python/03_arbol_binario/05_valor_minimo.py

#!/usr/bin/env python
"""
    Valor Mínimo de Arbol

    Escribe una función, ValorMinimo, que reciba la raíz de un
    árbol binario que contenga solo valores numericos.
    La función debe retornar el el valor minimo existente
    en el árbol.
    Se puede asumir que el árbol no esta vacío
"""

from arbol_binario import Nodo, ValorMinimo, ValorMinimo2, ValorMinimo3
import unittest
import TestRunner

def test_00():
    """
           3
        /    \
       11     4
      / \      \
     4   -2     1
    tree_min_value(a) # -> -2
    """
    a = Nodo(3)
    b = Nodo(11)
    c = Nodo(4)
    d = Nodo(4)
    e = Nodo(-2)
    f = Nodo(1)
    a.left = b
    a.right = c
    b.left = d
    b.right = e
    c.right = f
    return ValorMinimo(a)


def test_01():
    """
           5
        /    \
       11     3
      / \      \
     4   15     12
    tree_min_value(a) # -> 3
    """
    a = Nodo(5)
    b = Nodo(11)
    c = Nodo(3)
    d = Nodo(4)
    e = Nodo(14)
    f = Nodo(12)
    a.left = b
    a.right = c
    b.left = d
    b.right = e
    c.right = f
    return ValorMinimo(a)


def test_02():
    """
            -1
          /   \
        -6    -5
       /  \     \
     -3   -4   -13
         /       \
        -2       -2
    tree_min_value(a) # -> -13
    """
    a = Nodo(-1)
    b = Nodo(-6)
    c = Nodo(-5)
    d = Nodo(-3)
    e = Nodo(-4)
    f = Nodo(-13)
    g = Nodo(-2)
    h = Nodo(-2)
    a.left = b
    a.right = c
    b.left = d
    b.right = e
    c.right = f
    e.left = g
    f.right = h
    return ValorMinimo(a)

def test_03():
    """
            42
    tree_min_value(a) # -> 42
    """
    a = Nodo(42)
    return ValorMinimo(a)


class ValorMinimoTestCase(unittest.TestCase):

    def test_valor_minimo_00(self):
        self.assertEqual(-2, test_00())

    def test_valor_minimo_01(self):
        self.assertEqual(3, test_01())

    def test_valor_minimo_02(self):
        self.assertEqual(-13, test_02())

    def test_valor_minimo_03(self):
        self.assertEqual(42, test_03())


def test_20():
    a = Nodo(3)
    b = Nodo(11)
    c = Nodo(4)
    d = Nodo(4)
    e = Nodo(-2)
    f = Nodo(1)
    a.left = b
    a.right = c
    b.left = d
    b.right = e
    c.right = f
    return ValorMinimo2(a)


def test_21():
    a = Nodo(5)
    b = Nodo(11)
    c = Nodo(3)
    d = Nodo(4)
    e = Nodo(14)
    f = Nodo(12)
    a.left = b
    a.right = c
    b.left = d
    b.right = e
    c.right = f
    return ValorMinimo2(a)


def test_22():
    a = Nodo(-1)
    b = Nodo(-6)
    c = Nodo(-5)
    d = Nodo(-3)
    e = Nodo(-4)
    f = Nodo(-13)
    g = Nodo(-2)
    h = Nodo(-2)
    a.left = b
    a.right = c
    b.left = d
    b.right = e
    c.right = f
    e.left = g
    f.right = h
    return ValorMinimo2(a)

def test_23():
    a = Nodo(42)
    return ValorMinimo2(a)


class ValorMinimoTestCase2(unittest.TestCase):

    def test_valor_minimo_20(self):
        self.assertEqual(-2, test_20())

    def test_valor_minimo_21(self):
        self.assertEqual(3, test_21())

    def test_valor_minimo_22(self):
        self.assertEqual(-13, test_22())

    def test_valor_minimo_23(self):
        self.assertEqual(42, test_23())



def test_30():
    a = Nodo(3)
    b = Nodo(11)
    c = Nodo(4)
    d = Nodo(4)
    e = Nodo(-2)
    f = Nodo(1)
    a.left = b
    a.right = c
    b.left = d
    b.right = e
    c.right = f
    return ValorMinimo3(a)


def test_31():
    a = Nodo(5)
    b = Nodo(11)
    c = Nodo(3)
    d = Nodo(4)
    e = Nodo(14)
    f = Nodo(12)
    a.left = b
    a.right = c
    b.left = d
    b.right = e
    c.right = f
    return ValorMinimo3(a)


def test_32():
    a = Nodo(-1)
    b = Nodo(-6)
    c = Nodo(-5)
    d = Nodo(-3)
    e = Nodo(-4)
    f = Nodo(-13)
    g = Nodo(-2)
    h = Nodo(-2)
    a.left = b
    a.right = c
    b.left = d
    b.right = e
    c.right = f
    e.left = g
    f.right = h
    return ValorMinimo3(a)

def test_33():
    a = Nodo(42)
    return ValorMinimo3(a)


class ValorMinimoTestCase3(unittest.TestCase):

    def test_valor_minimo_30(self):
        self.assertEqual(-2, test_30())

    def test_valor_minimo_31(self):
        self.assertEqual(3, test_31())

    def test_valor_minimo_32(self):
        self.assertEqual(-13, test_32())

    def test_valor_minimo_33(self):
        self.assertEqual(42, test_33())


if  __name__ == '__main__':
    TestRunner.main()
    #unittest.main()