Greed algorithom-Huffman Tree

import unittest

class tree:
 left_node  = None
 right_node = None
 value = 0
 string = None

 def __init__(self, left_node, right_node, _val, _str):
  self.left_node = left_node
  self.right_node = right_node
  self.value = _val
  self.string = _str

 def __repr__(self):
  return "value:%d string:%s" %(self.value,self.string)

def make_tree_node(_val, _str):
 return tree(None, None, _val, _str)

def node_list(a):
 nodes=[]
 for ele in a:
  _str, _val = ele
  t = make_tree_node(_val,_str)
  nodes.append(t)
 return nodes

 

class mytest(unittest.TestCase):
 def setUp(self):
  pass
 def tearDown(self):
  pass
 def testStr(self):
  self.assertEqual(str(make_tree_node(10, 'c')),"value:10 string:c")

 def test_remove(self):
  data=[['a',23],['b', 3],['c', 7],['d', 8]]
  remove(data)
  self.assertEqual([['b', 3],['c', 7],['d', 8]], data)

 def test_insert_data(self):
  data=[['b',3],['c',7],['d',8],['a',23]]
  insert_data(data, 10)
  self.assertEqual([['b',3],['c',7],['d',8],['',10],['a',23]], data)

def insert_huffman_node(nodes,root):
 i=0
 while i <len(nodes):
  if nodes[i].value < root.value:
   i = i+1
  else:
   nodes.insert(i, root)
   return
 nodes.append(root)
 return

def build_huffman_tree(nodes,huffman_tree):
 while len(nodes)>1:
  node1 = nodes[0]
  node2 = nodes[1]
  root = tree(node1, node2, node1.value + node2.value, "")
  huffman_tree.append(root)
  remove(nodes)
  remove(nodes)
  insert_huffman_node(nodes,root)
 return root

def insert_data(a,val):
 i =0
 while i < len(a):
  x,y = a[i]
  if (y < val):
   i = i+1
  else:
   a.insert(i, ['',val])
   return
 a.append(val)

def remove(a):
 del a[0]

def insert(a, val):
 i =0
 while i < len(a):
  if (a[i] < val):
   i = i+1
  else:
   a.insert(i, val)
   return
 a.append(val)
 return

def insertNode(nodes, val):
 i = 0
 while i < len(nodes):
  if (nodes[i] < val):
   i = i+1
  else:
   a.insert(i, val)
   return
 a.append(val)
 return
 

def traverse_tree(root):
 if None==root:
  return;
 else:
  print root.value
 traverse_tree(root.left_node)
 traverse_tree(root.right_node)

class code_node:
 string=None
 val= []
 def __init__(self, _str, _val):
  print _val
  print _str
  val=[]
  self.string = _str
  self.val =_val[:]
 

def getCode(root, curCode, huffman_code):
 if (None == root.left_node) and (None == root.right_node):
  node = code_node(root.string, curCode)
  huffman_code.append(node)
 else:
  curCode.append('0')
  getCode(root.left_node, curCode, huffman_code)
  curCode.pop()
  curCode.append('1')
  getCode(root.right_node, curCode, huffman_code)
  curCode.pop()

huffman_tree = []
nodes = node_list([['b',3],['c',7],['d',8],['a',23]])
root = build_huffman_tree(nodes, huffman_tree)

print "getCode------------"
huffman_code = []
getCode(root, [], huffman_code)
for i in huffman_code:
 print i.string, i.val

def huffman_encode(_ch, huffman_code):
 for i in huffman_code:
  if (i.string == _ch):
   return i.val
 return ''

def huffman_str(_str,huffman_code):
 curStr=''
 val=[]
 for ele in _str:
  val=huffman_encode(ele, huffman_code)
  for i in val:
   curStr+=i
 return curStr

def huffman_decode(_str, root):
 node = root
 res =''
 i=0
 while i < len(_str):
  if ('0' == _str[i]):
   node = node.left_node

   if (node.left_node == None) and (node.right_node == None):
    res += node.string
    node = root
  else:
   node = node.right_node

   if (node.left_node == None) and (node.right_node == None):
    res += node.string
    node =root
  i = i+1
 return res
curCode = huffman_str('abc', huffman_code)

print curCode
traverse_tree(root)
print huffman_decode(curCode,root)

if __name__ == "__main__":
 unittest.main()