数据结构-顺序表

一、定义：

数组 线性表 顺序表 的区别

①数组：

数组（array）是一种线性表数据结构，它用一组连续的内存空间来存储一组具有相同类型的数据。

一句话：
就是物理上存储在一组联系的地址上。也称为数据结构中的物理结构。

②线性表：

线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。
一句话：
线性表是数据结构中的逻辑结构。可以存储在数组上，也可以存储在链表上。除了数组，链表，队列，栈等也是线性表结构

③顺序表：

线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。用顺序存储方法存储的线性表简称为顺序表。
一句话：
用数组来存储的线性表就是顺序表。（①+②=③）

二、优缺点

优点：

• 无需为表示表中元素之间的逻辑关系而增加额外的存储空间
• 按照索引查询速度快、遍历数组方便

缺点：

• 数组大小固定后无法扩容
• 数组只能存储一种类型的数据
• 添加删除慢（需要移动其它元素）

三、顺序表的基本操作（ADT）

用python实现顺序表基本操作：增删改查

class SqList(object):
#self.Listsize是顺序表的最大存储空间，如果顺序表长度大于最大存储空间，会自动扩空间，或者就是报错。
    def __init__(self, Listsize):#初始化
        self.elem = ['Linear_logo']
        self.length = len(self.elem)
        self.Listsize = Listsize
        self.increment = 1
    
    def __del__(self):
        print("销毁顺序表")

    def ClearList(self):#清空顺序表
        self.length=0

    def isEmpty(self):#判断是否为空表
        return self.length is 0

    def ListLength(self):#求顺序表长度
        return len(self.elem)

    def GetElem(self, pos):#查找某一位置元素
        if pos <= self.length:
            return self.elem[pos]
        else:
            return False

    def LocateElem(self, item):#查找元素
        for i in range(self.length):
            if self.elem[i] == item:
                return i
        else:
            return False

    def PriorElem(self, item):#前驱元素
        if self.LocateElem(item) == False:
            return False
        else:
            return self.elem[self.LocateElem(item) - 1]

    def NextElem(self, item):#后继元素
        if self.LocateElem(item) == False:
            return False
        else:
            return self.elem[self.LocateElem(item) + 1]

    def ListInsert(self, pos, item):#在某一位置插入元素
        if pos < 1 | pos > self.length+1:
            return IndexError
        if pos == self.length:
            self.elem += [item]
            self.length += self.increment
        else:
            for i in range(self.length - 1, pos + 1, -1):
                self.elem[i] = self.elem[i - 1]
            self.elem[pos] = item
            if len(self.elem) <= (self.Listsize - 1):
                self.elem = self.elem + [item]
                self.length = self.length + 1
            else:
                print("数组已满")
        return True

    def ListDelete(self, pos):#删除某一位置元素
        if pos < 1 | pos > self.length:
            return IndexError
        for i in range(pos, self.length - 1):
            self.elem[i] = self.elem[i + 1]
        self.length -= 1
        return True

    def ListTraverse(self):#遍历顺序表
        print('<', end='')
        for i in range(0, self.length):
            if i != self.length - 1:
                print(self.elem[i], end=',')
            else:
                print(self.elem[i], end='')
        print('>')


if __name__ == '__main__':
    list = SqList(20)
    for i in range(1, 12, 1):
        list.ListInsert(i, i)
    list.ListTraverse()
    print(list.isEmpty())

四、时间复杂度

因为内存地址连续，所以访问任意元素时间复杂度O(1)，插入和删除元素由于要将后面的元素挪动，其时间复杂度O(n)。（但是插入或者删除最后元素，时间复杂度O(1)）。

使用场景：频繁查询，对存储空间要求不大；增加删除少的情况