3_链表

最新推荐文章于 2024-05-11 11:08:32 发布

DisguiseR6

最新推荐文章于 2024-05-11 11:08:32 发布

阅读量203

点赞数

分类专栏： # python算法与数据结构

本文链接：https://blog.csdn.net/qq_25614773/article/details/89110420

版权

python算法与数据结构专栏收录该内容

5 篇文章 0 订阅

订阅专栏

3_链表

顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活。

链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。

文章目录

3_链表

3.1 单向链表

单向链表中头节点没有存储数值，只是指向了下一个节点

注意： $\color{Red}每次操作新node时，先链接node.next ，后动链表原有的结构$

单链表

3_0

3.1.0 遇到问题

输出未加括号 is_empty()——输出为一个地址

是否为空：<bound method SignleLinkList.is_empty of <__main__.SignleLinkList object at 0x000000000C072D30>>

remove 删除节点，需要退出程序（break）

3.1.1单链表的操作

定义一个头结点head
is_empty() 链表是否为空
length() 链表长度
travel() 遍历整个链表
add(item) 链表头部添加元素
- 先操作node.next 指向head
- 然后将head 指向 node

在这里插入图片描述

append(item) 链表尾部添加元素
1. 先判断链表是否为空，若为空，则将_head指向新节点
2. 若不为空，找到尾部，将为尾部的next指向新节点
insert(pos, item) 指定位置添加元素

pos 从0开始数（头、尾节点特殊考虑）
1. 找到要插入的前节点pre
2. $\color{red}开始操作node.next$

在这里插入图片描述

remove(item) 删除节点
- pre 、cur 将pre.next 指向cur.next
- $\color{red}头节点特殊考虑$
- 注意退出——break

在这里插入图片描述

search(item) 查找节点是否存在

3.1.2代码

class  SignleNode(object):
    '''单链表的节点'''
    def __init__(self, item):
        self.item = item
        self.next = None

'''----------
  单链表
-----------'''           
class SignleLinkList(object):
    def __init__(self):
        self._head = None
                
    def is_empty(self):
        '''判断链表是否为空'''
        return self._head == None
    
    def length(self):
        '''链表长度'''
        cur = self._head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count
    
    def travel(self):
        '''遍历链表'''
        cur = self._head
        while cur != None: 
            print(cur.item, end=' ')
            cur = cur.next
           
    def add(self, item):
        '''头部添加元素'''
        node = SignleNode(item)
        node.next = self._head
        self._head = node
            
    def append(self, item):
        node = SignleNode(item)
        if self._head == None:
            self._head = node
        else:
            cur = self._head
            while cur.next:
                cur = cur.next
            cur.next = node    
    
    def insert(self, pos,item):
        ''' 在指定位置pos添加节点（pos从0开始计数'''
        if pos <= 0:
            self.add(item)
        elif pos >= self.length():
            self.append(item)     
        else:
            node = SignleNode(item)
            count = 0
            pre = self._head
            while count < pos-1:         
                count += 1
                pre = pre.next
            node.next = pre.next
            pre.next = node
    
    def remove(self, item):
        '''删除节点'''
        cur = self._head
        pre = None
        while cur:
            if cur.item == item:
                if pre:                       # pre不指向None
                    pre.next = cur.next               
                else:                         #pre 指向None 即只有一个节点
                    self._head = cur.next 
                break
            else:
                pre = cur
                cur = cur.next 
    
    def search(self, item):
        '''链表查找'''
        cur = self._head
        while cur:
            if cur.item == item:
                return True
            cur = cur.next
        return False

if __name__ == "__main__":    
    l1 = SignleLinkList()
    l1.add(5)
    l1.add(4)  
    l1.add(3)
    l1.add(2)
    l1.add(1)
    l1.insert(0,8)
    l1.remove(8) 
    
    print('1是否在{}'.format(l1.search(1)))
    print('7是否在{}'.format(l1.search(7))) 
    print('是否为空：{}'.format(l1.is_empty()))
    print('链表长度：{}'.format(l1.length()))
    l1.travel()

3.2 单向循环链表

单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点

在这里插入图片描述

3.2.0遇到问题

python对象内调用加上self
当用 while cur.next 进行判断时，cur未执行
头节点head 不存储item,循环链表的尾部是指向node

