【顺序表和链表】【栈和队列】

栈

先进后出
顺序表实现栈（在尾部插入和弹出，时间复杂度为O(1））

class stack(object):
    def __init__(self):
        self.__List = []

    def push(self, item):
        return self.__List.append(item)

    def pop(self):
        return self.__List.pop()

    def size(self):
        return len(self.__List)

    def isempty(self):
        return self.__List == []


if __name__ == "__main__":
    s = stack()

    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
    print(s.size())
    print(s.isempty())
    # b = size(s)
    # print(b)
    for i in range(4):
        print(s.pop())
    print(s.isempty())

单链表实现栈（在头部插入和弹出，时间复杂度为O(1））

队列

普通队列
一端插入另一端弹出
顺序表实现

class queene(object):
    def __init__(self):
        self.__List = []

    def push(self, item):
        return self.__List.append(item)

    def pop(self):
        return self.__List.pop(0)

    def size(self):
        return len(self.__List)

    def isempty(self):
        return self.__List == []


if __name__ == "__main__":
    s1 = queene()
    s1.push(1)
    s1.push(2)
    s1.push(3)
    s1.push(4)
    print(s1.size())
    print(s1.isempty())
    # b = size(s)
    # print(b)
    for i in range(4):
        print(s1.pop())
    print(s1.isempty())

双端队列
相当于两个栈的栈底合并

class doublequeene(object):
    def __init__(self):
        self.__List = []

    def add_rear(self, item):
        return self.__List.insert(0,item)

    def add_front(self, item):
        return self.__List.append(item)
    def out_rear(self):
        return self.__List.pop(-1)

    def out_front(self):
        return self.__List.pop()

    def size(self):
        return len(self.__List)

    def isempty(self):
        return self.__List == []

树

class node(object):
    def __init__(self, ele):
        self.element = ele
        self.left = None
        self.right = None


class tree(object):
    def __init__(self):
        self.root = None

    def add(self, item):
        elm = node(item)
        if self.root is None:
            self.root = elm
            return
        queene = [self.root]
        while queene:
            cur_node = queene.pop(0)
            if cur_node.left is None:
                cur_node.left = elm
                return
            else:
                queene.append(cur_node.left)
            if cur_node.right is None:
                cur_node.right = elm
                return
            else:
                queene.append(cur_node.right)

    def travel(self):
        if self.root is None:
            return
        queene = [self.root]
        while queene:
            cur_node = queene.pop(0)
            print(cur_node.element)
            if cur_node.left is not None:
                queene.append(cur_node.left)
            if cur_node.right is not None:
                queene.append(cur_node.right)

    def front_travel(self, node):
        if node is None:
            return
        print(node.element)
        self.front_travel(node.left)
        self.front_travel(node.right)

    def middle_travel(self, node):
        if node is None:
            return
        self.middle_travel(node.left)
        print(node.element)
        self.middle_travel(node.right)

    def rear_travel(self, node):
        if node is None:
            return
        self.rear_travel(node.left)
        self.rear_travel(node.right)
        print(node.element)


if __name__ == "__main__":
    s2 = tree()
    s2.add(1)
    s2.add(2)
    s2.add(3)
    s2.add(4)
    s2.travel()
    s2.front_travel(s2.root)
    s2.middle_travel(s2.root)
    s2.rear_travel(s2.root)