数据结构：链表、队列、二叉树 python代码实现

顺序表

顺序表两种存储模式*（顺序和元素外置）：

1. 顺序存储模式：适用于列表中存储的都是同一种元素。
2. 元素外置存储模式：适用于列表中存储不同的元素，先开辟空间存储每一个数据，用顺序表存储列表中每一个元素的地址。

顺序表两种存储结构：（一体式和分离式）

1. 区别在于，当存储的元素超过了顺序表的存储容量时，分离式存储结构的标头不需要再次申请地址，只需要改变标头中第三次元素(存储元素的第一个地址，即200所在的地址0x23)

顺序表和链表的区别

1. 时间复杂度不同
   2.链表是将零散的内存空间利用起来，但也增加了地址的存储。
   3.如在中间删除操作，同样是o(n)，链表主要工作是在查找元素，但是顺序表是为了腾空间。

单链表代码实现

class Node(object):
    def __init__(self,elem):
            self.elem = elem
            self.next = None

class Single_link(object):
    def __init__(self,node = None):
        self.__head = node

    def is_empty(self):
        return self.__head == None  #布尔类型

    def length(self):
        cur = self.__head # cur.next 表示的是一个存在的节点， 如果不存在就会报错
        count = 0
        while cur!= None:
            cur = cur.next
            count += 1
        return count

    def travel(self):
        """遍历"""
        cur = self.__head
        while cur !=None:
            print(cur.elem,end=' ')
            cur = cur.next
        print(' ')

    def append(self,item):
        """链表尾部添加元素"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            cur.next = node
    def add(self, item):
        """链表头部添加元素"""
        node = Node(item)
        node.next =self.__head
        self.__head = node

    def insert(self, pos, item):
        """链表指定位置添加元素"""
        if pos <= 0:
            self.add(item)
        elif pos > self.length():
            self.append(item)
        else:
            count = 0
            pro_cur = self.__head

            while count < pos-1:
                pro_cur = pro_cur.next
                count += 1
            node = Node(item)
            node.next = pro_cur.next
            pro_cur.next = node


    def remove(self, item):
            '''删除某个数字'''
            cur = self.__head
            pre = None
            while cur != None:
                if cur.elem == item:
                    if cur == self.__head:
                        self.__head = cur.next
                    else:
                        pre.next = cur.next