数据结构——链表

单链表

---

class Node:
    next = None
    data = None

    def __init__(self, nodeData):
        self.data = nodeData


class List:
    head = None
    size = 0

    def __init__(self):
        self.size = 0
        self.head = None

    # 遍历链表
    def a(self):
        print("avx")

    def printlist(self):
        p = self.head
        while p is not None:
            print(p.data)
            p = p.next
        print("——————————————————————————————————————")

    def insertlink(self, a, newdata):
        newnode = Node(newdata)
        if self.size == 0:
            print("The link is none")
            self.head = newnode
            self.size = self.size + 1
        else:
            p = self.head
            while (p is not None) and (p.data != a):
                p = p.next
            if p.next is None:
                p.next = newnode
                self.size = self.size + 1
            else:
                newnode.next = p.next
                p.next = newnode
                self.size = self.size + 1

    # 删除链表中的节点
    def deldata(self, a):
        if self.size == 0:
            print("The link is none")
        elif self.size == 1:
            self.head = None
            self.size = self.size - 1
        else:
            p = self.head
            while (p is not None) and (p.data != a):
                q = p
                p = p.next
            if p is None:
                print("Can't find a")
            elif p == self.head:
                self.head = p.next
            elif p.data == a and p.next is not None:
                q.next = q.next.next
                self.size = self.size - 1
            else:
                q.next = None
                self.size = self.size - 1

    # 修改链表中的指定节点
    def updatelink(self, a, b):
        p = self.head
        print(p.data)
        while (p is not None) and (p.data != a):
            p = p.next
        if p is None:
            print("Can't find a")
        else:
            p.data = b


if __name__ == "__main__":
    p = List()
    p.insertlink(1, 1)
    p.insertlink(1, 2)
    p.insertlink(1, 3)
    p.insertlink(1, 4)
    print("_________________________---insertlink")
    p.printlist()
    print("_________________________--chalink")
    p.updatelink(2, 5)
    p.printlist()
    print("___________________________-----dellink")
    p.deldata(5)
    p.printlist()

---

循环链表

---

class Node(object):
    def __init__(self, item):
        self.item = item  # 节点数值
        self.prev = None  # 用于指向前一个元素
        self.next = None  # 用于指向后一个元素


