Note8：数据结构，顺序表，链表，栈，队列

一，数据结构

    数据是一个抽象的概念，将其进行分类后得到程序设计语言中的基本类型。如：int，float，char等。数据元素之间不是独立的，存在特定的关系，这些关系便是结构。数据结构指数据对象中数据元素之间的关系。

    Python给我们提供了很多现成的数据结构类型，这些系统自己定义好的，不需要我们自己去定义的数据结构叫做Python的内置数据结构，比如列表、元组、字典。而有些数据组织方式，Python系统里面没有直接定义，需要我们自己去定义实现这些数据的组织方式，这些数据组织方式称之为Python的扩展数据结构，比如栈，队列等。

二，顺序表

    1.概念

    将元素顺序地存放在一块连续的存储区里，元素间的顺序关系由它们的存储顺序自然表示

    2.顺序表中相同数据类型的存储方式

    在32位操作系统中，一个整型数据是点4字节的，它是如何在内存中存储的呢？一个存储单元有8位，也就是一个字节。所以一个整型数据点了4个连续的存储单元。如图：

    

   假如有4个整型数据，它的存储方式如图：

    

    3.顺序表中不同数据类型存储方式

    我们知道，不同类型数据所占的存储空间大小不一致，那怎么才能存储的不同类型的数据呢，例如python的列表中既可以存储整型数据，又可以存储字符串。想要达到顺序表中的连续存储，有一种元素外置顺序表，很好的解决了这个问题。元素外置是将连续数据的存储改为连续数据的物理地址的存储。原本要某个数据，我们改为存储它的物理地址，这样就可以由它的物理地址找到数据本身了，内存就可以另外开辟一个空间来存储数据了。如图：

    

 

    4.顺序表的结构

    一个顺序表的完整信息包括两部分，一部分是表中的元素集合，另一部分是为实现正确操作而需记录的信息，即有关表的整体情况的信息，这部分信息主要包括元素存储区的容量和当前表中已有的元素个数两项。

    

    5 .顺序表的基本实现方式

    

    图a为一体式结构，存储表信息的单元与元素存储区以连续的方式安排在一块存储区里，两部分数据的整体形成一个完整的顺序表对象。一体式结构整体性强，易于管理。但是由于数据元素存储区域是表对象的一部分，顺序表创建后，元素存储区就固定了。

    图b为分离式结构，表对象里只保存与整个表有关的信息（即容量和元素个数），实际数据元素存放在另一个独立的元素存储区里，通过链接与基本表对象关联。

    

    6.元素存储区替换

    一体式结构由于顺序表信息区与数据区连续存储在一起，所以若想更换数据区，则只能整体搬迁，即整个顺序表对象（指存储顺序表的结构信息的区域）改变了。

    分离式结构若想更换数据区，只需将表信息区中的数据区链接地址更新即可，而该顺序表对象不变。

    

    7.动态顺序表

    采用分离式结构的顺序表，若将数据区更换为存储空间更大的区域，则可以在不改变表对象的前提下对其数据存储区进行了扩充，所有使用这个表的地方都不必修改。只要程序的运行环境（计算机系统）还有空闲存储，这种表结构就不会因为满了而导致操作无法进行。人们把采用这种技术实现的顺序表称为动态顺序表，因为其容量可以在使用中动态变化。

    总结：

    python中的list是一种采用分离式技术实现的动态顺序表。这就可以解释python中为什么不用定义数据类型而C语言需要？

    例如python中 a = 10 和C语言中的 int a = 10。python中a存放的是指向对象10的地址。所以当a换数据类型的时候，更改a中的地址即可。而C语言中，a中存放的就是10，所以想要改变a的数据类型时就会报错。python中的‘=’就是指向这个的地址的对象的引用。总之，Python变量只是存储着指向对象的地址。

三，链表

    1.单向链表

    单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。

    

    用python实现一个单向链表：

    

class Note(object):
    """创建节点类"""
    def __init__(self, item):
        self.item = item
        self.next = None


