单链表，双向链表以及单向循环链表的基本实现（python）

最新推荐文章于 2022-09-24 21:51:06 发布

qq_43609939

最新推荐文章于 2022-09-24 21:51:06 发布

阅读量215

点赞数

本文链接：https://blog.csdn.net/qq_43609939/article/details/103100540

版权

单链表的实现

# 结点定义
class Node(object):
    def __init__(self, elem):
        self.elem = elem
        self.next = None

# 链表实现
class SingleLinkList(object):
    def __init__(self, node=None):
        self.__head = node

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

    def length(self):
        cur = self.__head
        count = 0
        while cur is not 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(end="\n")

    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 is not None:
                cur = cur.next
            cur.next = node

    def insert(self, pos, item):
        node = Node(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):
                count += 1
                pre = pre.next
            node.next = pre.next
            pre.next = node

    def remove(self, item):
        cur = self.__head
        pre = None
        while cur is not 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 is not None:
            if cur.elem == item:             
                return True  
            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.insert(2, 93)
    ll.travel()
    ll.append(4)
    ll.append(5)
    ll.add(88)
    ll.append(6)
    ll.travel()
    ll.remove(5)
    ll.travel()
    print(ll.is_empty())
    print(ll.length())
    print(ll.search(88))

测试结果如下

True
0
False
1
1 2 93 3 
88 1 2 93 3 4 5 6 
88 1 2 93 3 4 6 
False
7
找到了

双向链表

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


class DoubleLinkList(object):     # DoubleLinkList（SingleLinkList）可以继承单链表
    def __init__(self, node=None):
        self.__head = node

    def is_empty(self):
        return self.__head is None

    def length(self):
        cur = self.__head
        count = 0
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        cur = self.__head
        while cur is not None:
            print(cur.elem, end=" ")
            cur = cur.next
        print(end="\n")

    def add(self, item):
        node = Node(item)
        if self.is_empty():     # 处理空链表
            self.__head = node
        else:
            node.next = self.__head
            self.__head = node
            node.next.prev = node       # 此句对空链表产生影响
            # self.__head.prev = node
            # self.__head = node

    def append(self, item):
        node = Node(item)
        cur = self.__head
        if self.is_empty():       # 处理空链表
            self.__head = node
        else:
            while cur.next is not None:
                cur = cur.next
            cur.next = node
            node.prev = cur

    def insert(self, pos, item):
        node = Node(item)
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        # 写法1：定位到pos结点前一个pre
        # else:
        #     count = 0
        #     pre = self.__head
        #
        #     while count < pos-1:
        #         count += 1
        #         pre = pre.next
        #     node.next = pre.next
        #     node.prev = pre
        #     node.next = pre.next
        #     pre.next = node
        # 写法2:定位到当前结点pos cur
        else:
            count = 0
            cur = self.__head
            while count < pos:
                count += 1
                cur = cur.next
            node.next = cur
            node.prev = cur.prev
            # cur.prev = node
            # node.prev.next = node
            # 最后两句还可以替换指向顺序
            cur.prev.next = node
            node.next = cur

    def remove(self, item):
        cur = self.__head
        pre = None
        cur = self.__head
        while cur is not 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 is not None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False


if __name__ == "__main__":
    
    ll = DoubleLinkList()
    print(ll.length())
    print(ll.is_empty())
    ll.insert(3, 1000)
    ll.remove(1000)
    ll.travel()
    ll.append(899)
    ll.add(5)
    ll.add(56)
    ll.add(9)
    ll.travel()
    ll.remove(5)
    ll.travel()
    ll.add(44)
    print(ll.length())
    print(ll.is_empty())
    ll.travel()
    print(ll.search(7))
    ll.remove(899)
    ll.travel()

测试结果如下

0
True

9 56 5 899 
9 56 899 
4
False
44 9 56 899 
False
44 9 56

单向循环链表

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


class SingleLinkListo(object):
    def __init__(self, node=None):
        self.__head = node
        if node:                     # 多一步 反向指向
            node.next = node

    def is_empty(self):
        return self.__head is None

    def length(self):
        cur = self.__head

        if self.is_empty():                 # 添加
            return 0
        count = 1                           # 修养
        while cur.next != self.__head:      # 修改
            count += 1
            cur = cur.next
        return count

    def travel(self):
        cur = self.__head
        if self.is_empty():                # 添加
            return None                    # return
        while cur.next != self.__head:
            print(cur.elem, end=" ")
            cur = cur.next
        print(cur.elem)                    # 添加

    def add(self, item):
        cur = self.__head
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            while cur.next != self.__head:         # 易错
                cur = cur.next
            node.next = self.__head
            self.__head = node
            cur.next = self.__head

    def append(self, item):
        cur = self.__head
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            while cur.next != self.__head:
                cur = cur.next
            node.next = self.__head
            # node.next = cur.next        # 这一句和上一句可以替换
            cur.next = node

    def insert(self, pos, item):
        cur = self.__head
        node = Node(item)
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            count = 0
            while count < pos-1:
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node

    def remove(self, item):
        cur = self.__head
        pre = None
        rear = self.__head
        node = Node(item)
        if self.is_empty():      # 空链表
            return
        while cur.next != self.__head:         # >1 个结点的情况
            if cur.elem == item:
                while rear.next != self.__head:
                    rear = rear.next                    # 该指针用于定位尾部
                if self.__head == cur:
                    self.__head = cur.next
                    rear.next = self.__head
                else:
                    pre.next = cur.next

                return                           # 修改 将break修改成return
            else:
                pre = cur
                cur = cur.next
        if cur.elem == item:             # 指针指向最后一个结点，因为最后一个结点还没有判断过
            if self.__head == cur:       # =1 个结点的情况
                self.__head = None
            else:
                pre.next = cur.next

    def search(self, item):
        node = Node(item)
        cur = self.__head
        while cur.next != self.__head:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        if cur.elem == item:
            return True
        else:
            return False


if __name__=="__main__":
    ll = SingleLinkListo()
    print(ll.length())
    ll.remove(5)
    ll.append(55)
    ll.add(11)
    ll.add(22)
    ll.append(66)
    ll.add(33)
    ll.append(44)
    ll.insert(1, 77)
    ll.travel()
    ll.remove(77)
    ll.remove(33)
    print(ll.search(1))
    ll.travel()

测试结果如下

0
33 77 22 11 55 66 44
False
22 11 55 66 44

qq_43609939

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
单链表，双向链表以及单向循环链表的基本实现（python）

# 结点定义class Node(object): def __init__(self, elem): self.elem = elem self.next = None# 链表实现class SingleLinkList(object): def __init__(self, node=None): self.__head ...
复制链接

扫一扫