单向链表、单向循环链表、双向链表（Python实现）

最新推荐文章于 2022-07-30 14:58:00 发布

Andrew___A

最新推荐文章于 2022-07-30 14:58:00 发布

阅读量299

点赞数

Andrew

本文链接：https://blog.csdn.net/Andrew___A/article/details/101082858

版权

单向链表、单向循环链表、双向链表（Python实现）

单向链表
- 链表与顺序表的对比
单向循环链表
双向链表

链表（Linked list）：一种线性表、在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。
在这里插入图片描述

单向链表

单向链表也叫单链表：每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。
在这里插入图片描述

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

# coding:utf-8

class Node():

    """节点"""

    def __init__(self, elem):
        self.elem = elem
        self.next = None

class SingleLinkList():

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

    def __init__(self, node=None):
        self.__head = node

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

    def length(self):
        """链表长度"""
        # cur游标，用来移动遍历节点
        cur = self.__head
        # count记录数量
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

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

    def add(self, item):
        """链表头部添加元素，头插法"""
        node = Node(item)
        node.next = self.__head
        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

    def insert(self, pos, item):
        """指定位置添加元素
        :param  pos 从0开始
        """
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            pre = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            # 当循环退出后，pre指向pos-1位置
            node = Node(item)
            node.next = pre.next
            pre.next = node

    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
                break
            else:
                pre = cur
                cur = cur.next

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

if __name__ == "__main__":
    Sll = SingleLinkList()
    print(Sll.length())
    print(Sll.is_empty())
    for i in range(5):
        Sll.add(i)
        Sll.append(i)
    Sll.insert(3, 15)
    Sll.travel()
    Sll.remove(15)
    print(Sll.search(15))
    print(Sll.length())

输出为：

0
True
4 3 2 15 1 0 0 1 2 3 4
False
10

链表与顺序表的对比

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

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

单向循环链表

单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。
在这里插入图片描述

# coding:utf-8

class Node():

    """节点"""

    def __init__(self, elem):
        self.elem = elem
        self.next = None

class SingleCycleLinkList():

    """
    单向循环链表操作
    is_empty() 判断链表是否为空
    length() 返回链表的长度
    travel() 遍历
    add(item) 在头部添加一个节点
    append(item) 在尾部添加一个节点
    insert(pos, item) 在指定位置pos添加节点
    remove(item) 删除一个节点
    search(item) 查找节点是否存在
    reverse() 反转
    """

    def __init__(self, node=None):
        self.__head = node
        if node:
            node.next = node

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

    def length(self):
        """链表长度"""
        if self.is_empty():
            return 0
        # cur游标，用来移动遍历节点
        cur = self.__head
        # count记录数量
        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.elem, end=" ")
            cur = cur.next
        # 退出循环，cur指向尾节点，但尾节点的元素未打印
        print(cur.elem)

    def add(self, item):
        """链表头部添加元素，头插法"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            # 退出循环，cur指向尾节点
            node.next = self.__head
            self.__head = node
            # cur.next = node
            cur.next = self.__head

    def append(self, item):
        """链表尾部添加元素, 尾插法"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            # node.next = cur.next
            node.next = self.__head
            cur.next = node

    def insert(self, pos, item):
        """指定位置添加元素
        :param  pos 从0开始
        """
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            pre = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            # 当循环退出后，pre指向pos-1位置
            node = Node(item)
            node.next = pre.next
            pre.next = node

    def remove(self, item):
        """删除节点"""
        if self.is_empty():
            return

        cur = self.__head
        pre = None

        while cur.next != self.__head:
            if cur.elem == item:
                # 先判断此结点是否是头节点
                if cur == self.__head:
                    # 头节点的情况
                    # 找尾节点
                    rear = self.__head
                    while rear.next != self.__head:
                        rear = rear.next
                    self.__head = cur.next
                    rear.next = self.__head
                else:
                    # 中间节点
                    pre.next = cur.next
                return
            else:
                pre = cur
                cur = cur.next
        # 退出循环，cur指向尾节点
        if cur.elem == item:
            if cur == self.__head:
                # 链表只有一个节点
                self.__head = None
            else:
                # pre.next = cur.next
                pre.next = self.__head

    def search(self, item):
        """查找结点是否存在"""
        if self.is_empty():
            return False
        cur = self.__head
        while cur.next != self.__head:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        # 退出循环，cur指向尾节点
        if cur.elem == item:
            return True
        return False
        
    def reverse(self):
    	"""单链表结点反转"""
        if self.__head == None:#空结点的情况
            return True
        if self.__head.next == None:#一个结点的情况
            self.__head.next = self.__head
            self.__head.next = None
            return True
        if self.__head.next != None:#两个及以上结点的情况
            if self.__head.next.next == None:  # 两个结点的情况
                self.__head.next.next = self.__head
                self.__head = self.__head.next
                self.__head.next.next = None
                return True
            else:# 三个及以上结点的情况
                pre = self.__head
                cur = self.__head.next
                while cur.next != None: #第二个结点到最后一个结点的情况
                    c = cur.next    #保存下个位置到c
                    cur.next = pre  #当前结点的下一位置赋给当前的前结点
                    pre = cur   #pre移动到当前cur的位置
                    cur = c #cur移动到下个位置
                cur.next = pre  # pre作为cur的下一节点
                self.__head.next = None #首节点的next赋为None，作为尾结点
                self.__head = cur   #cur作为首节点
                return True
        return False