class SingleLinkList(object):
    """创建链表"""
    def __init__(self):
        self.__head = None

    def is_empty(self):
        """链表是否为空"""
        return self.__head is None

    def length(self):
        """链表长度"""
        cur = self.__head
        count = 0
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历整个链表"""
        cur = self.__head
        while cur is not None:
            print(cur.item, end=' ')
            cur = cur.next
        print('')

    def add(self, item):
        """链表头部添加元素"""
        note = Note(item)
        note.next = self.__head  # 新的节点的next指向原先的节点
        self.__head = note       #将头指向新的节点

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

    def insert(self, pos, item):
        """指定位置添加元素"""
        if pos <= 0:
            self.add(item)
        elif pos >= self.length():
            self.append(item)
        else:
            note = Note(item)
            pre = self.__head
            count = 1
            while count < pos:
                pre = pre.next
                count += 1
            note.next = pre.next  # 将新节点的next记为原先的节点
            pre.next = note  # 将此节点的的next记为新的节点

    def remove(self, item):
        """删除节点"""
        cur = self.__head
        pre = None
        while cur != None:
            if cur.item == item:
                if cur == self.__head:
                    self.__head = cur.next
                else:
                    pre.next = cur.next
                return
            else:
                pre = cur
                cur = cur.next
        print('ValueError: ll.remove(item): item not in ll')

    def search(self, item):
        """查找节点是否存在"""
        cur = self.__head
        while cur != None:
            if cur.item == item:
                return True
            cur = cur.next
        return False


if __name__ == '__main__':
    ll = SingleLinkList()
    ll.append(2)
    ll.append(3)
    ll.append(5)
    ll.append(6)
    print(ll.length())
    ll.insert(2, 4)
    ll.insert(0, 1)
    ll.insert(8, 7)
    ll.travel()
    print(ll.search(1))
    print(ll.search(999))
    ll.remove(1)
    ll.remove(3)
    ll.remove(999)
    print('*'*30)
    ll.travel()

    2.双向链表

    一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。

    

    python实现双向链表

    

class Note(object):
    """创建结点"""

    def __init__(self, item):
        self.item = item
        self.prev = None
        self.next = None


class DoubleLinkList(object):
    """创建双链表"""

    def __init__(self):
        self.__head = None

    def is_empty(self):
        """链表是否为空"""
        return self.__head is None

    def length(self):
        """链表长度"""
        cur = self.__head
        count = 0
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历整个链表"""
        cur = self.__head
        while cur is not None:
            print(cur.item, end=' ')
            cur = cur.next
        print('')

    def add(self, item):
        """链表头部添加元素"""
        note = Note(item)
        if self.__head is None:
            self.__head = note
        else:
            note.next = self.__head #新结点的下一个结点指向原先的头结点
            self.__head = note #头结点指向新结点
            note.next.prev = note #原先的头结点的前一个结点指向新结点

    def append(self, item):
        """链表尾部添加元素"""
        note = Note(item)
        cur = self.__head
        if self.is_empty():
            self.__head = note
        else:
            while cur.next is not None:
                cur = cur.next
            cur.next = note
            note.prev = cur

    def insert(self, pos, item):
        """指定位置添加元素"""
        if pos <= 0:
            self.add(item)
        elif pos >= self.length():
            self.append(item)
        else:
            note = Note(item)
            cur = self.__head
            count = 0
            while count < pos:
                cur = cur.next
                count += 1
            note.next = cur #新结点的next为当前结点
            cur.prev.next = note #当前结点的原先prev结点的next记为新结点
            note.prev = cur.prev #新结点的prev改为当前结点的原先前一个结点
            cur.prev = note  #当前结点的原先结点改为当前结点

    def remove(self, item):
        """删除节点"""
        cur = self.__head
        while cur != None:
            if cur.item == item:
                if cur.next != None:
                    cur.next.prev = cur.prev
                if cur.prev == None:
                    self.__head = cur.next
                else:
                    cur.prev.next = cur.next
                return
            cur = cur.next
        print('ValueError: ll.remove(item): item not in ll')

    def search(self, item):
        """查找节点是否存在"""
        cur = self.__head
        while cur != None:
            if cur.item == item:
                return True
            cur = cur.next
        return False

if __name__ == '__main__':
    dl = DoubleLinkList()
    dl.append(1)
    dl.remove(1)
    dl.append(2)
    dl.append(3)
    print('length:',dl.length())
    dl.travel()
    dl.insert(0,0)
    dl.insert(1,0.5)
    dl.insert(8,4)
    dl.travel()
    dl.remove(0)
    dl.remove(4)
    dl.remove(0.5)
    dl.remove(100)
    dl.travel()
    print(dl.search(10))
    print(dl.search(2))

    3.单向循环链表

    单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。

    

    python中单向循环链表的实现

    

class Note(object):
    """创建一个结点"""
    def __init__(self, item):
        self.item = item
        self.next = None