3.2.1 操作

is_empty()判断链表是否为空
length()返回链表的长度
- 区别于单链表的判断条件 ——cur
- 当判断条件为 cur.next ，注意count的初始值
travel()遍历
add(item) 在头节点添加一个节点

$\color{red}移到链表的尾部，将尾部节点的next指向node$
```
'''先操作node,next'''
'''和单链表的区别，cur指向尾部，cur.next指向node'''
node.next = self._head
cur.next = node
self._head = node
```
insert(pos, item)指定位置pos添加节点
- 同单链表
$\color{Red}remove(item)删除一个节$
- 两参数cur, pre
  1. 若头节点就是要删除的点
    - 分两种情况（1.只有一个节点，2.不止一个节点）
  2. 头节点不是要删除的（注意尾部）
search(item)查找一个节点是否存在

3.2.2 代码

class SingleNode(object):
    def __init__(self, item):
        self.item = item
        self.next = None
        
class SingCycLinkedlist(object):
    def __init__(self):
        self._head = None
        
    def is_empty(self):
        return self._head == None
    
    def length(self):
        if self.is_empty():
            return 0
        else:
            cur = self._head
            count = 1
            while cur.next != self._head:
                count +=1
                cur = cur.next
            return count
     
    def travel(self):
        if self.is_empty():
            return
        else:
            cur =self._head
            while cur.next != self._head:
                print(cur.item,end=' ')
                cur = cur.next
            print(cur.item)
    
    def add(self, item):
        node = SingleNode(item)
        if self.is_empty():
            self._head = node
            node.next = self._head            
        else:
            cur = self._head
            while cur.next != self._head:
                 cur = cur.next
            
            node.next = self._head
            cur.next = node
            self._head = node
    
    def append(self,item):
        node = SingleNode(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            cur = self._head
            while cur.next != self._head:
                cur = cur.next
            
            node.next = self._head
            cur.next = node
        
    def insert(self, pos, item):
        if pos <= 0:
            self.add(item)
        elif pos >= self.length():
                self.append(item)
        else:
            node = SingleNode(item)
            pre = self._head
            count=0
            while count < pos-1:
                count += 1
                pre = pre.next
                
            node.next = pre.next
            pre.next = node
    
    def remove(self, item):
        if self.is_empty():
            return 
        '''指向头节点'''
        cur = self._head
        pre = None
        '''若头节点就是要删除的节点'''
        if cur.item == item:
            if cur.next != self._head:      # 不止一个节点                 
                '''找到尾节点，将为节点的next指向第二个节点'''
                while cur.next !=self._head:
                    cur = cur.next
                self._head = self._head.next
                cur.next = self._head
            else:                           #只有一个节点
                self._head = None
       
            '''删除的不是头节点''' 
        else:
            pre = self._head
            
            while cur.next != self._head:
                # 找到要删除的点
                if cur.item == item:
                    pre.next = cur.next
                    return
                else:
                    pre = cur
                    cur = cur.next
                    
            '''指向尾节点'''
            if cur.item ==item:
                pre.next = self._head               
    
    def search(self, item):
        cur = self._head
        while cur.next != self._head:
            if cur.item == item:
                return True
            cur = cur.next
        if cur.item == item:
            return True
        else:
            return False
            
if __name__=='__main__':        
    l2 = SingCycLinkedlist()
    l2.append(0)
    l2.add(5)
    l2.add(4)
    l2.add(3)
    l2.add(2)
    l2.add(1)
    l2.append(6)
    l2.insert(3,8)
    print('2是否在{}'.format(l2.search(2)))
    print('6是否在{}'.format(l2.search(6))) 
    print('是否为空：{}'.format(l2.is_empty()))
    print('链表长度：{}'.format(l2.length()))
    l2.remove(1)
    l2.travel()

3.3 双向链表

在这里插入图片描述

DisguiseR6

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
3_链表

3_链表顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活。链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。文章目录3_链表3.1 单向链表3.1.0 遇到问题3.1.1单链表的操作3.1.2代码3.2 单向循环链表3.2.0遇到问题3.2.1 操作3.2.2 代码3.3 双向链表3.1 单向链表单向链...
复制链接

扫一扫