if __name__ == "__main__":
    SCll = SingleCycleLinkList()
    print(SCll.length())
    print(SCll.is_empty())
    for i in range(6):
        SCll.add(i)
        SCll.append(i+1)
    SCll.insert(1, "a")
    SCll.travel()
    SCll.remove("a")
    print(SCll.search("a"))
    print(SCll.length())

输出为：

0
True
5 a 4 3 2 1 0 1 2 3 4 5 6
False
12

双向链表

“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。
![在这里插入图片描述](https://img-blog.csdnimg.cn/20190921081926483.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FuZHJld19fX0E=,size_16,color_FFFFFF,t_70

# coding:utf-8

class Node():

    """结点"""

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


class DoubleLinkList():

    """
    双链表的操作
    is_empty() 判断链表是否为空
    length() 返回链表的长度
    travel() 遍历
    add(item) 在头部添加一个节点
    append(item) 在尾部添加一个节点
    insert(pos, item) 在指定位置pos添加节点
    remove(item) 删除一个节点
    search(item) 查找节点是否存在
    """

    def __init__(self, node=None):
        self.__head = node

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

    def length(self):
        """链表长度"""
        # cur游标，用来移动遍历节点
        cur = self.__head
        # count记录数量
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

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

        # """倒序遍历整个链表"""
        # cur = self.__head
        # while cur.next != None:
        #     cur = cur.next
        # while cur != None:
        #     print(cur.elem,end = " ")
        #     cur=cur.prev
        # print("")

    def add(self, item):
        """链表头部添加元素，头插法"""
        node = Node(item)
        if self.__head == None:
            self.__head = node
        else:
            self.__head.prev = node
            node.next = self.__head
            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, pos, item):
        """指定位置添加元素
        :param  pos 从0开始
        """
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            cur = self.__head
            count = 0
            while count < pos:
                count += 1
                cur = cur.next
            # 当循环退出后，cur指向pos位置
            node = Node(item)
            node.next = cur
            node.prev = cur.prev
            cur.prev.next = node
            cur.prev = node

    def remove(self, item):
        """删除节点"""
        cur = self.__head
        while cur != None:
            if cur.elem == item:
                # 先判断此结点是否是头节点
                # 头节点
                if cur == self.__head:
                    self.__head = cur.next
                    if cur.next:
                        # 判断链表是否只有一个结点
                        cur.next.prev = None
                else:
                    cur.prev.next = cur.next
                    if cur.next:
                        cur.next.prev = cur.prev
                break
            else:
                cur = cur.next

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

if __name__ == "__main__":
    Dll = DoubleLinkList()
    print(Dll.length())
    print(Dll.is_empty())
    for i in range(6):
        Dll.add(i)
        Dll.append(i+1)
    Dll.insert(1, "a")
    Dll.travel()
    Dll.remove("a")
    print(Dll.search("a"))
    print(Dll.length())

输出为：

0
True
5 a 4 3 2 1 0 1 2 3 4 5 6
False
12

Andrew___A

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
单向链表、单向循环链表、双向链表（Python实现）

链表（Linked list）：一种线性表、在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。单向链表单向链表也叫单链表：每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。表元素域elem用来存放具体的数据。链接域next用来存放下一个节点的位置（python中的标识）变量p指向链表的头节点（...
复制链接

扫一扫