class SingleCircleList(object):
    """创建单向循环链表"""

    def __init__(self):
        self.__head = None

    def is_empty(self):
        """链表是否为空"""
        return self.__head is None

    def length(self):
        """链表长度"""
        cur = self.__head
        if self.is_empty():
            return 0
        else:
            count = 1
            while cur.next != self.__head:
                count += 1
                cur = cur.next
            return count

    def travel(self):
        """遍历整个链表"""
        if self.is_empty():
            return
        cur = self.__head
        while cur.next != self.__head:
            print(cur.item, end=' ')
            cur = cur.next
        print(cur.item)

    def add(self, item):
        """链表头部添加元素"""
        note = Note(item)
        if self.is_empty():
            self.__head = note
            note.next = note
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            cur.next = note
            note.next = self.__head
            self.__head = note

    def append(self, item):
        """链表尾部添加元素"""
        note = Note(item)
        if self.is_empty():
            self.__head = note
            note.next = note
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            cur.next = note
            note.next = self.__head

    def insert(self, pos, item):
        """指定位置添加元素"""
        if pos <= 0:
            self.add(item)
        elif pos >= self.length():
            self.append(item)
        else:
            note = Note(item)
            pre = self.__head
            count = 1
            while count < pos:
                pre = pre.next
                count += 1
            note.next = pre.next  # 将新节点的next记为原先的节点
            pre.next = note  # 将此节点的的next记为新的节点

    def remove(self, item):
        """删除节点"""
        cur = self.__head
        if cur.next == self.__head:
            #只有一个头结点
            self.__head = None
            return
        pre = None
        while cur.next != self.__head:
            if cur.item == item:
                if cur == self.__head:
                    #若恰好为头结点
                    self.__head = cur.next
                else:
                    pre.next = cur.next
            pre = cur
            cur = cur.next
        if self.__head.item == item:
            cur.next = self.__head
        if cur.item == item:
            pre.next = self.__head

    def search(self, item):
        """查找节点是否存在"""
        if self.is_empty():
            return False
        cur = self.__head
        while cur.next != self.__head:
            if cur.item == item:
                return True
            cur = cur.next
        if cur.item == item:
            return True
        return False

if __name__ == '__main__':
    scl = SingleCircleList()
    print(scl.is_empty())
    print(scl.length())
    scl.travel()
    scl.append(5)
    scl.add(4)
    scl.add(3)
    scl.add(2)
    print(scl.is_empty())
    print(scl.length())
    scl.travel()
    scl.append(6)
    scl.travel()
    scl.insert(0, 1)
    scl.insert(3, 3.5)
    scl.insert(9, 7)
    scl.travel()
    scl.remove(3.5)
    scl.remove(1)
    scl.remove(7)
    scl.travel()
    print(scl.search(1))
    print(scl.search(2))
    print(scl.search(3))

四，栈

    栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。由于栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。

    

    python中利用顺序表实现栈

    

class Stack(object):
    """创建栈，后进先出"""

    def __init__(self):
        self.__list = []

    def push(self, item):
        """添加一个新的元素item到栈顶"""
        self.__list.append(item)

    def pop(self):
        """弹出栈顶元素"""
        self.__list.pop()

    def peek(self):
        """返回栈顶元素"""
        if self.__list:
            return self.__list[-1]
        else:
            return None

    def is_empty(self):
        """判断栈是否为空"""
        return self.__list == []

    def size(self):
        """返回栈的元素个数"""
        return len(self.__list)

if __name__ == '__main__':
    s = Stack()
    print(s.is_empty())
    print(s.peek())
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
    s.pop()
    print(s.peek())
    print(s.size())
    print(s.is_empty())

五，队列   

    1.队列

    队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。

    

    python中实现队列

    

class Queue(object):
    """定义队列类，先进先出，一端进，一端出"""

    def __init__(self):
        self.__list = []

    def enqueue(self, item):
        """往队列中添加一个item元素"""
        self.__list.append(item)

    def dequeue(self):
        """从队列头部删除一个元素"""
        return self.__list.pop(0)

    def is_empty(self):
        """判断一个队列是否为空"""
        return self.__list == []

    def size(self):
        """返回队列的大小"""
        return len(self.__list)

if __name__ == '__main__':
    q = Queue()
    print(q.is_empty())
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    q.enqueue(4)
    print(q.dequeue())
    print(q.is_empty())
    print(q.size())

   

    2. 双端队列

    双端队列（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。

    

    python实现

    

class Dequeue(object):
    """创建两端队列，两端均有出进"""

    def __init__(self):
        self.__list = []

    def is_empty(self):
        """判断双端队列是否为空"""
        return self.__list == []

    def size(self):
        """返回双端队列的大小"""
        return len(self.__list)

    def add_front(self, item):
        """从队头加入一个元素"""
        self.__list.insert(0, item)

    def add_tail(self, item):
        """从队尾加入一个元素"""
        self.__list.append(item)

    def remove_front(self):
        """从队头删除一个元素"""
        return self.__list.pop(0)

    def remove_tail(self):
        """从队尾删除一个元素"""
        return self.__list.pop()