python3-链表结构

python定义链表时，自己定义一个链表的结点类，之后每一个链表的对象都是改结点类的实例化，都拥有一个数据域，一个指针域next，因为python中不存在指针一说，所以使用该方法去模仿C语言中的指针完成队链表的操作，将定义的结点的next指向下一个元素，有点类似于C语言中的指针的作用

单链表的完成：

'''链表的完成'''

#定义链表的结点
class LinkNode(object):
    #node:元素；next:保存当前元素的下一个元素的地址
    def __init__(self,ldata):
        self._ldata = ldata
        self._lnext = None

class Link(object):
    #初始化并且创建链表(创建链表之后链表中有一个头指针)
    def __init__(self):
        #初始化对象
        self._head = LinkNode(None)
        #链表长度
        self._size = 0

    #判断空
    def is_empty(self):
        #判断链表的头结点是否指向None
        if self._size == 0:
            return True
        else:
            return False

    #遍历链表元素
    def traveLink(self):
        # 定义初始游标
        link_cur = self._head
        for i in range(self._size):
            print(link_cur._lnext._ldata,end=' ')
            link_cur = link_cur._lnext
        else:
            print(' ')

    # 添加元素
    def addLink(self, data):
        link_data = LinkNode(data)
        # 创建游标
        link_cur = self._head
        for i in range(self._size):
            # 移动游标
            link_cur = link_cur.next
        else:
            # 与新节点有关的节点有所指向
            link_cur.next = link_data
            # 链表长度加1
            self._size += 1

    #插入元素
    def insertLink(self,pos,link_data):
        if pos < 0 or pos > self._size:
            return 'overflow error'
        else:
            # 实例化新加入链表结点
            link_data = LinkNode(link_data)
            #创建游标
            link_cur = self._head

            for i in range(self._size):
                link_cur = link_cur._lnext
                if i == pos-1:
                    #新加的元素的指针指向插入元素的next
                    link_data._lnext = link_cur
                    #修改插入元素的上一个结点的指针
                    link_cur._lnext = link_data
                    #链表长度+1
                    self._size += 1
                    return
            else:
                link_cur = link_cur._lnext

    #删除元素
    def deleteLink(self,link_data):
        if self.is_empty():
            return 'no node error'
        else:
            #实例化需要删除的元素对象
            link_data = LinkNode(link_data)
            #创建游标
            link_cur = self._head
            #遍历
            for i in range(self._size):
                #没循环一次游标指针移动一次
                link_cur = link_cur._lnext
                #判断需要删除的元素
                if link_cur._lnext._ldata == link_data:
                    #找到删除的元素之后见需要删除的元素的next赋值给他的前一个元素的next
                    link_cur._lnext = link_cur._lnext._lnext
                    #长度-1
                    self._size -= 1

                else:
                    link_cur = link_cur._lnext

    #链表长度
    def size(self):
        return self._size

if __name__ == '__main__':
    s = Link()
    print('初始链表长度:',s.size())
    for i in range(3):
        s.addLink(i)

    print('插入之后链表长度:',s.size())
    s.traveLink()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
双向链表的基本操作

'''双向链表'''

class LinkNode(object):
    #定义结点
    def __init__(self,data1):
        #数据
        self.data1 = data1
        #后继指针
        self.next = None
        #前驱指针
        self.prev = None

class TwoLinkList(object):

    def __init__(self):
        #定义头结点
        self._head = LinkNode(None)
        #定义链表的长度
        self._length = 0

    #判空
    def is_empty(self):
        if self._length == 0:
            return True
        else:
            return False

    #遍历链表元素
    def trave(self):
        #定义初始游标
        cur = self._head
        for i in range(self._length):
            print(cur.next.data1, end=" ")
            cur = cur.next
        else:
            print(' ')

    #添加元素
    def add(self,data):
        new_code = LinkNode(data)
        # 创建游标
        cur = self._head
        for i in range(self._length):
            # 移动游标
            cur = cur.next
        else:
            # 插入新节点：
            # 1.让新节点有所指向
            new_code.prev = cur
            # 2.让与新节点有关的节点有所指向
            cur.next = new_code
            # 链表长度加1
            self._length += 1

    #插入
    def insert(self,pos,data):
        #判断插入位置
        if pos < 0 or pos > self._length:
            return 'Error'
        else:
            #构造新的结点
            new_node = LinkNode(data)
            #创建游标
            cur = self._head
            #移动游标
            for i in range(self._length):
                cur = cur.next
                if i == pos-1:
                    #新结点的前驱后继指针域变化
                    new_node.prev = cur
                    new_node.next = cur.next
                    #与其相关的结点的前驱后继变化
                    cur.next = new_node
                    (new_node.next).prev = new_node
                    #链表长度增加
                    self._length += 1
                    return
            else:
                cur = cur.next

    #删除
    def delete(self,data):
        #判断是否为空
        if self.is_empty():
            return 'Error'
        else:
            #创建游标
            cur = self._head
            for i in range(self._length):
                if cur.next.data1 == data:
                    #删除尾部结点，直接next赋值为None
                    if cur.next.next is None:
                        cur.next = None
                    #删除中间结点，变换next、prev
                    else:
                        cur.next = cur.next.next
                        cur.next.prev = cur

                        self._length -= 1
                else:
                    cur = cur.next
            return

if __name__ == '__main__':
    x = TwoLinkList()
    for i  in range(11):
        x.add(i)

    x.trave()
    x.delete(1)
    x.trave()

    x.delete(2)
    x.trave()

    x.insert(3,'a')
    x.trave()

    x.insert(5,'W')
    x.trave()
————————————————
版权声明：本文为CSDN博主「十 一 丶」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45061361/article/details/103940734