蓝桥杯数据结构整理-链表（Python 自用）

单链表快速实现

#创建Node类
class Node:
    #初始化链点
    def __init__(self,data):
        self.data = data #表示对应的元素
        self.next = None #表示下一个链接的链点
#创建 Linked_List 类
class Linked_List:
    #链表初始化函数
    def __init__(self,head = None):
        self.head = head #表示链表的头部元素
    #添加append函数
    def append(self,new_element):
        #将头部结点指向临时变量 current
        current = self.head
        #当头部节点存在时：
        if self.head:
            #循环遍历到链表的最后一个元素
            while current.next:
                current = current.next
            current.next = new_element
        #当头部节点不存在时
        else:
            self.head = new_element
    #添加is_empty函数
    def is_empty(self):
        return not self.head
    #添加insert函数
    #1.判断要插入的位置是否在链表的索引范围内
    #2.当插入的位置是头结点时，做特殊情况处理
    #3.当要插入的结点的位置不在头结点的时候，找到要插入位置插入即可
    def insert(self,position,new_element):
        """
        在链表指定索引处插入元素
        """
        if position < 0 or position > self.get_length():
            raise IndexError('insert 插入时，key值超出范围')
        temp = self.head
        #将插入元素的next属性指向老的头结点，并将新元素赋值给头结点
        if position == 0:
            new_element.next = temp
            self.head = new_element
            return
        i = 0
        #遍历找到索引值为position的结点后，在其后面插入结点
        while i < position:
            pre = temp
            temp = temp.next
            i += 1
        pre.next = new_element
        new_element.next = temp
    #添加remove函数
    def remove(self,position):
        """
        删除指定索引的链表元素
        """
        if position < 0 or position > self.get_length() - 1:
            raise IndexError('删除元素的索引超出范围')

        i = 0
        temp = self.head
        #当存在链表元素时才能执行删除操作
        while temp != None:
            #将头结点的后一个结点赋值给新的头结点，再将之前的头结点指向'None'
            if position == 0:
                self.head = temp.next
                temp.next = None
                return
            pre = temp
            #遍历链表
            temp = temp.next
            i += 1
            if i == position:
                pre.next = temp.next
                temp.next = None
                return
    #功能函数
    def get_length(self):
        #返回链表长度
        temp = self.head
        length = 0
        while temp != None:
            length += 1
            temp = temp.next
        return length

    def print_list(self):
        #遍历链表，依次打印
        temp = self.head
        while temp is not None:
            print(temp.data)
            temp = temp.next

    def reverse(self):
        #反转链表
        prev = None
        current = self.head
        while current:
            next_node = current.next
            current.next = prev
            prev = current
            current = next_node
        self.head = prev

    def initlist(self,data_list):
        #将列表转换为链表
        #创建头结点
        self.head = Node(data_list[0])
        temp = self.head
        #逐个为data内的数据创建结点，建立链表
        for i in data_list[1:]:
            node = Node(i)
            temp.next = node
            temp = temp.next

双向链表快速实现

#结点类
class Node(object):
    #双向链表结点
    def __init__(self,item):
        self.item = item
        self.next = None
        self.prev = None

class DLinkList(object):
    #初始化函数
    def __init__(self):
        self._head = None

    #判空函数
    def is_empty(self):
        return self._head == None

    #获取长度
    def get_length(self):
        cur = self._head
        length = 0
        while cur != None:
            length += 1
            cur = cur.next
        return length

    #遍历链表
    def travel(self):
        cur = self._head
        while cur != None:
            print(cur.item)
            cur = cur.next
        print("")

    #头插
    def add(self,item):
        node = Node(item)
        if self.is_empty():
            self._head = node
        else:
            node.next = self._head
            self._head.prev = node
            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 search(self,item):
        cur = self._head
        while cur != None:
            if cur.item == item:
                return True
            cur = cur.next
        return False

    #指定位置插入结点
    def insert(self,pos,item):
        if pos <= 0:
            self.add(item)
        elif pos > (self.get_length()-1):
            self.append(item)
        else:
            node = Node(item)
            cur = self._head
            count = 0
            while count < (pos-1):
                count += 1
                cur = cur.next
            node.prev = cur
            node.next = cur.next
            cur.next.prev = node
            cur.next = node

    #删除元素
    def remove(self,item):
        if self.is_empty():
            return
        else:
            cur = self._head
            if cur.item == item:
                #首结点就是要删除的元素
                if cur.next == None:
                    #该链表只有这一个结点
                    self._head = None
                else:
                    cur.next.prev = None
                    self._head = cur.next
                return
            while cur != None:
                if cur.item == item:
                    cur.prev.next = cur.next
                    cur.next.prev = cur.prev
                    break
                cur = cur.next

单链表应用

"""
交换单链表里的两个链点
"""

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

class LinkedList:
    def __init__(self):
        self.head = None

    def traval(self):
        cur = self.head
        new_list = []
        while cur != None:
            new_list.append(cur.data)
            cur = cur.next
        print(new_list)

    def insert(self,new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node

    def swapNodes(self,d1,d2):
        preD1 = None
        preD2 = None
        if d1 == d2:
            return
        else:
            D1 = self.head
            #D1不为空且头结点值不是d1
            while D1 is not None and D1.data != d1:
                preD1 = D1
                D1 = D1.next
            D2 = self.head
            #D2不为空且头结点值不是d2
            while D2 is not None and D2.data != d2:
                preD2 = D2
                D2 = D2.next
            if D1 is None or D2 is None:
                return
            if preD1 is not None:
                preD1.next = D2
            else:
                self.head = D2
            if preD2 is not None:
                preD2.next = D1
            else:
                self.head = D1
            temp = D1.next
            D1.next = D2.next
            D2.next = temp
if __name__ == '__main__':
    list = LinkedList()
    list.insert(5)
    list.insert(4)
    list.insert(3)
    list.insert(2)
    list.insert(1)
    list.traval()
    list.swapNodes(1, 6)
    print("After swapping")
    list.traval()