基于python的数据结构与算法——线性表之顺序表

已于 2022-11-02 14:48:06 修改
阅读量1.5k 收藏 14
点赞数 4
分类专栏： 数据结构python版 文章标签： python 数据结构
于 2022-09-12 21:36:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44998686/article/details/126813422
版权

线性表

概念

  • 将一组（同为某个类型的）数据元素作为整体管理和使用
  • 用元素在序列里的位置和顺序，表示数据之间的某种关系
  • 线性表是一种组织数据元素的数据结构
  • 一个线性表是某类元素的一个集合+记录元素之间的顺序关系
  • 实现：list和tuple

操作

在这里插入图片描述

  • self：被操作的对象
  • elem：元素
  • op：具体的操作

两种基本的实现模型

  • 将表中元素顺序地存放在一大块连续的存储区里——顺序表
  • 将表中元素存放在通过链接构造起来的一系列存储块里——链表

顺序表的实现

基本实现方式

元素顺序存放在一片足够大的连续存储区里，首元素存入开始位置，其余元素依次顺序存放

在这里插入图片描述

  1. tuple：创建不变的顺序表，适用于建立时就确定好元素个数的存储。
  2. list：创建变动的表，需区分当前元素个数（num）和总容量（max）

基本操作的实现

一、创建和访问操作
  1. 创建空表

在这里插入图片描述

  • python函数默认值只初始化一次，也就是说这段代码的模块一旦加载进来，参数的默认值就固定不变了
  • 想要实现动态默认值用None
  • 传入的参数是可变类型时用None
import copy

maxsize = 5  # 全局变量，给定一个空间

# python函数默认值只初始化一次，也就是说这段代码的模块一旦加载进来，参数的默认值就固定不变了
# 想要实现动态默认值用None
# 传入的参数是可变类型时用None
class seqList:
    def __init__(self, A=None):
        # 不传入A，就是None,表示还没有表
        # 传入A，表示已经有个表
        self.maxsize = maxsize

        if A is None:  # 表不存在，就创建一个空表
            self.len = 0
            self.list = []
        elif len(A) > self.maxsize:
            self.len = 0
            self.list = []
            raise Exception("Warning:输入列表过大，返回一个空顺序表，以重新建一个更大的表")
        else:
            self.len = len(A)
            self.list = copy.deepcopy(A)  # deepcopy真正意义上的复制，新开辟一块空间


if __name__ == '__main__':
    s = seqList()
    print(s.list)
    A = [1, 2, 3, 4, 5]
    s = seqList(A)
    print(s.list)
    A = [1, 2, 3, 4, 5, 6]
    s = seqList(A)
    print(s.list)
  1. 简单判断操作
    在这里插入图片描述
    # 判断空
    def is_empty(self):
        return self.len == 0

    # 判断满
    def is_full(self):
        return self.len == maxsize
  1. 计算表长
    在这里插入图片描述
# 计算表长
    def count_len(self):
        length = 0
        for i in self.list:
            length += 1
        print("表长", length)
        return length
  1. 访问给定下标 i 的元素
    在这里插入图片描述
    # 访问给定下标i的元素
    def get_i(self, i):
        if (i < 1) or (i > self.len):
            raise Exception("i不合法")
        return self.list[i - 1]
  1. 查找给定元素 d 的位置（首次出现）
    在这里插入图片描述
    # 查找给定元素的第一次出现的位置
    def locate_elem(self, elem):
        for i in range(self.len):  # 下标从0到self.len-1
            if self.list[i] == elem:
                return i + 1  # 返回位序
        return 0
二、变动操作
删除

1.根据位置删
在这里插入图片描述

 # 删除位置为i的元素
    def del_by_i(self, i):
        if (i < 1) or (i > self.len):
            raise Exception("位置i不合法")
        temp = self.list[i - 1]
        for index in range(i - 1, self.len - 1):  # 左闭右开
            self.list[index] = self.list[index + 1]  # [len-2]=[len-1]
        self.list[self.len - 1] = -1
        self.len -= 1
        return temp

在这里插入图片描述

  1. 摧毁表
    在这里插入图片描述
    在这里插入图片描述
插入

在这里插入图片描述

  • 发现这个代码出错了
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

