数据结构 - 1 线性表 - 3 链表 - 单向链表 - python

最新推荐文章于 2025-05-15 20:49:36 发布

KinChow94

最新推荐文章于 2025-05-15 20:49:36 发布

阅读量179

点赞数

分类专栏：数据结构文章标签：数据结构与算法 Python

本文链接：https://blog.youkuaiyun.com/qq_20967953/article/details/103395996

版权

数据结构专栏收录该内容

12 篇文章

订阅专栏

单向链表

节点

链表实现的基本构造块是节点。每个节点对象必须至少保存两个信息。一个是存储数据元素的数据域（设域名为data），另一个是存储下一个结点地址的指针域（设域名为next）。

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
    
    # 查看节点的数据域
    def getData(self):
        return self.data

    # 查看节点的指针域
    def getNext(self):
        return self.next
	
    # 设置节点的数据域
    def setData(self,newdata):
        self.data = newdata

    # 设置节点的指针域
    def setNext(self,newnext):
        self.next = newnext

创建节点

node1 = Node(57)
node2 = Node(7)
node1.setNext(node2)
print(node1.getData()) # 57
print(node2.getData()) # 7
print(node1.getNext() == node2) # True
print(node2.getNext() == None) # True
node2.setData(1)
print(node2.getData()) # 1

单向链表的基本操作

LinkedList.isEmpty()：返回链表是否为空。
LinkedList.length()：返回链表的长度。
LinkedList.traversal()：遍历链表。
LinkedList.add(x)：在链表的头部添加一个节点。
LinkedList.append(x)：在链表的尾部添加一个节点。
LinkedList.insert(i, x)：在给定的位置插入一个元素。第一个参数是要插入的元素的索引，所以 a.insert(0, x) 插入列表头部等同于a.add(x)， a.insert(a.length(), x) 等同于 a.append(x) 。
LinkedList.remove(x)：移除链表中第一个值为 x 的节点。如果没有这样的节点，则输出错误。
LinkedList.pop(i, x)：删除链表中给定位置的节点并返回它。
LinkedList.clear()：删除链表中所有的节点。
LinkedList.search(x)：返回链表是否有值为 x 的节点。
LinkedList.index(x)：返回链表中第一个值为 x 的节点的从零开始的索引。如果没有这样的节点，则输出错误。
LinkedList.location(x)：返回链表中第 x 个节点。如果没有这样的节点，则输出错误。
LinkedList.reverse()：反转链表中的节点。

class LinkedList:
    def __init__(self):
        self.head = None
     
    # 返回链表是否为空。
    def isEmpty(self):
        return self.head is None
    
    # 返回链表的长度。
    def length(self):
        count = 0
        current = self.head
        while current is not None:
            count += 1
            current = current.getNext()
        return count
    
    # 遍历链表。
    def traversal(self):
        current = self.head
        while current is not None:
            print(current.getData(), end=' ')
            current = current.getNext()
        print()
    
    # 在链表的头部添加一个节点。
    def add(self, data):
        node = Node(data)
        node.setNext(self.head)
        self.head = node
    
    # 在链表的尾部添加一个节点。
    def append(self, data):
        node = Node(data)
        if self.isEmpty():
            self.head = node
        else:
            current = self.head
            while current.getNext() is not None:
                current = current.getNext()
            current.setNext(node) 
    
    # 在给定的位置插入一个元素。
    def insert(self, pos, data):
        if pos == 0:
            self.add(data)
        else:
            count = 0
            current = self.head
            while current != None:
                if count == pos - 1:
                    node = Node(data)
                    node.setNext(current.getNext())
                    current.setNext(node)
                    break
                else:
                    count += 1
                    current = current.getNext()
            if count < pos - 1:
                print("错误：链表插入的位置大于链表长度！")    
    
    # 移除链表中第一个值为 x 的节点。
    def remove(self, data):
        try:
            current = self.head
            previous = None
            while current != None:
                if current.getData() == data:
                    break
                else:
                    previous = current
                    current = current.getNext()
            if previous == None:
                self.head = current.getNext()
            else:
                previous.setNext(current.getNext())
        except:
            print("错误：链表中没有{0}元素！".format(data))
    
    # 删除链表中给定位置的节点并返回它。
    def pop(self, pos):
        if pos < self.length():
            if pos == 0:
                self.head = self.head.getNext()
            else:
                count = 0
                current = self.head
                while current!=None:
                    if count == pos - 1:
                        temp = current.getNext()
                        current.setNext(temp.getNext())
                        return temp.getData()
                    else:
                        count += 1
                        current = current.getNext()
        else:
            print("错误：链表删除的位置大于链表长度！")
    
    # 删除链表中所有的节点。
    def clear(self):
        self.head = None
    
    # 返回链表是否有值为 x 的节点。
    def search(self, data):
        current = self.head
        while current is not None:
            if current.getData() == data:
                return True
            else:
                current = current.getNext()
        return False
    
    # 返回链表中第一个值为 x 的节点的从零开始的索引。
    def index(self, data):
        current = self.head
        count = 0
        while current != None:
            if current.getData() == data:
                return count 
            else:
                count += 1
                current = current.getNext()
        print("错误：链表中没有{0}元素！".format(data))
    
    # 返回链表中第 x 个节点。如果没有这样的节点，则输出错误。
    def location(self, pos):
        count = 0
        current = self.head
        while current is not None:
            if count == pos:
                return current.getData()
            else:
                count += 1
                current = current.getNext()
        if count < pos:
            print("错误：链表索引的位置大于链表长度！")
    
    # 反转链表中的节点。
    def reverse(self):
        previous = None
        while self.head is not None:
            temp = self.head.getNext()
            self.head.setNext(previous)
            previous = self.head
            self.head = temp
        self.head = previous

对操作进行测试：

ll =  LinkedList()
print("查看是否为空：",ll.isEmpty()) #True
ll.traversal() # 
print("链表长度：", ll.length()) # 0
print('===================')
ll.add(2)
ll.traversal() # 2
print("链表长度：", ll.length()) # 1
print('===================')
ll.add(3)
ll.traversal() # 3 2
print("链表长度：", ll.length()) # 2
print('===================')
ll.append(7)
ll.traversal() # 3 2 7
print("链表长度：", ll.length()) # 3
print('===================')
ll.insert(1,4) 
ll.traversal() # 3 4 2 7
print("链表长度：", ll.length()) # 4
print('===================')
ll.insert(0,5)
ll.traversal() # 5 3 4 2 7
print("链表长度：", ll.length()) # 5
print('===================')
ll.insert(ll.length(),99)
ll.traversal() # 5 3 4 2 7 99
print("链表长度：", ll.length()) # 6
print('===================')
ll.remove(4)
ll.traversal() # 5 3 2 7 99
print("链表长度：", ll.length()) # 5
print('===================')
ll.remove(6)
ll.traversal() # 5 3 2 7 99
print("链表长度：", ll.length()) # 5
print('===================')
ll.pop(4)
ll.traversal() # 5 3 2 7
print("链表长度：", ll.length()) # 4
print('===================')
print(ll.location(0)) # 5
print('===================')
ll.reverse()
ll.traversal() # 7 2 3 5
print('===================')
ll.reverse()
ll.traversal() # 5 3 2 7
print('===================')