# 双向循环链表
class DoubleCircleLinkList(object):
    def __init__(self):
        self.__head = None  # 初始化的时候头节点设为空、

    # 判断链表是否为空，head为None 的话则链表是空的
    def is_empty(self):
        return self.__head is None

    # 头部添加元素的方法
    def add(self, item):
        node = Node(item)  # 新建一个节点node 里面的值是item
        # 如果链表是空的，则node的next和prev都指向自己(因为是双向循环)，head指向node
        if self.is_empty():
            self.__head = node
            node.next = node
            node.prev = node
        # 否则链表不空
        else:
            node.next = self.__head  # node的next设为现在的head
            node.prev = self.__head.prev  # node的prev 设为现在head的prev
            self.__head.prev.next = node  # 现在head的前一个元素的next设为node
            self.__head.prev = node  # 现在head的前驱 改为node
            self.__head = node  # 更改头部指针

    # 尾部添加元素方法
    def append(self, item):
        # 如果当前链表是空的 那就调用头部插入方法
        if self.is_empty():
            self.add(item)
        # 否则链表不为空
        else:
            node = Node(item)  # 新建一个节点node
            # 因为是双向循环链表，所以head的prev其实就是链表的尾部
            node.next = self.__head  # node的下一个设为头
            node.prev = self.__head.prev  # node的前驱设为现在头部的前驱
            self.__head.prev.next = node  # 头部前驱的后继设为node
            self.__head.prev = node  # 头部自己的前驱改为node

    # 获得链表长度 节点个数
    def length(self):
        # 如果链表是空的 就返回0
        if self.is_empty():
            return 0
        # 如果不是空的
        else:
            cur = self.__head  # 临时变量cur表示当前位置 初始化设为头head
            count = 1  # 设一个计数器count，cur每指向一个节点，count就自增1  目前cur指向头，所以count初始化为1
            # 如果cur.next不是head，说明cur目前不是最后一个元素，那么count就1，再让cur后移一位
            while cur.next is not self.__head:
                count += 1
                cur = cur.next
            # 跳出循环说明所有元素都被累加了一次 返回count就是一共有多少个元素
            return count

    # 遍历链表的功能
    def travel(self):
        # 如果当前自己是空的，那就不遍历
        if self.is_empty():
            return
        # 链表不空
        else:
            cur = self.__head  # 临时变量cur表示当前位置，初始化为链表的头部
            # 只要cur的后继不是头说明cur不是最后一个节点，我们就输出当前值，并让cur后移一个节点
            while cur.next is not self.__head:
                print(cur.item, end=" ")
                cur = cur.next
            # 当cur的后继是head的时候跳出循环了，最后一个节点还没有打印值 在这里打印出来
            print(cur.item)

    # 置顶位置插入节点
    def insert(self, pos, item):
        # 如果位置<=0 则调用头部插入方法
        if pos <= 0:
            self.add(item)
        # 如果位置是最后一个或者更大 就调用尾部插入方法
        elif pos > self.length() - 1:
            self.append(item)
        # 否则插入位置就是链表中间
        else:
            index = 0  # 设置计数器，用于标记我们后移了多少步
            cur = self.__head  # cur标记当前所在位置
            # 让index每次自增1 ，cur后移，当index=pos-1的时候说明cur在要插入位置的前一个元素，这时候停下
            while index < pos - 1:
                index += 1
                cur = cur.next
            # 跳出循环，cur在要插入位置的前一个元素，将node插入到cur的后面
            node = Node(item)  # 新建一个节点
            node.next = cur.next  # node的后继设为cur的后继
            node.prev = cur  # node的前驱设为cur
            cur.next.prev = node  # cur后继的前驱改为node
            cur.next = node  # cur后继改为node

    # 删除节点操作
    def remove(self, item):
        # 如果链表为空 直接不操作
        if self.is_empty():
            return
        # 链表不为空
        else:
            cur = self.__head  # 临时变量标记位置，从头开始
            # 如果头结点就是 要删除的元素
            if cur.item == item:
                # 如果只有一个节点 链表就空了 head设为None
                if self.length() == 1:
                    self.__head = None
                # 如果多个元素
                else:
                    self.__head = cur.next  # 头指针指向cur的下一个
                    cur.next.prev = cur.prev  # cur后继的前驱改为cur的前驱
                    cur.prev.next = cur.next  # cur前驱的后继改为cur的后继
            # 否则 头节点不是要删除的节点 我们要向下遍历
            else:
                cur = cur.next  # 把cur后移一个节点
                # 循环让cur后移一直到链表尾元素位置，期间如果找得到就删除节点，找不到就跳出循环，
                while cur is not self.__head:
                    # 找到了元素cur就是要删除的
                    if cur.item == item:
                        cur.prev.next = cur.next  # cur的前驱的后继改为cur的后继
                        cur.next.prev = cur.prev  # cur的后继的前驱改为cur的前驱
                    cur = cur.next

    # 搜索节点是否存在
    def search(self, item):
        # 如果链表是空的一定不存在
        if self.is_empty():
            return False
        # 否则链表不空
        else:
            cur = self.__head  # 设置临时cur从头开始
            # cur不断后移，一直到尾节点为止
            while cur.next is not self.__head:
                # 如果期间找到了就返回一个True 结束运行
                if cur.item == item:
                    return True
                cur = cur.next
            # 从循环跳出来cur就指向了尾元素 看一下为元素是不是要找的 是就返回True
            if cur.item == item:
                return True
            # 所有元素都不是 就返回False 没找到
            return False


if __name__ == "__main__":
    dlcl = DoubleCircleLinkList()
    print(dlcl.search(7))
    dlcl.travel()
    dlcl.remove(1)
    print(dlcl.length())
    print(dlcl.is_empty())
    dlcl.append(55)
    print(dlcl.search(55))
    dlcl.travel()
    dlcl.remove(55)
    dlcl.travel()
    print(dlcl.length())
    dlcl.add(3)
    print(dlcl.is_empty())
    dlcl.travel()
    dlcl.add(4)
    dlcl.add(5)
    dlcl.append(6)
    dlcl.insert(-10, 1)
    dlcl.travel()
    print(dlcl.length())
    dlcl.remove(6)
    dlcl.travel()

    print(dlcl.search(7))
    dlcl.append(55)
    dlcl.travel()

