python数据结构:bitmap,list链表,树，图

#--coding:utf8--
'''栈'''
class stack1():
def __init__(st,size):
st.stack=[]
st.size=size
st.top = -1
def push(st,content):
if st.full():
print "stack is full!"
else:
st.stack.append(content)
st.top=st.top+1
def full(st):
if st.top == st.size:
return  True
else:
return  False
def empty(st):
if st.top == -1:
print "stack is empty"
else:
print("stack is not empty")
def remove(self):
if st.top == -1:
print "stack is empty"
print "remove st.stack[-1]:%d"%st.stack[-1]
st.stack.pop()
del st.stack[0]

'''树'''
class TRee():
def __init__(self,leftjd=0,rightjd=0,data=0):
self.leftjd = leftjd
self.rightjd = rightjd
self.data = data
class Btree():
def __init__(self,base=0):
self.base = base
def empty(self):
if self.base is 0:
return  True
else:
return  False
def qout(self,jd):
''''前序遍历 NLR 根左右'''
if jd == 0:
return
        print(jd.data)
self.qout(jd.leftjd)
self.qout(jd.rightjd)
def mout(self,jd):
'''中序遍历 LNR 左根中 先遍历左树返回根节点在遍历右树'''
if jd ==0:
return
self.mout(jd.leftjd)
print jd.data
self.mout(jd.rightjd)
def hout(self,jd):
'''后续遍历 LRN 左右根 循环遍历左节点返回根节点在遍历右节点在打印根'''
if jd ==0:
return
self.hout(jd.leftjd)
self.hout(jd.rightjd)
print jd.data

'''链表'''
class Node(object):
def __init__(self, data):
self.data = data
self.next = None

class NodeList(object):
def __init__(self, node):
self.head = node
self.head.next = None
self.end = self.head

def add_node(self, node):
self.end.next = node
self.end = self.end.next

def length(self):
node = self.head
count = 1
while node.next is not None:
count += 1
node = node.next
return count

# delete node and return it's value
def delete_node(self, index):
if index+1 > self.length():
raise IndexError('index out of bounds')
i = 0
node = self.head
while True:
if i==index-1:
break
node = node.next
i += 1
tmp_node = node.next
node.next = node.next.next
return tmp_node.data

def show(self):
node = self.head
node_str = ''
while node is not None:
if node.next is not None:
node_str += str(node.data) + '->'
else:
node_str += str(node.data)
node = node.next
print node_str

# Modify the original position value and return the old value
def change(self, index, data):
if index+1 > self.length():
raise IndexError('index out of bounds')
i = 0
node = self.head
while True:
if i == index:
break
node = node.next
i += 1
tmp_data = node.data
node.data = data
return tmp_data

# To find the location of index value
def find(self, index):
if index+1 > self.length():
raise IndexError('index out of bounds')
i = 0
node = self.head
while True:
if i == index:
break
node = node.next
i += 1
return node.data
'''bitmap'''
class Bitmap():
def __init__(self,max):
self.size=int((max+31-1)/31)
self.array=[0 for i in range(self.size)]
def bitIndex(self,num):
return num % 31
def set(self,num):
elemIndex = num / 31
byteIndex = self.bitIndex(num)
element = self.array[elemIndex]
self.array[elemIndex] = element | (1<<byteIndex)
def test(self,i):
elemIndex = i/31
byteIndex = self.bitIndex(i)
if self.array[elemIndex] & (1<<byteIndex):
return  True
return  False
if __name__ == "__main__":
'''栈'''
st = stack1(10)
for i in range(10,22):
st.push(i)
st.empty()
st.full()
st.remove()
'''树'''
jd1 = TRee(data=8)
jd2 = TRee(data=9)
jd3 = TRee(data=23)
jd4 = TRee(data=36)
jd5 = TRee(data=57)
jd6 = TRee(data=58)
b3 = TRee(jd5,jd6,data=jd3)
b1 = TRee(0,b3,data=jd1)
b4 =TRee(data=jd4)
b2=TRee(0,b4,data=jd2)
base = TRee(b1,b2,data=7)
x = Btree(base)
x.qout(x.base)
'''链表'''
#test case
n1 = Node(0)
n2 = Node(1)
n3 = Node(2)
n4 = Node(3)
n5 = Node(4)
node_list = NodeList(n1)
node_list.add_node(n2)
node_list.add_node(n3)
node_list.add_node(n4)
node_list.add_node(n5)
#node = node_list.delete_node(3)
#print node
#d = node_list.change(0,88)
# data = node_list.find(5)
# print data
node_list.show()

li = list()
li.append(0)
li.append(1)
li.append(2)
li.append(4)
li.append(5)
li.insert(3,3)
for i in li:
print(i)
li.pop(3)
for i in li:
print(i)
'''bitmap'''
#ord()转换成ascii码
#chr()ascii码转成字符串
MAX=ord('z')
suffle_array=[x for x in 'coledraw']
result = []
bitmap = Bitmap(MAX)
for c in suffle_array:
bitmap.set(ord(c))
for i in range(MAX+1):
if bitmap.test(i):
result.append(chr(i))

print ('原始数组：%s' %suffle_array)
print ('排序后的数组：%s' %result)