精华内容
下载资源
问答
  • python 顺序表

    2019-06-24 18:37:44
    Python的官方实现中,list就是一种采用分离式技术实现的动态顺序表。这就是为什么用list.append(x) (或 list.insert(len(list), x),即尾部插入)比在指定位置插入元素效率高的原因。 在Python的官方实现中,list...

    在Python的官方实现中,list就是一种采用分离式技术实现的动态顺序表。这就是为什么用list.append(x) (或 list.insert(len(list), x),即尾部插入)比在指定位置插入元素效率高的原因。

    在Python的官方实现中,list实现采用了如下的策略:在建立空表(或者很小的表)时,系统分配一块能容纳8个元素的存储区;在执行插入操作(insert或append)时,如果元素存储区满就换一块4倍大的存储区。但如果此时的表已经很大(目前的阀值为50000),则改变策略,采用加一倍的方法。引入这种改变策略的方式,是为了避免出现过多空闲的存储位置。

    展开全文
  • python顺序表

    2018-01-08 20:37:14
    顺序表:表头,和元素存储区 表头:容量和元素个数 元素存储区:基本布局,元素外置的布局 表头的位置:一体式,分离式 python 元素外置布局,分离式。(list,tuple)

    顺序表:表头,和元素存储区
    表头:容量和元素个数
    元素存储区:基本布局,元素外置的布局
    表头的位置:一体式,分离式
    python 元素外置布局,分离式。(list,tuple)

    展开全文
  • 1.python顺序表的存储形式 python的每个int型占四个字节(每个Byte是八个bit),比如Li = [12,"ab",1.23,399],存储形式如下 由于不同的数据类型占据的字节不一样,比如char型每个字母占据一个字节,则"ab"占两个...

    1.python顺序表的存储形式

    python的每个int型占四个字节(每个Byte是八个bit),比如Li = [12,"ab",1.23,399],存储形式如下

    由于不同的数据类型占据的字节不一样,比如char型每个字母占据一个字节,则"ab"占两个字节,这样寻址方式0x23+相对地址x4就不实用,所以每个内址存储真是数据的地址,因为地址都是整型所以都是占据四个字节,这样存储形式就做到了顺序存储,我们把真实数据的地址叫做外址

    2.顺序表的两种实现形式

    max保存申请的空间比如8,num存储现在存有的空间比如5,num<=max,如果需要添加第九个数据就得重新向内存申请空间,原有的空间作废,所以我们有两种实现形式,通常采用第二种

    通常采用下面一种方式,由于每次申请一块内存都是固定的大小,如果往列表添加数据就得重新开辟内存空间,第一种形式需要重新开辟所有空间,而第二种形式仅仅需要开辟数据地址的空间。

    展开全文
  • Python实现顺序表

    千次阅读 2020-01-18 18:41:17
    Python实现顺序表 关于顺序表的介绍,请参考:https://blog.csdn.net/weixin_43790276/article/details/103848039 Python 中的列表和元组都属于顺序表,下面根据顺序表的特性,自己来实现顺序表。 一、自定义一个...

    Python实现顺序表

    关于顺序表的介绍,请参考:https://blog.csdn.net/weixin_43790276/article/details/103848039

    Python 中的列表和元组都属于顺序表,下面根据顺序表的特性,自己来实现顺序表。

    一、自定义一个顺序表类

    在顺序表中,“表头”部分存储了当前顺序表的容量和已经有多少个数据。初始化一个顺序表时,需要按容量开辟一段内存来作为顺序表的数据存储空间,初始顺序表中的元素个数为0。

    定义一个顺序表类 SequenceList ,初始化时可以指定顺序表的长度并开辟对应的存储空间,如默认长度为10,顺序表中的元素个数为0。

    # coding=utf-8
    class SequenceList(object):
    
        def __init__(self, max=10):
            self.max = max
            self.data = [None] * self.max
            self.num = 0

    这样,就定义了一个顺序表类,实例化一个类对象就可以创建一个顺序表,只是还没有实现相应的功能。

    二、实现顺序表的展示功能

        def is_empty(self):
            return self.num is 0
    
        def is_full(self):
            return self.num is self.max
    
        def show(self):
            print('<', end='')
            for i in range(0, self.num):
                if i != self.num-1:
                    print(self.data[i], end=',')
                else:
                    print(self.data[i], end='')
            print('>')

    先实现判断顺序表是否为空的方法 is_empty() 和是否已满的方法 is_full(),这两个方法比较简单,如果顺序表中的数据是0个,则为空,如果数据数量已经达到了最大容量,则顺序表已满。

    Python中的列表是用中括号,元组是小括号,所以也可以模仿,在展示自定义的顺序表时,使用尖括号,具体见 show() 方法。

    if __name__ == '__main__':
        s = SequenceList()
        print("is_empty: ", s.is_empty())
        print("is_full: ", s.is_full())
        s.show()

    运行结果:

    is_empty:  True
    is_full:  False
    <>

    三、实现顺序表中添加数据的功能

        def add(self, value):
            for j in range(self.num, 0, -1):
                self.data[j] = self.data[j-1]
            self.data[0] = value
            self.num += 1
    
        def append(self, value):
            self.data[self.num] = value
            self.num += 1
    
        def insert(self, i, value):
            if not isinstance(i, int):
                raise TypeError
            if i < 0:
                self.add(value)
            if i > self.num:
                self.append(value)
            for j in range(self.num, i, -1):
                self.data[j] = self.data[j-1]
            self.data[i] = value
            self.num += 1
    
        def count(self):
            return self.num

    添加数据到顺序表中,可以从头部添加、从尾部添加或从指定位置添加。

    add(value):从头部添加时,为了保证顺序表的顺序关系,原有的数据需要依次往后移动一个位置,所以从顺序表尾部开始遍历,将每个数据的索引值都加1,然后将添加的数据放在顺序表的第一个位置,添加完成后将顺序表的数量加1。

    append(value):从尾部添加时,直接将数据添加在顺序表最后一个数据的后面,然后将顺序表的数量加1。

    insert(i, value):在指定位置添加数据时,指定位置前面的数据不变,后面的数据都需要往后移动一个位置,所以从顺序表尾部开始遍历,将这些数据的索引值都加1,然后将添加的数据放在指定位置,再将顺序表的数量加1。

    如果指定的位置是负数或超过了顺序表最大长度,则需要特殊处理,上面的处理是负数就在头部添加,超过最大长度就在尾部添加。也可以直接抛出 IndexError ,这个按需实现就可以了。

    同时实现了查看顺序表长度的方法 count(),返回当前顺序表的数据个数。

        s.add(1)
        s.add(10)
        s.append(2)
        s.append(3)
        s.append(4)
        s.show()
        s.insert(1, 20)
        s.show()
        print("顺序表长度:", s.count())

    运行结果:

    <10,1,2,3,4>
    <10,20,1,2,3,4>
    顺序表长度: 6

    四、实现顺序表的查询和修改功能

        def is_exist(self, value):
            for j in range(self.num):
                if self.data[j] == value:
                    return True
            else:
                return False
    
        def index(self, value):
            for j in range(self.num):
                if self.data[j] == value:
                    return j
            else:
                return -1
    
        def __getitem__(self, item):
            if not isinstance(item, int):
                raise TypeError
            if 0 <= item < self.num:
                return self.data[item]
            else:
                raise IndexError
    
        def __setitem__(self, key, value):
            if not isinstance(key, int):
                raise TypeError
            if 0 <= key < self.num:
                self.data[key] = value
            else:
                raise IndexError

    在顺序表中添加数据后,就不再是一个空的表了。会有很多关于顺序表中的数据查询需求。

    is_exist(value):判断一个数据是否存在顺序表中,遍历顺序表的每个数据,如果数据值与目标值相等,则说明顺序表中存在目标值。

    index(value):返回一个数据在顺序表中的索引位置,与判断是否存在的实现方式一样,这里返回的是索引的值,如果顺序表中没有这个数据,则返回-1。

    __getitem__(item):根据索引查询某个索引的数据,给定一个索引值,直接返回顺序表中该位置的数据即可,如果给的索引值超出了索引范围,应该直接抛出 IndexError 。这个方法之所以重写 Python 中的 __getitem__() 魔法方法,是因为 __getitem__() 实现了列表下标的方式来操作数据,支持 s[1] 这种类型的语法。这样写之后,既可以使用 s[1] 来获取顺序表中索引1的数据,也可以使用 s.__getitem__(1) ,结果相同。

    __setitem__(key, value):修改指定位置的数据,先根据给定的索引值,找到顺序表中该索引的数据,然后修改。重写 __setitem__() 方法的原因与 __getitem__() 相同。

        s.show()
        print(s.is_exist(200))
        print(s.index(20))
        print(s.__getitem__(1))
        print(s[1])
        s[2] = 30
        s.__setitem__(3, 40)
        s.show()

    运行结果:

    <10,20,1,2,3,4>
    False
    1
    20
    20
    <10,20,30,40,3,4>
    

    五、实现顺序表的删除功能

        def remove(self, i):
            if not isinstance(i, int):
                raise TypeError
            if i < 0 or i >= self.num:
                raise IndexError
            for j in range(i, self.num):
                if j == self.num-1:
                    self.data[j] = None
                else:
                    self.data[j] = self.data[j+1]
            self.num -= 1
    
        def delete(self, value):
            for i in range(self.num):
                if self.data[i] == value:
                    self.remove(i)
                    return
    
        def delete_all(self, value):
            for i in range(self.num):
                if self.data[i] == value:
                    self.remove(i)
                    self.delete_all(value)

    对顺序表执行删除操作之后,依然要保证顺序表中的数据顺序关系。

    remove(i):删除指定索引的数据,删除指定索引位置的数据之后,该索引后面的数据都要依次往前移动。所以从指定索引的位置开始,依次将后一个位置的数据赋值给前一个位置,就实现了数据的删除。如果到了最后一个位置,则直接将它赋值为空就可以了。删除之后,顺序表的数量减1。

    delete(value):删除指定值的数据,先遍历顺序表,找到对应值的索引,然后调用上面按索引删除的方法,即可删除指定的数据。使用这个方法,如果顺序表中有多个满足条件的数据,只会删除最前面的一个数据。

    delete_all(value):删除所有相等的值,如果顺序表中有多个数据与指定值相等,删除第一个数据后,顺序表中数据的数量 self.num 会减1,继续遍历顺序表,会出现删除不完全甚至程序出错的情况。所以在删除第一个数据之后,递归调用自身,这样重新遍历时使用的是减1之后的 self.num ,不会出现漏删或错误。(也可以自己使用其他方式实现)

        s.show()
        s.remove(5)
        s.show()
        s.append(4)
        s.append(4)
        s.append(4)
        s.append(4)
        s.append(4)
        print("is_full: ", s.is_full())
        s.show()
        print("s的长度:", s.count())
        s.delete(4)
        s.show()
        s.delete_all(4)
        s.show()

    运行结果:

    <10,20,30,40,3,4>
    <10,20,30,40,3>
    is_full:  True
    <10,20,30,40,3,4,4,4,4,4>
    s的长度: 10
    <10,20,30,40,3,4,4,4,4>
    <10,20,30,40,3>

    以上就是 Python 中顺序表及一些简单方法的实现。

    上面的顺序表容量默认设置是10,如果超过10(可以改大)会报 IndexError ,使用时要注意。因为这个顺序表类中没有实现动态扩容的方法,不像 Python 中的列表有自动扩容的机制,如果需要的话可以继续实现扩容的方法。

     

    展开全文
  • Python中的顺序表

    2018-08-28 09:57:47
    Python中的顺序表 Python中的list和tuple两种类型采用了顺序表的实现技术,具有顺序表的所有性质。 tuple是不可变类型,即不变的顺序表,因此不支持改变其内部状态的任何操作,而其他方面,则与list的性质类似。 ...
  • 数据结构之python实现顺序表

    千次阅读 多人点赞 2019-01-19 22:38:39
    顺序表
  • Python中的顺序表Python中的顺序表list的基本实现技术 2.4. Python中的顺序表 Python中的顺序表 Python中的list和tuple两种类型采用了顺序表的实现技术,具有前面讨论的顺序表的所有性质。 tuple是不可变类型,即...
  • 基于python实现顺序表(简单)

    千次阅读 2020-11-17 19:50:54
    所以尝试用python写了部分的代码(本人小白)(基于python的list) 全文语法简单,易懂** 如果有错,请各位大神指导一下; ```python import string class Sequen(): def __init__(self): self.list=[]//创建一个...
  • def __init__(self,length):#length表示顺序表的长度,决定此顺序表最多存储多少元素 self.length=length self.data=[] #data表示顺序表内容 self.biao=-1 #元素下标 def weikong(self):#判断 这个顺序表...
  • 顺序表即线性表的顺序存储结构。它是通过一组地址连续的存储单元对线性表中的数据进行存储的,相邻的两个元素在物理位置上也是相邻的。比如,第1个元素是存储在线性表的起始位置LOC(1),那么第i个元素即是存储在LOC...
  • 顺序表Python实现
  • 顺序表 在程序中,经常需要将一组(通常是同为某个类型的)数据元素作为整体管理和使用,需要创建这种元素组,用变量记录它们,传进传出函数等。一组数据中包含的元素个数可能发生变化(可以增加或删除元素)。 对于...
  • 基础数据结构:顺序表、链表(单链表、双向循环链表)——Python实现 在最初学习数据结构时,相信大家一定都是从线性表开始的,因为它是最简单、最基本、最常用的一种线性结构,根据存储方法可分为顺序表和链表,基本...
  • 顺序表 一组序列元素的组织形式,我们可以将其抽象为线性表。一个线性表是某类元素的一个集合,还记录着元素之间的一种顺序关系。线性表是最基本的数据结构之一,在实际程序中应用非常广泛,它还经常被用作更复杂的...
  • 顺序表的实现(python

    千次阅读 2018-12-11 20:29:17
    利用python内置的list来实现顺序表 class SequenceList(object): &amp;quot;&amp;quot;&amp;quot;顺序表&amp;quot;&amp;quot;&amp;quot; def __init__(self, size=6): # 初始化顺序...
  • 第一部分:顺序表 一.线性表及其分类 1.一个线性表是某类元素的一个集合,记录着元素之间的一种顺序关系。根据线性表的实际存储方式,分为两种实现模型: 1)顺序表,将元素顺序地存放在一块连续的存储区里,元素间的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 128,750
精华内容 51,500
关键字:

python顺序表

python 订阅