顺序表和链表

顺序表

- 集合中存储的元素是有顺序的，顺序表的结构可以分为两种形式：但数据类型和多数据类型

- python中的列表和元组就书序多数据类型的顺序表

- 单数据类型顺序表的内存是连续开启

- 多数据类型顺序表的内存是非连续开辟

- 顺序表的弊端：顺序表的结构需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁

链表：相对顺序表，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理且进行扩充时不需要进行数据搬迁

- 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是每一个节点（数据存储单元）里存放下一个节点的信息（地址）

. is_empty()：链表是否为空

. length()：链表长度

. travel()：遍历整个链表

. add(item)：链表头部添加元素

. append(item)：链表尾部添加元素

. insert(pos, item)：指定位置添加元素

. remove(item)：删除节点

. search(item)：查找节点是否存在

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


class Link():
    #构建出一个空的链表
    def __init__(self):
        self._head = None #永远指向链表中的头节点
        #想链表的头部插入节点
    def add(self,item):
        node = Node(item)
        node.next = self._head
        self._head = node
        
    def travel(self):   
        cur = self._head
        #链表为空则输出‘链表为空’
        if self._head == None:
            print('链表为空！')
        while cur:
            print(cur.item)
            cur = cur.next
    def isEmpty(self):
        return self._head == None
    def length(self):
        cur = self._head
        count = 0
        while cur:
            count += 1
            cur = cur.next
        return count          
    def search(self,item):
        cur = self._head
        find = False
        while cur:
            if cur.item == item:
                find = True
                break
            cur = cur.next
        return find
    
    def append(self,item):
        node = Node(item)
        #链表为空的情况
        if self._head == None:
            self._head = node
            return
        
        cur = self._head #头节点
        pre = None #cur的前一个节点
        while cur:
            pre = cur
            cur = cur.next
        pre.next = node
        
    def insert(self,pos,item):
        node = Node(item)
        
        if pos < 0 or pos > self.length():
            print('重新给pos赋值！！！')
            return
        
        cur = self._head
        pre = None
        
        for i in range(pos):
            pre = cur
            cur = cur.next
        pre.next = node
        node.next = cur
    def remove(self,item):
        cur = self._head
        pre = None
        
        if self._head == None:#链表为空
            print('链表为空，没有可删除的节点！！1')
            return
    
        
        #删除的是第一个节点的情况
        if self._head.item == item:
            self._head = self._head.next
            return
        
        #删除的是非第一个节点的情况
        while cur:
            pre = cur
            cur = cur.next
            if cur.item == item:
                pre.next = cur.next
                return

link = Link()
link.add(3)
link.add(4)
link.add(5)
link.add(6)

link.remove(3)

link.travel()