node 获取表单数据 为空_数据结构与算法(python)单向链表篇

链表

数据表的构建需要预先知道数据的大小来申请连续的存储空间, 而在进行扩充的时候又需要进行数据的搬迁, 使用起来不是很灵活.

链表结构可以充分利用计算机内存空间, 实现灵活的内存动态管理. 简单来说就是, 需要存储一个数据就随机分配一个地址空间.

定义

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

链表图

单向链表

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

单链表的节点和单链表

表元素域elem用来存放具体的数据。链接域next用来存放下一个节点的位置(python中的标识)变量p指向链表的头节点(首节点)的位置，从p出发能找到表中的任意节点。

简单来说如图:

单链表的节点及单链表

节点的实现

首先需要定义一个节点, 需要一个__item来存放数据元素, __next来指向下一个节点.

class Node(object):    '''单链表的节点'''    def __init__(self, elem):        # 存放数据元素        self.elem = elem         # 指向下一个数据地址        self.next = None

运行结果图(建议每写完一个功能就调试一遍, 免得最后一起调试的时候问题太多, 保持好习惯. 我这里一个一个上截图太麻烦了, 在写了很多遍的结果上,就直接上最后的调试截图了):

node运行结果图

单链表的操作

将单链表的的常用操作功能进行封装

常见的单链表操作功能如下所示:

• is_empty() 链表是否为空
• length() 链表长度
• travel() 遍历整个链表
• add(item) 链表头部添加元素
• append(item) 链表尾部添加元素
• insert(pos, item) 指定位置添加元素
• remove(item) 删除节点
• search(item) 查找节点是否存在

单链表的实现

大致的功能如下: 初始化一个节点如果有参数传进来就是非空, 没有参数的传递就是空节点.

class SingleLinkList(object):    '''单链表'''    def __init__(self, node=None):        self.__head = node    def is_empty(self):        '''判断单链表是否为空'''    def length(self):        '''需要链表的长度'''    def travel(self):        '''遍历链表'''    def add(self, item):        '''链表的头部添加元素'''    def append(self, item):        '''链表的尾部添加元素, 尾插法'''    def insert(self, pos, item):        '''链表的指定位置添加元素'''    def remove(self, item):        '''链表删除节点'''    def search(self, item):        '''链表搜索元素'''if __name__ == "__main__":    ll = SingleLinkList()

判断链表是否为空

直接通过头结点的判断, 看看是否为空. 如果头结点是None, 那么这个链表也就是空.

def is_empty(self):    '''判断单链表是否为空'''    return self.__head == None

判断链表的长度

对链表进行遍历, 每遍历一个元素count 加一, 直到数据区为none.

def length(self):    '''需要链表的长度'''    # cur 初始时间指向头节点    cur = self.__head    count = 0    # 尾节点指向None, 当达到尾部时    while cur != None:        count += 1        # 将cur向后移动一个节点        cur = cur.next    return count

遍历列表打印全部元素

同样是遍历链表, 遇见一个列表打印一个元素, 使用cur = cur.next来对链表进行移动.

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

头部添加元素

头部添加节点元素

插入节点的next区域指向当前链表的头部, sefl.__head指向node的头部区域

def add(self, item):    '''链表的头部添加元素'''    node = Node(item)    node.next = self.__head    self.__head = node

尾部添加节点元素

直接把最后的元素的next区域指向node节点的头部区域, node节点的next区域已经是none了. 如果是空直接self.__head指向新的节点.

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

指定位置添加元素

链表指定位置添加元素节点

通过pre这个游标对链表进行循环遍历来找到要插入的位置, 先将node.next = pre.next再将pre.next = node, 如果恰巧是在头部和尾部插入节点的话, 直接调用之前的add()和append()方法. 使用pre=pre.next来控制游标的移动.

使用pre来指向指定位置pos的前一个位置pos-1，初始从头节点开始移动到指定位置.

def insert(self, pos, item):    '''链表的指定位置添加元素'''    if pos <= 0:        self.add(item)    elif pos > (self.length() - 1):        self.append(item)    else:        pre = self.__head        count = 0        while count < (pos-1):            pre = pre.next            count += 1        # 循环结束后, pre指向pos-1 的位置        node = Node(item)        node.next = pre.next        pre.next = node

删除节点

删除节点

先找到指定元素, 如果第一个就是要删除的节点, 将头指针指向头节点的后一个节点, 如果不是, 将删除位置前一个节点的next指向删除位置的后一个节点. cur = cur.next来控制移动

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 # 如果使用一个游标直接就是pre.next = pre.next.next            break        else:            pre = cur            cur = cur.next

查找节点是否存在

链表查找节点是否存在，返回True或者False. 直接对链表进行遍历, 如果与给定元素比较相同就放回True, 反之返回False.

def search(self, item):    '''链表搜索元素'''    cur = self.__head    count = -1    while cur != None:        count += 1        if cur.elem == item:            return count        else:            cur = cur.next    return False

测试

对链表进行相应的操作来查看链表是否可以完成相应的功能.

if __name__ == '__main__':    ll = SingleLinkList()    print (ll.is_empty())    print (ll.length())    ll.append(1)    print (ll.is_empty())    print (ll.length())    ll.append(2)    ll.append(3)    ll.append(4)    ll.append(5)    ll.travel()    ll.add(10)    ll.travel()    ll.insert(-1, 100)    ll.travel()    ll.insert(7,1000)    ll.travel()    ll.insert(2, 1111) # 100 10 1111 12345 1000    ll.travel()    print (ll.search(100)) # 0    print (ll.search(10)) # 1    print (ll.search(1)) # 3    print (ll.search(1000)) # 8    ll.travel()    ll.remove(10)    ll.travel()    ll.remove(100)    ll.travel()    ll.remove(1000)    ll.travel()

运行结果如下(建议每写完一个功能就进行相应的测试, 避免最后运行的时候问题太多, 这里为了方便就直接一次性调试, 要不然一张一张上截图太麻烦了.):

单链表功能演示运行结果

链表与顺序表的对比

链表失去了顺序表随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大，但对存储空间的使用要相对灵活。

链表与顺序表的各种操作复杂度如下所示：

单链表与顺序表的复杂度对比图

注意 虽然表面看起来复杂度都是 O(n)，但是链表和顺序表在插入和删除时进行的是完全不同的操作。链表的主要耗时操作是遍历查找，删除和插入操作本身的复杂度是O(1)。顺序表查找很快，主要耗时的操作是拷贝覆盖。因为除了目标元素在尾部的特殊情况，顺序表进行插入和删除时需要对操作点之后的所有元素进行前后移位操作，只能通过拷贝和覆盖的方法进行。