Python实现顺序表——数据结构与算法课程记录

本文章用于记录我用Python学习数据结构时敲的代码，希望给极少数也用Python学数据结构的朋友们一些帮助。

文章开始前必须提一点，Python的列表（list）本身就是一个顺序表，和本文定义的顺序表（SeqList）功能完全一致，故用Python定义SeqList没什么很大的作用，只是给刚入门的朋友们做一下练习。

先介绍一下我的基本思路（其实很简单）：

1.写一个顺序表的类

2.根据要实现的功能，在类里边定义相对应的函数

下面开始一步步介绍我的代码：

1.建立一个类，取名为SeqList，再定义一个初始化函数，参数为max

这时，定义的顺序表的结构为一个列表（list）：[None, None, ...... , None]，长度为self.max

self.max：顺序表最大长度

self.num：顺序表中现有元素的个数

class SeqList(object):

    "初始化"
    def __init__(self, max=10):
        self.max = max
        self.num = 0
        self.data = [None] * self.max

2.定义函数，判断顺序表是否为空，是否已满

is_empty：不用输入参数。顺序表现有元素个数为0时，为空

is_full：不用输入参数。顺序表现有元素等于其最大长度，为满

    "判断顺序表是否为空"
    def is_empty(self):
        return self.num == 0

    "判断顺序表是否已满"
    def is_full(self):
        return self.num == self.max

3.定义函数，根据索引找值和根据值找索引

get_value：输入参数idx（索引）

get_idx：输入参数value（值）

    "根据索引找值"
    def get_value(self, idx):
        if not isinstance(idx, int):  # 判断idx是否是int类型（是否是整数）
            raise TypeError
        if 0 <= idx < self.num:  # 判断idx的取值范围是否在0至self.num-1（不能取self.num）
            return self.data[idx]
        else:
            return IndexError

    "根据值找索引"
    def get_idx(self, value):
        for i in range(self.num):
            if self.data[i] == value:
                return i
            else:
                if i == self.num - 1:  # 当SeqList中没有对应的value，等i达到最大值时，报错
                    raise "No the value in this seqlist"

4.定义函数，根据索引修改值和统计顺序表的长度

set_item：输入参数idx、value

get_len：不用输入参数

    "根据索引修改值"
    def set_item(self, idx, value):
        if not isinstance(idx, int):  # 判断idx是否是int类型（是否是整数）
            raise TypeError
        if 0 <= idx < self.num:  # 判断idx的取值范围是否在0至self.num-1（不能取self.num）
            self.data[idx] = value
        else:
            raise IndexError

    "统计顺序表的长度"
    def get_len(self):
        return self.num

5.定义函数，从顺序表的末尾插入元素

append_last：输入参数value（补充一下：append本身就有从末尾插入的意思，加个last是和Python本身list的append函数加以区分，虽然好像没什么必要，我后面别的函数也取名和list的函数相同了(⊙﹏⊙)）

    "顺序表末尾插入"
    def append_last(self, value):
        if self.is_full() is True:  # 判断顺序表是否已满
            raise "This SeqList is full. Fail to append_last"
        else:
            self.data[self.num] = value
            self.num += 1  # 插入元素后，顺序表已有元素+1

6.定义函数，从顺序表任意位置插入元素

insert：输入参数idx、value

    "顺序表任意位置插入"
    def insert(self, idx, value):
        if not isinstance(idx, int):  #判断idx是否为int类型（是否为整数）
            raise TypeError
        if idx < 0 or idx >= self.num:  # idx为复数或大于等于self.num时报错
            raise IndexError
        else:
            for i in range(self.num, idx, -1):  # 顺序表元素依次后延
                self.data[i] = self.data[i - 1]
            self.data[idx] = value  # 对应位置插入元素
            self.num += 1  # 长度加一

注：此处解释一下上处代码

    for i in range(self.num, idx, -1):
           self.data[i] = self.data[i - 1]

i从self.num到idx+1（取不了idx），将第i-1个元素赋值给第i个元素，如下所示：

在idx为4处插入元素8： [1, 2, 3, 4, 5, 6]  ——> [1, 2, 3, 4, 8, 5, 6]

上述代码即修改5、6的位置

7.定义函数，删除顺序表任意位置的元素

remove：输入参数idx

    "顺序表任意位置删除"
    def remove(self, idx):
        if not isinstance(idx, int):
            raise TypeError
        if idx < 0 or idx >= self.num:
            raise IndexError
        for i in range(idx, self.num-1):  # 把值依次往前传递，末尾的值暂时不动
            self.data[i] = self.data[i + 1]
        self.data[self.num-1] = None  # 顺序表末尾的值直接修改为None
        self.num += -1  # 长度-1

8.定义函数，动态扩容顺序表

insert_auto：输入参数idx、value

    "顺序表动态扩容"
    def insert_auto(self, idx, value):
        if not isinstance(idx, int):
            raise TypeError
        if idx < 0:
            raise IndexError
        if 0 <= idx < self.num:  # idx处于闭区间0至self.num-1上时
            if self.is_full() is True:  # 顺序表已满，先扩容再插入，扩容分两步
                self.max += 1  # 第一步，最大长度扩容
                self.data += [None] * 1  # 第二步，实际装载元素的列表（list）扩容
                self.insert(idx, value)
            else:
                self.insert(idx, value)  # 顺序表未满，直接插入元素
        else:                            # idx大于等于self.num时
            if self.is_full() is True:  # 顺序表已满，先扩容再插入
                self.max += 1
                self.data += [None] * 1
                self.append_last(value)
            else:
                self.append_last(value)  # 顺序表未满，直接插入元素

