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)