顺序表-Python

一、创建顺序表

我们学习了，有关于线性表的创建，其中涉及的基本操作有，重新定义容量大小，由一个数组a来进行创建线性表，在末尾添加一个元素，以及查找序号为i的的元素值和设置序号为i的元素值，在这个过程中，如果时涉及一个序号的时候一般需要用断言来判断其合法性，如果涉及添加删减元素，则需要进行相应的扩容和减容，其中，比较关键的几个点，是，进行插入和删除操作，需要进行移动操作，比方说，在i处进行插入，则需要从后往前遍历，将前一个的元素值赋值给后一个，以此来实现，i以及其后的元素后移，给插入的元素腾出空间。

class SqList:
    def __init__(self):
        self.initcapacity=5
        self.capacity=self.initcapacity
        self.data=[None]*self.capacity
        self.size=0
    def resize(self,newcapacity):
        assert newcapacity>=0
        olddata=self.data
        self.capacity=newcapacity
        self.data=[None]*newcapacity #为data重新分配一个容量
        for i in range(self.size):
            self.data[i]=olddata[i]
    def CreateList(self,a):
        for i in range(len(a)):
            if self.size==self.capacity:
                self.resize(2*self.size)
            self.data[self.size]=a[i]
            self.size+=1
    def Add(self,e):
        if self.size==self.capacity:
            self.resize(2*self.size)
        self.data[self.size]=e
        self.size+=1
    def getsize(self):
        return self.size
    def __getitem__(self,i):
        assert 0<=i<self.size
        return self.data[i]
    def __setitem__(self,i,e):
        assert 0<=i<self.size
        self.data[i]=e
    def Insert(self,i,e):
        assert 0<=i<self.size
        if self.size==self.capacity:
            self.resize(2*self.size)
        for j in range(self.size,i-1,-1):
            self.data[j]=self.data[j-1]
        self.data[i]=e
        self.size+=1
    def GetNo(self,e):
        i=0
        while i<self.size and self.data[i]!=e:
            i+=1
        if i>=self.size:
            return -1
        else:
            return i
    def Delete(self,i):
        for j in range(i,self.size-1):
            self.data[j]=self.data[j+1]
        self.size-=1
        if self.capacity>self.initcapacity and self.size<=self.capacity/4:
            self.resize(self.capacity//2)
    def Display(self):
        for i in range(self.size):
            print(self.data[i],end=' ')
        print()
#主程序
L=SqList()
a=[1,2,3,4]
L.CreateList(a)
L.Insert(1,9)
L.Delete(0)
L.Add(6)
print("%d"%L.getsize())
L.Display()

二、基本算法

实现逆转算法

def Reverse(L):
    i=0
    j=L.getsize()-1
    while i<j:
        L[i],L[j]=L[j],L[i]
        i+=1
        j-=1

删除k个元素

def Deletek(L,i,k):
    assert i>=0 and k>=1 and i+k<=L.getsize()
    for j in range(i+k,L.size):
        L[j-k]=L[j]
    L.size-=k

删除一个顺序表中所有值为x的值

解法一
用k来进行记录，遍历整个顺序表，如果满足不为x，则用该顺序表进行再存储，

def Deletex1(L,x):
    k=0
    for i in range(L.getsize()):
        if L[i]!=x:
            L[k]=L[i]
            k+=1
    L.size=k    

解法二

def Deletex2(L,x):
    k=0
    for i in range(L.getsize()):
        if L[i]!=x:
            L[i-k]=L[i]
        else:
            k+=1
    L.size-=k

解法三
用j来遍历整个顺序表，遇到不为x的值，将其放到前面去，也就是说i增加用来逐渐存储符合条件的值（保留的），因为是从0开始算一个元素，所以size=i+1。就是说，j走在前面，那么i在后面遇到一个可以保留的值时i才可以走一步。以此来指向下一个元素达到存储保留值得目的。

def Deletex3(L,x):
     i=-1
     j=0
     while j<L.getsize():
         if L[j]!=x:
             i+=1
             if i!=j:
                 L[i],L[j]=L[j],L[i]
         j+=1
     L.size=i+1

二路归并

这个程序的目的是将两个顺序表进行合并，并排序，这时，我们可以这样做，就是说，我们用两个指针分别指向两个顺序表，并将其进行比较大小，将小的放入新的顺序表中，这个小的指针继续往后移，直到遍历完一个顺序表，再来判断，哪个顺序表没有遍历完，再接着遍历依次将其存储到新的顺序表中。这里看出其实，最开始的表也是按大小顺序存储的。

def Merge2(A,B):
    C=SqList()
    i=j=0 #i用于遍历A,j用于遍历B
    while i<A.getsize() and j<B.getsize():
        if A[i]<B[j]:
            C.Add(A[i])
            i+=1
        else:
            C.Add(B[j])
            j+=1
    while i<A.getsize():
        C.Add(A[i])
        i+=1
    while j<B.getsize():
        C.Add(B[j])
        j+=1
    return C
a1=[1,3,5,7]
b1=[2,4,6]
A=SqList()
B=SqList()
A.CreateList(a1)
B.CreateList(b1)
C=Merge2(A,B)
C.Display()