---

双向链表​​​​

---

class Node:
    data = None
    nextnode = None
    prenode = None

    def __init__(self, data):
        self.data = data


class PersonChan:
    size = 0
    head = None
    tail = None

    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    # 增加节点
    def add_node(self, a):
        newnode = Node(a)
        if self.head is None:
            self.head = newnode
            self.head.prenode = None
            self.tail = newnode
            self.tail.prenode = None
            self.tail.nextnode = None
            self.size = self.size + 1
        else:
            temp = self.head
            while temp.nextnode is not None:  # 返回尾节点tail
                temp = temp.nextnode
            temp.nextnode = newnode
            self.tail = newnode
            self.tail.prenode = temp
            self.tail.nextnode = None
            self.size = self.size + 1

    # 在查找到的a后面增加节点
    def ins_node(self, a, b):
        newnode = Node(b)
        if self.head is None:
            self.head = newnode
            self.tail = newnode
            print("Insert success:", newnode.data)
            self.size = self.size + 1
        else:
            temp = self.head
            while (temp is not None) & (temp.data != a):
                temp = temp.nextnode
            if temp.nextnode is None:
                temp.nextnode = newnode
                self.tail = newnode
                self.tail.prenode = temp
                self.tail.nextnode = None
                temp = None
                print("Insert success:", newnode.data)
                self.size = self.size + 1
            else:
                newnode.prenode = temp
                newnode.nextnode = temp.nextnode
                temp.nextnode = newnode
                print("Insert success:", newnode.data)
                self.size = self.size + 1

    # 删除节点
    def del_node(self, a):
        if self.head is None:
            pass
        elif self.head.data == a:
            if self.size == 1:
                self.head = None
                self.tail = None
                self.size = self.size - 1
            else:
                self.head = self.head.nextnode
                self.size = self.size - 1
        else:
            temp = self.head.nextnode
            while (temp is not None) and (temp.data != a):
                temp = temp.nextnode
            p = temp.prenode
            if temp is not None:
                if temp.nextnode is None:

                    self.tail = p
                    self.tail.nextnod = None
                else:
                    p.nextnode = temp.nextnode
                    temp = None
                self.size = self.size - 1
                print("Delete is success:", a)

    def listall(self):  # 正序排列
        if self.size == 0:
            print("No data in the list")
        else:
            temp = self.head
            while (temp is not None):
                print(temp.data)
                temp = temp.nextnode

    def lista(self):  # 倒序排列
        if self.size == 0:
            print("No data in the list")
        temp = self.tail
        while temp is not None:
            print(temp.data)
            temp = temp.prenode


if __name__ == '__main__':
    link = PersonChan()
    link.add_node(1)
    link.add_node(2)
    link.add_node(3)
    link.add_node(4)
    link.listall()
    print("The list's size is:", link.size)
    link.lista()

 

---

单链表反转

---

 

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


def rev(link):
    pre = link
    cur = link.next
    pre.next = None
    while cur:
        temp = cur.next
        cur.next = pre
        pre = cur
        cur = temp
    return pre


if __name__ == '__main__':
    link = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9)))))))))
    root = rev(link)
    while root:
        print(root.data)
        root = root.next

---

两个有序的链表合并为一个有序链表

---

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution:
    def mergeTwoLists(self, l1, l2):

        if not l1:
            return l2
        if not l2:
            return l1
        if l1.val <= l2.val:
            ret = l1
            ret.next = self.mergeTwoLists(l1.next, l2)
        else:
            ret = l2
            ret.next = self.mergeTwoLists(l1, l2.next)
        return ret

---

求链表的中间结点

---

class Solution:
    def middleNode(self, head):

        count = 0
        res = {}
        while head != None:
            count += 1
            res[count] = head
            head = head.next

        j = math.ceil((count - 1) / 2) + 1
        return res[j]