【线性表--顺序表（python描述）】

线性表分为两种存储形式：顺序存储和链式存储

顺序存储 ：

顺序存储中，线性表的节点按照逻辑依次存放在一组地址连续的存储单元中，用这种方法存储的线性表称为顺序表，有两个特征：1.逻辑顺序与物理顺序一致 ；2.数据元素之间的关系是以元素在计算机内‘物理位置相邻’来体现的。假设顺序表的每个元素的数据类型相同，设需要n个存储单元，每个元素需要占L个存储单元，以第一个元素所占的存储地址作为数据元素的起始位置，则顺序表第i+1个数据元素的存储位置Loc(i+1)和第i个数据元素的存储位置Loc（i）之间满足：Loc(i+1)=Loc(i)+L。

1 初始化顺序表:

def __init__(self,max):
        self.max = max    #顺序表的最大容量
        self.index = 0    
        self.data = [None for _ in range(self.max)]:
        
#在dog=Dog(11)中，11为传递给max

2 按照下标来查找元素:

def __getitem__(self,index):
    #获取下标为index的元素
    if index < 0 or index >= sel.index:
       raise IndexError('非法')
    else:
       return self.data[index]
 

3 修改下标为index的元素:

def __setitem__(self,index,value):
   if index < 0 or index >= self.index:
       raise IndexError('index 非法')
   else:
       self.data[index] = value

4 判断顺序表是否为空:

def  empty(self):
    return self.index is 0
    

5 插入表头元素

def append(self,value):
   if self.index is self.max:
      return
   else:
      self.data[self.index] = value
      self.index = self.index + 1

6 在顺序表任意位置插入元素：

'''先判断index下标是否合法，若不合法，则抛出异常；若合法，则通过for讲下标为index及
其之后的元素向后移动一个位置，并在下标index所在的位置添加元素，代码实现如下：
'''
def insert(self,index,value):
    if index < 0 or index > self.index:
       raise IndexError('index非法')
    if index == self.index:  #index刚好是顺序表表尾
       self.append(value)
    else:
       self.data += {0]
       for i in range(self.index,index,-1):
            self.data[i] = self.data[-1]
       self.data[index = value
       self.index += 1
    return self.data

7 删除表尾元素：

def pop(self):
    if self.empty():
       return
    self.index -=1
    del self.data[-1]
    return self.data

tips:深浅拷贝

不可变对象有：大部分是python内置数据类型： 数字，字符串，元组
除ID之外，其他状态都有可能发生改变,可变对象有：列表、集合、字典

l = []
print("修改前id= ", id(l))
 
l.append(132)
print("修改后id= ", id(l))
print(l)

#输出的两次Idj结果一致

i = 1
print("修改前id= ", id(i))
 
i = 4
print("修改后id= ", id(i))  # id 变化了，说明数据的修改不是建立在原内存的， 而是新申请了内存，保存新的值
print(i)

#输出的两次的id不一致

深浅拷贝：

ls = [1,2,3]
ls2 = ls
ls2[0]=8
print(ls2]
'''此时会发现ls2也变成了[8,2,3],因为其实‘ls2=ls’只是一个浅拷贝，并没有分配新的内存空间，只是
让ls2指向ls的地址，所以，改ls2的时候，等于是修改了ls2指向的地址的内容
'''

import copy
ls3=copy.deepcopy(ls)
ls3[0]=9
print(ls3)
'''
此处发现输出的ls没有因为ls3的改变而改变，因为这里的deepcopy是深拷贝，为ls3开辟了新内存空间
'''

8 删除任意位置的元素:

def delete(self,index):
   if self.empty() or index >= self.index:
       raise IndexError('index非法')
   for i in range(index,self.index):
       self.data[i]=self.data[i+1]
   self.index -= 1
   return self.data

9 获取顺序表长度：

def getlen(self):
    self.leng=len(self.data)
    return self.leng
    

10 遍历顺序表并打印每一个元素：

def travalsal(self):
    for i in self.data:
        print(i)
     

构造的顺序表例子：

#!/usr/bin/python3
# 线性表分为顺序表和链表

#  顺序表
class SL:
    def __init__(self):
        self.data = []

    def ifempty(self):
        if len(self.data) == 0:
            print('is empty')
        else:
            print('not empty')

    def createL(self,j):
        if len(self.data) == 0:
           for i in range(0,j):
                self.data.append(i)
        return self.data

    def lengL(self):
        lengthL=len(self.data)
        return lengthL

    def insertL(self,i,e):

        leng=len(self.data)
        #self.data[i + 1] = e
        self.data.append(0)
        print(self.data)
        for j in range(leng,i,-1):  #从第leng-1个元素（包含）一直往前遍历到第i个元素（不包含）
            self.data[j]=self.data[j-1]
        self.data[i+1]=e
        print('在第：',i,'个元素后'+'插入元素：',e)
        return self.data

    def deleteL(self,i,e):
        leng = len(self.data)
        for j in range(i-1,leng):
            if j==i-1:
                e=self.data[j]
            self.data[j]=self.data[j+1]
        return self.data,e

    def createL(self):
        self.data.append('j')
        self.data.append('a')

    def selectL(self,e):
        for i in range(0,len(self.data)):
            if self.data[i]==e:
                print('序号为：',i)


if __name__ == "__main__":      ##########保护被import时不被调用

    SL1=SL()
    SL1.createL()
    print(SL1.insertL(0,'p'))
    SL1.selectL('j')