数据结构——链表

链表

顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行空充时又需要进行数据的搬迁，所以使用起来并不是很灵活。

而链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。

链表的定义：

链表(Linked List)是一种常见的基础数据结构，是一只种类线性表，但是不像顺序表一样连续存储数据，而是在每一个节点(数据存储单元)里存放下一个节点的位置信息(即地址)。 链表的每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

单链表

单向链表也叫单链表，每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 如下图所示：

表元素域elem用来存放具体的数据。

链接域next用来存放下一个节点的位置（python中的标识）。 

变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。

单链表的操作

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

 

单链表的头部添加元素原理图示：

指定位置添加元素原理图示：

删除节点原理图示：

链表与顺序表时间复杂度的对比

 

操作	链表	顺序表
访问元素	O(n)	O(1)
在头部插入/删除	O(1)	O(n)
在尾部插入/删除	O(n)	O(1)
在中间插入/删除	O(n)	O(n)

下面编写代码，实现单链表的封装：

class Node(object):
    """
    单链表节点的封装
    """
    def __init__(self, element):
        self.element = element
        self.next = None

class SingleLink(object):
    """
    单链表的封装
    """
    def __init__(self):
        # 默认情况下链表为空， 没有任何元素
        self.head = None

    def is_empty(self):
        """判断链表是否为空"""
        return self.head == None

    def __len__(self):
        """
        链表长度:
            1. 如果当前链表为空， 直接返回0；
            2. 如果当前链表不为空， 依次遍历链表的每一个元素，计算长度
        """
        if self.is_empty():
            return 0
        else:
            cur = self.head
            length = 0
            while cur != None:
                length += 1
                cur = cur.next
            return length

    def travel(self):
        """遍历链表"""
        if not self.is_empty():
            cur = self.head
            while cur.next != None:
                print(cur.element, end=',')
                cur = cur.next
            print(cur.element)
        else:
            print("空链表")

    def append(self, item):
        """
        尾部添加元素
            1. 先判断链表是否为空，若是空链表，则将head指向新节点
            2. 若不为空，则找到尾部，将尾节点的next指向新节点
        """
        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):
        """
        头部添加元素
            1. 先创建一个保存item值的节点
            2. 将新节点的链接域next指向头节点，即head指向的位置
            3. 将链表的头head指向新节点
        """
        node = Node(item)
        node.next = self.head
        self.head = node

    def insert(self, index, item):
        """
        指定位置添加元素
            1. 若指定位置index为第一个元素之前，则执行头部插入
            2. 若指定位置超过链表尾部，则执行尾部插入
            3. 否则， 找到指定位置
        """
        if index <= 0:
            self.add(item)
        elif index >= len(self):
            self.append(item)
        else:
            node = Node(item)
            count = 0  # 当前位置
            cur = self.head
            while count < index - 1:
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node

    def remove(self, item):
        """
        删除指定元素的节点
        """
        cur = self.head
        pre = None
        while cur != None:
            if cur.element == item:
                if not pre:
                    self.head = cur.next
                else:
                    pre.next = cur.next
                break
            else:
                pre = cur
                cur = cur.next

    def search(self, item):
        """
        判断查找的元素在节点中是否存在， 返回Bool类型
        """
        cur = self.head
        while cur.next != None:
            if cur.element == item:
                return True
            cur = cur.next
        return False

if __name__ == '__main__':
    # 实例化单链表对象
    link = SingleLink()
    # 长度获取
    print("链表长度: ", len(link))
    # 遍历链表
    link.travel()
    print("链表是否为空? ", link.is_empty())

    print("添加元素:")
    link.append(1)
    link.append(2)
    link.add(3)
    link.insert(1, 'hello')
    # 3 'hello' 1 2
    # 长度获取
    print("链表长度: ", len(link))
    # 遍历链表
    link.travel()
    print("链表是否为空? ", link.is_empty())
    print(link.search(2))
    link.remove(1)
    link.travel()
    print(link.search(1))

经过下面的测试，封装的单链表具有上述的功能，具体输出结果如下：

---

 

单向循环链表

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

单向循环链表的操作和单链表的操作基本一样：

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

 

接下来，还是编写代码对单向循环链表进行封装，代码如下，可供参考：

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

class SingleCirLink(object):
    def __init__(self, node = None):
        self.head = node
        if node:
            node.next = node

    def is_empty(self):
        return self.head == None

    def __len__(self):
        if self.is_empty():
            return 0
        else:
            cur = self.head
            length = 1
            while cur.next != self.head:
                length += 1
                cur = cur.next
            return length

    def travel(self):
        if not self.is_empty():
            cur = self.head
            while cur.next != self.head:
                print(cur.element, end=',')
                cur = cur.next
            print(cur.element)
        else:
            print("空链表")

    def append(self, item):
        node = Node(item)
        if self.is_empty():
            self.head = node
            node.next = self.head
        else:
            cur = self.head
            while cur.next != self.head:
                cur = cur.next
            cur.next = node
            node.next = self.head

    def add(self, item):
        node = Node(item)
        if self.is_empty():
            self.head = node
            node.next = self.head
        else:
            node.next = self.head
            cur = self.head
            while cur.next != self.head:
                cur = cur.next
            cur.next = node
            self.head = node

    def insert(self, index, item):
        if index <= 0:
            self.add(item)
        elif index >= len(self):
            self.append(item)
        else:
            node = Node(item)
            count = 0  # 当前位置
            cur = self.head
            while count < index - 1:
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node

    def remove(self, item):
        cur = self.head
        pre = None
        while cur.next != self.head:
            if cur.element == item:
                if not pre:
                    self.head = cur.next
                else:
                    pre.next = cur.next
                break
            else:
                pre = cur
                cur = cur.next

    def search(self, item):
        if self.is_empty():
            return False
        cur = self.head
        if cur.element == item:
            return True
        while cur.next != self.head:
            cur = cur.next
            if cur.element == item:
                return True
        return False