9.定义函数，打印顺序表和销毁顺序表

    "打印顺序表"
    def print_seqlist(self):
        for i in range(self.num):
            print(self.data[i], end=" ")

    "销毁操作（初始化）"
    def destroy(self):
        self.__init__()

10.测试，此处我没有做很严谨的测试，随便测试了一下，大家可以自己测试

if __name__== "__main__":
    s = SeqList()
    print("---------------------")
    print("---------------------")
    s.append_last(1)
    s.append_last(2)
    s.append_last(3)
    s.append_last(4)
    s.append_last(5)
    s.append_last(6)
    s.append_last(7)
    s.append_last(8)
    s.append_last(9)
    s.append_last(10)
    s.print_seqlist()
    print("---------------------")
    print("---------------------")
    s.remove(5)
    s.print_seqlist()
    print("---------------------")
    print("---------------------")
    s.append_last(9)
    s.print_seqlist()
    print("---------------------")
    print("---------------------")
    s.insert_auto(100, 100)
    s.insert_auto(100, 200)
    s.print_seqlist()
    print("---------------------")
    print("---------------------")
    print(s.get_idx(100))
    print(s.get_value(7))
    s.set_item(10, 999)
    s.print_seqlist()
    print(s.get_len())

结果为

---------------------
---------------------
1 2 3 4 5 6 7 8 9 10 ---------------------
---------------------
1 2 3 4 5 7 8 9 10 ---------------------
---------------------
1 2 3 4 5 7 8 9 10 9 ---------------------
---------------------
1 2 3 4 5 7 8 9 10 9 100 200 ---------------------
---------------------
10
9
1 2 3 4 5 7 8 9 10 9 999 200 12

最后把全部代码一起展示一下：

class SeqList(object):

    "初始化"
    def __init__(self, max=10):
        self.max = max
        self.num = 0
        self.data = [None] * self.max

    "判断顺序表是否为空"
    def is_empty(self):
        return self.num == 0

    "判断顺序表是否已满"
    def is_full(self):
        return self.num == self.max

    "根据索引找值"
    def get_value(self, idx):
        if not isinstance(idx, int):
            raise TypeError
        if 0 <= idx < self.num:
            return self.data[idx]
        else:
            return IndexError

    "根据值找索引"
    def get_idx(self, value):
        for i in range(self.num):
            if self.data[i] == value:
                return i
            else:
                if i == self.num - 1:
                    raise "No the value in this seqlist"

    "根据索引修改值"
    def set_item(self, idx, value):
        if not isinstance(idx, int):
            raise TypeError
        if 0 <= idx < self.num:
            self.data[idx] = value
        else:
            raise IndexError

    "统计顺序表的长度"
    def get_len(self):
        return self.num

    "顺序表末尾插入"
    def append_last(self, value):
        if self.is_full() is True:
            raise "This SeqList is full. Fail to append_last"
        else:
            self.data[self.num] = value
            self.num += 1

    "顺序表任意位置插入"
    def insert(self, idx, value):
        if not isinstance(idx, int):
            raise TypeError
        if idx < 0 or idx >= self.num:
            raise IndexError
        else:
            for i in range(self.num, idx, -1):
                self.data[i] = self.data[i - 1]
            self.data[idx] = value
            self.num += 1

    "顺序表任意位置删除"
    def remove(self, idx):
        if not isinstance(idx, int):
            raise TypeError
        if idx < 0 or idx >= self.num:
            raise IndexError
        for i in range(idx, self.num-1):
            self.data[i] = self.data[i + 1]
        self.data[self.num-1] = None
        self.num += -1

    "顺序表动态扩容"
    def insert_auto(self, idx, value):
        if not isinstance(idx, int):
            raise TypeError
        if idx < 0:
            raise IndexError
        if 0 <= idx < self.num:
            if self.is_full() is True:
                self.max += 1
                self.data += [None] * 1
                self.insert(idx, value)
            else:
                self.insert(idx, value)
        else:
            if self.is_full() is True:
                self.max += 1
                self.data += [None] * 1
                self.append_last(value)
            else:
                self.append_last(value)

    "打印顺序表"
    def print_seqlist(self):
        for i in range(self.num):
            print(self.data[i], end=" ")

    "销毁操作（初始化）"
    def destroy(self):
        self.__init__()

if __name__== "__main__":
    s = SeqList()
    print("---------------------")
    print("---------------------")
    s.append_last(1)
    s.append_last(2)
    s.append_last(3)
    s.append_last(4)
    s.append_last(5)
    s.append_last(6)
    s.append_last(7)
    s.append_last(8)
    s.append_last(9)
    s.append_last(10)
    s.print_seqlist()
    print("---------------------")
    print("---------------------")
    s.remove(5)
    s.print_seqlist()
    print("---------------------")
    print("---------------------")
    s.append_last(9)
    s.print_seqlist()
    print("---------------------")
    print("---------------------")
    s.insert_auto(100, 100)
    s.insert_auto(100, 200)
    s.print_seqlist()
    print("---------------------")
    print("---------------------")
    print(s.get_idx(100))
    print(s.get_value(7))
    s.set_item(10, 999)
    s.print_seqlist()
    print(s.get_len())

顺序表代码暂时就这么多了，希望能够对新手有所帮助。