数据结构之链表

和顺序表相对应，有个链式存储的数据结构，命名曰链表。

单链表

节点中只存储后项节点指针的链表，称为单链表。

# 定义节点
class LinkNode(object):
    def __init__(self, data=None):
        self.data = data
        self.next = None

关于单链表的创建、遍历、插入和删除代码示例如下：

# 2021.11.8
# 链表

# 定义节点
class LinkNode(object):
    def __init__(self, data=None):
        self.data = data
        self.next = None

# 创建链表:头插法
def create_link_list_head(li):
    head = LinkNode(li[0])
    for item in li[1:]:
        node = LinkNode(item)
        node.next = head
        head = node
    return head

# 创建链表： 尾插法
def create_link_list_tail(li):
    head = LinkNode(li[0])
    tail = head
    for item in li[1:]:
        node = LinkNode(item)
        tail.next = node
        tail = node
    return head

# 遍历链表
def print_link_list(link_list):
    while link_list:
        print(link_list.data)
        link_list = link_list.next

# 链表插入:将p_node 插入到cur_node 后面
def insert_link_list(cur_node, p_node):
    p_node.next = cur_node.next
    cur_node.next = p_node

# 链表删除：将cur_node后面节点删除
def delete_link_list(cur_node):
    p_node = cur_node.next
    cur_node.next = p_node.next
    del p_node

if __name__ == '__main__':
    li = [2, 3, 1, 5]
    # 创建和遍历打印
    h = create_link_list_tail(li)
    print_link_list(h)
    # 链表插入节点
    p_node = LinkNode(8)
    insert_link_list(h, p_node)
    print_link_list(h)
    # 链表删除节点
    delete_link_list(h)
    print_link_list(h)

双链表

要找到链表中的某个元素，必须从链表头节点开始，通过节点的next指针依次去查找。而双链表通过节点的前项指针可更为方便地去查找。

双链表节点中除了存储数据，还有前项指针和后项指针。

class DoubleLinkListNode(object):
    def __init__(self, data):
        self.data = data
        self.next = None
        self.pre = None

关于双链表的创建、遍历、插入和删除代码示例如下：

# 2021.11.8
# 双链表

class DoubleLinkListNode(object):
    def __init__(self, data):
        self.data = data
        self.next = None
        self.pre = None

# 双链表创建:头插法
def create_double_link_list_head(li):
    head = DoubleLinkListNode(li[0])
    for item in li[1:]:
        node = DoubleLinkListNode(item)
        node.next = head
        head.pre = node
        head = node
    return head

# 双链表创建：尾插法
def create_double_link_list_tail(li):
    head = DoubleLinkListNode(li[0])
    tail = head
    for item in li[1:]:
        node = DoubleLinkListNode(item)
        tail.next = node
        node.pre = tail
        tail = node
    return head

# 遍历双链表
def print_double_link_list(double_link_list):
    while double_link_list:
        print(double_link_list.data)
        double_link_list = double_link_list.next

# 双链表插入
def insert_double_link_list(cur_node, p_node):
    p_node.next = cur_node.next
    cur_node.next.pre = p_node
    cur_node.next = p_node
    p_node.pre = cur_node

# 双链表删除: 删除cur_node后面的节点p_node
def delete_double_link_list(cur_node):
    p_node = cur_node.next
    cur_node.next = p_node.next
    p_node.next.pre = cur_node
    del p_node

if __name__ == '__main__':
    li = [2, 3, 1, 5]
    # 双链表创建
    h = create_double_link_list_tail(li)
    print_double_link_list(h)
    # 双链表插入
    p_node = DoubleLinkListNode(8)
    insert_double_link_list(h.next, p_node)
    print_double_link_list(h)
    # 双链表删除
    delete_double_link_list(h.next)
    print_double_link_list(h)

小结

链表和顺序表对比：

• 链表插入和删除速度比顺序表要快，复杂度为O(1)；
• 链表节点数据在内存中存储非连续，链表扩充比较方便；
• 链表链式存储为数和图等数据结构做好铺垫。