后来查阅资料才知道：

  • 由于我没有用append()，所以体验不到列表自动扩容的特性（这是个黑匣子，封装好了，隐形使用）
  • 由于python的list是动态扩展的，而我们要实现底层具有固定容量、占用一段连续的内存空间的顺序表，需要在构造函数初始化时加上下面的化，None作为无效元素的标识
self._data = [None] * self._capacity

在这里插入图片描述
在这里插入图片描述
所以我的构造函数初始化应该这样写：

    def __init__(self, A=None):
        # 不传入A，就是None,表示还没有表
        # 传入A，表示已经有个表
        self.maxsize = maxsize

        if A is None:  # 表不存在，就创建一个空表
            self.len = 0
            self.list = [None] * maxsize
        elif len(A) > self.maxsize:
            self.len = 0
            self.list = [None] * maxsize
            raise Exception("Warning:输入列表过大，返回一个空顺序表，以重新建一个更大的表")
        else:
            self.len = len(A)
            # deepcopy真正意义上的复制，新开辟一块空间
            # 本来传来一个A，然后我重新开辟一个空间，跟她一模一样，但是叫list，两个的地址不一样了
            self.list = copy.deepcopy(A)
            self.list += [None] * (maxsize - self.len)  # 原来的+再扩大（maxsize-self.len)的空间，拼接起来又给了self.list

插入才能跑起来：

 # 先判满，满就需要重新开辟
    # 插入
    def insert_elem_by_i(self, i, elem):
        if s.is_full():
            raise Exception("表已满，请扩容")
        elif (i < 1) or (i > self.len + 1):
            raise Exception("插入位置异常")
        else:
            # 中间插
            for index in range(self.len, i - 1, -1):
                self.list[index] = self.list[index - 1]
            self.list[i - 1] = elem
            self.len += 1
            return True
反转

在这里插入图片描述

    def reverse_list(self):
        list = self.list
        i, j = 0, self.len - 1
        while i < j:
            list[i], list[j] = list[j], list[i]
            i, j = i + 1, j - 1

注意

python 列表 初始化

在这里插入图片描述

总结

在这里插入图片描述

完整代码

import copy

maxsize = 5  # 全局变量，给定一个空间


# python函数默认值只初始化一次，也就是说这段代码的模块一旦加载进来，参数的默认值就固定不变了
# 想要实现动态默认值用None
# 传入的参数是可变类型时用None
class seqList:
    def __init__(self, A=None):
        # 不传入A，就是None,表示还没有表
        # 传入A，表示已经有个表
        self.maxsize = maxsize

        if A is None:  # 表不存在，就创建一个空表
            self.len = 0
            self.list = [None] * maxsize
        elif len(A) > self.maxsize:
            self.len = 0
            self.list = [None] * maxsize
            raise Exception("Warning:输入列表过大，返回一个空顺序表，以重新建一个更大的表")
        else:
            self.len = len(A)
            # deepcopy真正意义上的复制，新开辟一块空间
            # 本来传来一个A，然后我重新开辟一个空间，跟她一模一样，但是叫list，两个的地址不一样了
            self.list = copy.deepcopy(A)
            self.list += [None] * (maxsize - self.len)  # 原来的+再扩大（maxsize-self.len)的空间，拼接起来又给了self.list

    # 判断空
    def is_empty(self):
        return self.len == 0

    # 判断满
    def is_full(self):
        return self.len == maxsize

    # 访问给定下标i的元素
    def get_i(self, i):
        if (i < 1) or (i > self.len):
            raise Exception("i不合法")
        return self.list[i - 1]

    # 查找给定元素的第一次出现的位置
    def locate_elem(self, elem):
        for i in range(self.len):  # 下标从0到self.len-1
            if self.list[i] == elem:
                return i + 1  # 返回位序
        return 0

    # 计算表长
    def count_len(self):
        length = 0
        for i in self.list:
            length += 1
        print("表长", length)
        return length

    # 删除位置为i的元素
    def del_by_i(self, i):
        if (i < 1) or (i > self.len):
            raise Exception("位置i不合法")
        temp = self.list[i - 1]
        for index in range(i - 1, self.len - 1):  # 左闭右开
            self.list[index] = self.list[index + 1]  # [len-2]=[len-1]
        self.list[self.len - 1] = -1
        self.len -= 1
        return temp

    # 先判满，满就需要重新开辟
    # 插入
    def insert_elem_by_i(self, i, elem):
        if s.is_full():
            raise Exception("表已满，请扩容")
        elif (i < 1) or (i > self.len + 1):
            raise Exception("插入位置异常")
        else:
            # 中间插
            for index in range(self.len, i - 1, -1):
                self.list[index] = self.list[index - 1]
            self.list[i - 1] = elem
            self.len += 1
            return True

    def reverse_list(self):
        list = self.list
        i, j = 0, self.len - 1
        while i < j:
            list[i], list[j] = list[j], list[i]
            i, j = i + 1, j - 1

    def print_list(self):
        print(self.list[:self.len])  # 左闭右开


