python描述：链表

单链表结构：

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。对于python来说指针就是指向下一个对象。

单链表时间复杂度：

创建空表：O（1）

删除表：O（1）

判断空：O（1）

加入：

首端加入：O（1）

尾端加入：O（n）

定位加入：O（n）

删除：

首端删除：O（1）

尾端删除：O（n）

定位删除：O（n）

其他删除:O（n）

扫描定位遍历都需要价差一批表节点，其时间复杂度收到节点数约束。

单链表实现：

 1 class LinkedListUnderflow(ValueError): #自定义链表为空异常类
 2     pass
 3 
 4 class Lnode(object):
 5     def __init__(self,ele,next=None):
 6         self.ele = ele
 7         self.next = next
 8 
 9 
10 class Dlist(object):
11     def __init__(self):
12         self.head = None
13 
14     def is_emtpy(self):   #链表是否为空
15         if self.head == None:
16 
17             return True
18 
19     def last_append(self,ele):  #尾插入
20         p = Lnode(ele=ele)
21 
22         if self.is_emtpy():
23             self.head = p
24             return
25 
26         last_p = self.head
27         while last_p.next:    #找到尾部后插入
28            last_p = last_p.next
29         last_p.next = p
30 
31     def head_append(self,ele):  #头插入
32         p = Lnode(ele=ele)
33 
34         if self.is_emtpy():
35             self.head = p
36             return
37 
38         p.next = self.head
39         self.head = p
40 
41     def head_pop(self):
42         if self.is_emtpy():
43             raise LinkedListUnderflow("链表为空")
44 
45         if self.head.next == None: #只有一个节点
46             self.head = None
47             return
48 
49         self.head = self.head.next
50 
51     def last_pop(self):
52         if self.is_emtpy():
53             raise LinkedListUnderflow("链表为空")
54 
55         if self.head.next == None:  # 只有一个节点
56             self.head = None
57             return
58 
59         p = self.head
60         while p.next.next:  #找到倒数第二个节点
61             p = p.next
62         p.next = None
63 
64 
65     def print_all(self):  #输出所有元素
66         if self.is_emtpy():
67             print("链表为空")
68             return
69 
70         last_p = self.head
71         while last_p:
72             print(last_p.ele)
73             last_p = last_p.next

单链表

循环单链表：

python中的循环单链表，实际就是尾部（tail）节点的指针指向head对象。所以循环单链表实现中只需要实现self.tail而头部即为self.tail.next，以此形成循环进行节点操作。

循环单链表实现

 1 class LooDlist(object):
 2     def __init__(self):
 3         self._real = None
 4 
 5     def is_emtpy(self):
 6         return self._real is None
 7 
 8     def head_append(self,ele):
 9         p = Lnode(ele=ele)
10 
11         if self.is_emtpy():
12             self._real = p
13             p.next = self._real  #建立一个列表循环
14             return
15 
16         p.next = self._real.next #在首部添加新节点
17         self._real.next = p
18 
19     def last_append(self,ele):
20         self.head_append(ele)
21         self._real = self._real.next  #将尾部指针向后移一位
22 
23     def pop(self):  #前端弹出
24         if self.is_emtpy():
25             raise LinkedListUnderflow("链表为空")
26 
27         if self._real.next == self._real: #只有一个节点
28             print(self._real.ele)
29             self._real = None
30             return
31 
32         value = self._real.next.ele
33         self._real.next = self._real.next.next  #弹出前端节点，尾部指针指向弹出节点的next对象
34         return value
35 
36     def print_all(self):
37         if self.is_emtpy():
38             return
39 
40         p = self._real.next
41         while True:
42             print(p.ele)
43             if p is self._real:
44                 break
45             p = p.next

View Code

双向链表：

双向链表实现：

#双向链表

class Delement(object):
    def __init__(self,ele,next=None,pre=None):
        self.ele = ele
        self.next = next
        self.pre = pre

class Bllist(object):
    def __init__(self):
        self.head = None
        self.real = None

    def Empty(self):     #清空链表
        self.head = None
        self.real = None

    def head_append(self,ele):        #前端增加
        p = Delement(ele=ele,next=self.head)

        if not self.head:       #链表为空
            self.head = p
            self.real = p
            return

        self.head.pre = p
        self.head = p

    def last_append(self,ele):        #尾端增加
        p = Delement(ele=ele,pre=self.real)

        if not self.real:
            self.head = p
            self.real = p
            return

        self.real.next = p
        self.real = p

    def head_pop(self):         #前端删除
        if not self.head:
            raise ValueError("列表为空")

        value = self.head.ele
        if self.head == self.real:     #只有一个元素清空
            self.Empty()
            return value

        self.head = self.head.next
        self.head.pre = None
        return value

    def last_pop(self):
        if not self.real:
            raise ValueError("列表为空")

        value = self.real.ele
        if self.head == self.real:
            self.Empty()
            return value

        self.real = self.real.pre
        self.real.next = None
        return value

    def printall(self):   #输出所有元素值
        p = self.head
        while p != self.real:
            print(p.ele)
            p = p.next

        if p:             #链表是否为空
            print(p.ele)

View Code

链表反转

原理：原链表相当于一摞书，将这摞书最上面的一本拿下来放在一个位置B，再拿一本再放在位置B的最上面，重复这个过程。

class Lnode(object):
    def __init__(self, ele, next=None):
        self.next = next
        self.ele = ele


class Dlist(object):
    def __init__(self):
        self.head = None

    def head_append(self, ele):  # 头插入
        p = Lnode(ele=ele)
        if not self.head:
            self.head = p
            return
        p.next = self.head
        self.head = p

    def reverse(self):
        q = None             #新链表

        while True:       #从原链表中拿到一个元素放入新链表
            p = self.head   #剔除原链表最上方的元素
            self.head = self.head.next

            if p == None:    #原链表没元素了
                break

            p.next = q      #将剔除元素放入新的链表
            q = p

        self.head = q    #将反转的链表给原链表

    def printall(self):
        p = self.head
        while p != None:
            print(p.ele)
            p = p.next

a = Dlist()
for i in range(10):
    a.head_append(i)

a.reverse()
a.printall()

猜你喜欢