【数据结构连载一线性表】【顺序表】python

# -*- coding: UTF-8 -*-
"""
线性表之顺序存储结构
    python 使用list模拟顺序表
    基本操作:
        初始化 __init__
        线性表空判断 empty
        清空线性表   clear
        获取元素    get
        是否存在数据  exist
        插入操作    insert
        删除操作    delete
        线性表的长度  length
    扩展操作
        遍历顺序表 show
        顺序表从头开始添加 add
        顺序表添加到最后 append
        顺序表删除最后元素 pop
"""


class List(object):

    def __init__(self, max_size):
        """
        顺序表的初始化
        _length：当前顺序表的长度
        _l： 顺序表的存储
        """
        self._length = 0
        self._max_size = max_size
        self._l = [None] * max_size

    def get(self, index):
        """
        获取顺序表中的元素
        时间复杂度为O(1)
        :param index:要获取的元素下表
        :return:
        """
        if index < 0 or index >= self._length:
            return -1
        return self._l[index]

    def exist(self, data):
        """
        顺序表判断是否存在
        时间复杂度为O(n)
        :param data:
        :return:
        """
        for i in range(self._length):
            if self._l[i] == data:
                return True
        return False

    def length(self):
        """
        顺序表的长度
        时间复杂度为O(1)
        :return:
        """
        return self._length

    def clear(self):
        """
        顺序表的清空
        时间复杂度为O(1)
        :return:
        """
        self._length = 0
        self._l = [None] * self._max_size

    def empty(self):
        """
        顺序表判断是否为空
        时间复杂度为O(1)
        :return:
        """
        return self._length == 0

    def insert(self, index, data):
        """
        顺序表的插入操作
        时间复杂度为O(n)
        :param data: 要插入的数据
        :param index: 要插入的位置
        :return:
        """
        if self._length == self._max_size:
            raise Exception("顺序表已满")
        if index < 0 or index >= self._max_size:
            raise Exception("插入位置错误")
        if index < self._length:
            for i in range(self._length, index, -1):
                self._l[i] = self._l[i - 1]
        else:
            index = self._length
        self._l[index] = data
        self._length += 1

    def pop(self):
        """
        顺序表删除最后一个元素
        时间复杂度为O(1)
        :return:
        """
        self._length -= 1
        value = self._l[self._length]
        self._l[self._length] = None
        return value

    def add(self, data):
        """
        顺序表插入到第一个位置
        时间复杂度为O(n)
        :param data:
        :return:
        """
        if self._length == self._max_size:
            raise Exception("顺序表已满")
        for i in range(self._length, 0, -1):
            self._l[i] = self._l[i - 1]
        self._l[0] = data
        self._length += 1

    def append(self, data):
        """
        顺序表插入到最后
        时间复杂度为O(1)
        :param data:
        :return:
        """
        if self._length == self._max_size:
            raise Exception("顺序表已满")
        self._l[self._length] = data
        self._length += 1

    def delete(self, i):
        """
        顺序表的删除操作
        时间复杂度为O(n)
        :param i:
        :return:
        """
        if i < 0 or i > self._max_size:
            raise Exception("删除错误")
        if i < self._length:
            for i in range(i, self._length - 1):
                self._l[i] = self._l[i + 1]
        self._length -= 1

    def show(self, reverse=False):
        """
        展示列表数据
        :return:
        """
        if reverse:
            start = self._length - 1
            end = -1
            step = -1
            add = 1
        else:
            start = 0
            end = self._length
            step = 1
            add = -1
        print("[", end="")
        for i in range(start, end, step):
            print(self._l[i], end="")
            if i != end + add:
                print(",", end="")
        print("]")


if __name__ == '__main__':
    l = List(10)
    for i in range(5, 15):
        l.append(i)
    print(l.pop())

    l.show()