if __name__ == '__main__':
    A = [1, 2]
    s = seqList(A)

    s.insert_elem_by_i(2, 12)
    s.print_list()
    s.insert_elem_by_i(2, 24)
    s.print_list()
    s.insert_elem_by_i(5, 55)
    s.print_list()
    # s.reverse_list()
    # s.print_list()
数据结构Python版（一）——顺序表
⚡
06-14 5754
线性表就是数据元素的排列像一条线一样的表。线性表严格的定义是具有相同特性的数据元素组成的一个有限序列。其特征有3个：不同于集合，线性表中可以出现值相同的元素。线性表的逻辑结构一般表示为 (a0,a1,⋯ ,an−1)(a_0,a_1,\cdots,a_{n-1})(a0​,a1​,⋯,an−1​)，用 n(n≥0)n(n\geq0)n(n≥0) 表示线性表的长度（即线性表中元素的个数）。当 n=0n=0n=0 时，表示线性表是一个空表，不包含任何数据元素。线性表的逻辑特征：每个元素最多只有一个前驱元素，也最
python顺序结构的例题-python数据结构之线性表的顺序存储结构
weixin_39559119的博客
11-11 1051
用Python仿照C语言来实现线性表的顺序存储结构，供大家参考，具体内容如下本文所采用的数据结构模板为 《数据结构教程》C语言版，李春葆、尹为民等著。该篇所涉及到的是线性表的顺序存储结构。代码：# !/usr/bin/env python# -*- coding: utf-8 -*-__author__ = "MrHero"class Node(object):"&q...
【Python 实现顺序表（线性表）：从设计到实现的完整指南】
最新发布
weixin_44431770的博客
05-13 776
定义一个抽象线性表类，用于规范线性表的基本操作"""检查线性表是否为空"""pass"""获取线性表的长度"""pass"""在指定位置插入一个元素参数:pos - 插入位置item - 要插入的元素"""pass"""移除指定位置的元素参数:pos - 移除位置"""pass"""获取指定元素首次出现的位置参数:item - 要查找的元素"""pass"""遍历线性表"""pass方法名功能描述is_empty()判断线性表是否为空。
04-2_Python中的线性表
argb78546的博客
09-24 234
Python中的顺序表 Python中的list(列表)和tuple(元组)两种类型采用了顺序表的实现技术 tuple是不可变的顺序表，因此不支持改变其内部状态的任何操作，而其他方面，则与list的性质类似 listr的基本实现技术 Python标准类型list就是一种元素个数可变的线性表，可以加入和删除元素，并在各种操作中维持已有元素的顺序（即保序） 在Python的官方实现中，lis...
数据结构与算法之Python实现——顺序表
weixin_62917800的博客
10-15 3197
一刷数据结构与算法后的感言。线性表的简单理解以及顺序表的简单实现
【python】python数据结构（一）——线性表：顺序表的实现
roguesir的博客
10-17 6498
前言 这一系列文章将介绍基于python语言的数据结构，主要涉及线性表、字符串、栈和队列、二叉树和树、图、字典和集合、排序等。 线性表及分类 线性表是一类元素序列的抽象，是某类元素的集合，记录着元素之间的顺序关系。python中的list和tuple都支持线性表的需要，只是tuple中元素固定，而list则灵活的多。 顺序表：将表中元素顺序地存储在一大块连续的存储区内，这样实现的表称为顺序
Python数据结构与算法—线性表 定义线性表节点的结构.pdf
04-18
"Python数据结构与算法—线性表定义线性表节点的结构" 知识点一：线性表的定义 线性表是一种基本的数据结构类型，它的逻辑结构是描述其元素之间的逻辑关系。在计算机存储器中的映象（或表象）一般有两种形式，一种...
python数据结构学习之实现线性表的顺序
12-25
本文实例为大家分享了python实现线性表顺序的具体代码，供大家参考，具体内容如下 线性表 1.抽象数据类型表示（ADT） 类型名称：线性表 数据对象集：线性表是n(>=0)个元素构成的有序序列（a1,a2,….,an） 操作集：...
python数据结构之线性表的顺序存储结构
12-24
本文所采用的数据结构模板为 《数据结构教程》C语言版，李春葆、尹为民等著。 该篇所涉及到的是线性表的顺序存储结构。 代码： # !/usr/bin/env python # -*- coding: utf-8 -*- __author__ = 'MrHero' class ...
数据结构与算法 Python语言描述 ——裘宗燕版
07-05
《数据结构与算法 Python语言描述》是裘宗燕编著的一本专著，它深入浅出地介绍了数据结构和算法的基础知识，特别是如何利用Python语言进行实现。这本书以高清且带有目录的形式，使得读者能够方便地查找和学习相关...
Python实现顺序表——数据结构与算法课程记录
qq_73471878的博客
12-23 2519
本文章用于记录我用Python学习数据结构时敲的代码，希望给极少数也用Python学数据结构的朋友们一些帮助。
python实现顺序表的简单代码
09-20
主要为大家详细介绍了顺序表定义及python实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Python中顺序表的实现简单代码分享
09-20
主要介绍了Python中顺序表的实现简单代码分享，展示了代码运行结果，然后分享了相关实例代码，具有一定借鉴价值,需要的朋友可以参考下
自学python顺序-python数据结构学习之实现线性表的顺序
q6q6q的专栏
10-28 371
本文实例为大家分享了python实现线性表顺序的具体代码，供大家参考，具体内容如下线性表1.抽象数据类型表示（ADT）类型名称：线性表数据对象集：线性表是n(>=0)个元素构成的有序序列（a1,a2,….,an）操作集：2.线性表的顺序实现1.表示方法：其中100可以自己规定，last代表线性表的长度# 线性表定义class Lnode(object):def __init__(self,last...
数据结构与算法-python实现顺序表
哈皮霍根的博客
06-25 355
顺序表的实现和无序表相似，只是add方法中，需要添加条件判断的语句 # 链表的python实现 # 定义一个结点 class Node: def __init__(self, initdata): self.data = initdata self.next = None def getData(self): return self.data def getNext(self): return self.next
python线性表顺序存储实现_数据结构（三）——基于顺序存储结构的线性表
weixin_29048775的博客
01-14 945
数据结构(三)——基于顺序存储结构的线性表一、基于顺序存储结构的线性表实现1、顺序存储的定义线性表的顺序存储结构是用一段地址连续的存储单元依次存储线性表中的数据元素。2、顺序存储结构的操作使用一维数组实现顺序存储结构。template class SeqList:public List{protected:T* m_array;//顺序存储空间int m_length;//当前线性表的长度};一维...
python实现线性表
Ellen的博客
09-15 776
前几年经历过python从入门到放弃，最近重拾python的体会是，如果熟悉或精通类C语言，整体上可以快速、轻松的掌握基本特性。因为既然是编程语言，很多特性都是举一反三、触类旁通的，上手成本较小。工作上有了用武之地，也可以用它来巩固数据结构。
python 顺序表
06-24 524
在Python的官方实现中，list就是一种采用分离式技术实现的动态顺序表。这就是为什么用list.append(x) （或 list.insert(len(list), x)，即尾部插入）比在指定位置插入元素效率高的原因。 在Python的官方实现中，list实现采用了如下的策略：在建立空表（或者很小的表）时，系统分配一块能容纳8个元素的存储区；在执行插入操作（insert或append）时，如...
Python实现顺序表
weixin_43790276的博客
01-18 5408
Python实现顺序表 关于顺序表的介绍，请参考：https://blog.youkuaiyun.com/weixin_43790276/article/details/103848039 Python 中的列表和元组都属于顺序表，下面根据顺序表的特性，自己来实现顺序表。 一、自定义一个顺序表类 在顺序表中，“表头”部分存储了当前顺序表的容量和已经有多少个数据。初始化一个顺序表时，需要按容量开辟一段内...
Python数据结构深度解析：线性表与顺序表操作
"Python数据结构和大厂面试攻略主要涵盖了数据结构的基础概念，特别是Python中的内置数据结构，如列表和元组，以及如何利用这些数据结构进行有效的编程和解决面试问题。本文着重讨论了线性表，特别是顺序表的实现和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值