if __name__ == '__main__':
    link = SingleCirLink()
    print("链表长度: ", len(link))
    # 遍历链表
    link.travel()
    print("链表是否为空? ", link.is_empty())
    print("添加元素:")
    link.append(1)
    link.append(2)
    link.add(3)
    link.insert(2, 5)
    # 长度获取
    print("链表长度: ", len(link))
    # 遍历链表
    link.travel()
    print("链表是否为空? ", link.is_empty())
    print(link.search(2))
    link.remove(1)
    link.travel()
    print(link.search(1))

经过下面的测试，封装的单向循环链表满足所有的功能，具体的测试输出如下：

---

双向链表 

 每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。如下图所示：

几个关于双向链表的操作图例

（1）头部添加节点

 

步骤：

1. 先创建一个保存item值的节点； 
2. 将新节点的链接域next指向头节点，即head指向的位置； 
3. 将链表的头head指向新节点。 

（2）中间指定位置添加节点

步骤：

1. 若指定位置index为第一个元素之前，则执行头部插入 ；
2. 若指定位置超过链表尾部，则执行尾部插入 ；
3. 否则， 找到指定位置。

（3）尾部添加节点

步骤：

1. 先判断链表是否为空，若是空链表，则将head指向新节点 ；
2. 若不为空，则找到尾部，将尾节点的next指向新节点。

（4）删除指定节点

步骤：

1. 如果删除的是头结点， 指针直接指向头结点的下一个节点；
2. 如果删除的不是头结点， 一直循环， 知道找到要删除的节点元素。 

接下来，对双向链表进行封装，其基本操作同单链表，代码如下：

class Node(object):
    """
    双向链表节点的封装
    """
    def __init__(self, element):
        self.element = element  # 数据域
        # 指针域
        self.next = None  # 指向后继节点的指针
        self.prev = None  # 指向前驱节点的指针

    def __str__(self):
        return self.element

class DuLinkList(object):
    """
    双向链表的封装
    """
    def __init__(self):
        self.head = None

    def is_empty(self):
        """判断双向链表是否为空"""
        return self.head == None

    def __len__(self):
        """获取双向链表的长度"""
        if self.is_empty():
            return 0
        cur = self.head
        linkLen = 0
        while cur:
            cur = cur.next
            linkLen += 1
        return linkLen

    def travel(self):
        """遍历链表元素"""
        if not self.is_empty():
            cur = self.head
            while cur.next != None:
                print(cur.element, end=',')
                cur = cur.next
            print(cur.element)
        else:
            print("空链表")

    def add(self, item):
        """
        头部添加元素
        """
        node = Node(item)
        if self.is_empty():
            self.head = node
        else:
            node.next = self.head
            self.head.prev = node
            self.head = node

    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
            node.prev = cur

    def insert(self, index, item):
        """
        指定位置添加元素
        """
        if index <= 0:
            self.add(item)
        elif index >= len(self):
            self.append(item)
        else:
            node = Node(item)
            count = 0  # 当前位置
            cur = self.head
            while count < index - 1:
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node
            node.prev = cur
            cur.next.prev = node

    def remove(self, item):
        """
        删除指定元素的节点：
        """
        if self.is_empty():
            return
        pre = None
        cur = self.head
        # 如果删除的是头结点， 指针直接指向头结点的下一个节点;
        if cur.element == item:
            self.head = self.head.next
        else:
            while cur:
                if cur.element != item:
                    pre = cur
                    cur = cur.next
                else:
                    # 判断删除的是否为尾部节点， 如果是， 则直接让pre.next指向为None;
                    if not cur.next:
                        pre.next = None
                        break
                    else:
                        # pre.next = pre.next.next
                        pre.next = cur.next
                        cur.next.prev = pre
                        break

    def search(self, item):
        cur = self.head
        while cur:
            if cur.element == item:
                return  True
            cur = cur.next
        else:
            return  False

if __name__ == '__main__':
    link = DuLinkList()
    print("链表长度: ", len(link))
    # 遍历链表
    link.travel()
    print("链表是否为空? ", link.is_empty())

    print("追加结点：")
    for item in range(5):
        link.append(item)  # 0  python 1  2 3 4

    # 长度获取
    print("链表长度: ", len(link))
    # 遍历链表
    link.travel()
    print("链表是否为空? ", link.is_empty())

    print("指定位置插入元素")
    link.insert(1, 'python')
    # 长度获取
    print("链表长度: ", len(link))
    # 遍历链表
    link.travel()
    print("链表是否为空? ", link.is_empty())

    print("删除元素")  # 0  python 1  2 3 4
    link.remove(4)
    link.travel()

    print("查找元素:")
    print(link.search(1))
    print(link.search(10))

经过下面的测试代码，输出为：