【1】数据结构的顺序表章

顺序表的定义

• 用顺序存储结构实现的线性表成为顺序表
• 物理存储地址为相邻顺序的存储结构
  

顺序表的初始化

• 顺序表的定义
• 初始化顺序表
• 判断是否为空表
• 获取表的长度
• 展示顺序表

class SeqList:
    """
    顺序表的定义
    """
    # 初始化顺序表
    def __init__(self, maxSize):
        """
        初始化
        :param maxSize: 顺序表的最大容量
        """
        # 设置顺序表的最大容量
        self.maxSize = maxSize
        # 记录顺序表中最后一个数据元素的位置。如果为空表，则为-1；如果为满表，则为maxSize-1
        self.last = -1
        # 创建元素列表：创建一个空间大小为指定大小的列表
        self.data = [None for _ in range(self.maxSize)]
    # 判断空表
    def isEmpty(self):
        """
        判断顺序表是否为空表
        :return:True or False
        """
        # 如果顺序表中的最后一个数据元素在列表中的位置为-1，则返回True,否则返回False
        return self.last == -1
    # 顺序表长度
    def getLength(self):
        """
        获取顺序表的长度
        :return:当前顺序表中数据元素的个数
        """
        return self.last + 1
    # 展示顺序表
    def display(self):
        """
        展示顺序表中的数据元素
        :return:
        """
        if self.isEmpty():
            print("当前顺序表为空表！")
            return
        print("顺序表的数据元素为：",end="")
        for i in range(self.last + 1):
            print(self.data[i], end=",")

顺序表的查找

按序号查找

• 要求查找顺序表中的第index个数据元素，若合法，则返回index-1下标对应的数据元素。

# 查找操作--按序号查找
    def getData(self, index):
        """
        按序号查找
        :param index: 待查找的位置
        :return: 查找位置的数据元素
        """
        #判断是否合法
        if index <= 0 or index > self.last + 1:
            raise IndexError("index 非法")
        """
        raise ValueError("a 必须是数字")
        raise TypeError("参数类型不匹配")
        raise KeyError("字典中不存在的键")
        raise NameError("变量未定义")
        raise ZeroDivisionError("除数不能为零")
        raise AssertionError("断言失败")
        raise SyntaxError("语法错误")
        raise IOError("文件不存在")
        raise ImportError("无法导入模块")
        raise RuntimeError("运行时错误")
        raise MemoryError("内存不足")
        raise RecursionError("递归深度超过最大限制")
        raise SystemExit("程序正常退出")
        raise OverflowError("数值溢出")
        """
        # 返回待查找位置的数据元素
        return self.data[index - 1]

按内容查找

• 要求的是给定一个数据值，返回在表中的index+1值，即数值在表中的位置，则是返回-1。

# 查找操作--按内容查找
    def locate(self, key):
        """
        按内容查找
        :param key: 待查找的值
        :return: 返回位置
        """
        # 初始化待查找关键值的位置为-1
        index = -1
        # 遍历顺序表，如果找到，则获得当前位置，并退出循环；如果没有找到，则index为-1
        for i in range(self.last + 1):
            if self.data[i] == key:
                index = i + 1
                break
        return index

顺序表的插入与删除

插入

• 直接在表的尾部追加数据元素。

# 插入操作--尾部
    def append(self, data):
        """
        在顺序表尾部追加数据元素
        :return:
        """
        # 如果顺序表已满，表示不允许追加
        if self.last == self.maxSize - 1:
            raise IndexError("当前顺序表已满")
        self.last += 1
        self.data[self.last] = data
        return print('已在尾部追加数据元素成功！')

• 在表中的任意位置添加数据元素。

# 插入操作--任意位置
    def insert(self,index,data):
        """
        在任意位置插入数据元素
        :param index: 插入的位置
        :param data: 插入的值
        :return:
        """
        if index <= 0 or index > self.last + 1:
            raise IndexError("index 非法")
        if self.last == self.maxSize - 1:
            raise IndexError("顺序表已满，不允许继续插入数据元素")
        for i in range(self.last+1, index-1, -1):
            self.data[i] = self.data[i-1]
        self.data[index-1] = data
        self.last += 1
        return print("插入成功")

删除

• 在表中任意位置删除数据元素

    def detele(self,index):
        """
        在任意位置删除数据元素
        :param index: 插入数据元素的位置
        :return:
        """
        if self.isEmpty():
            raise IndexError("当前顺序表为空表")
        if index <= 0 or index > self.last + 1:
            raise IndexError("index 非法")
        data = self.data[index-1]
        for i in range(index - 1, self.last + 1):
            self.data[i] = self.data[i + 1]
        self.last -= 1
        return data

顺序表的合并

• 将已有的两个顺序有序的表listA和listB，进行合并成一个新的有序的顺序表listC。

    def merge(self, listB):
        """
        合并算法
        :param listB: 待合并的顺序表B
        :return:
        """
        # 设置三个顺序表的指针
        i = 0
        j = 0
        k = 0
        # 初始化顺序表listC
        listC = SeqList(100)
        # 循环，进行顺序表listA和B表的合并
        while i <= self.last and j <= listB.last:
            if self.data[i] <= listB.data[j]:
                listC.data[k] = self.data[i]
                i += 1
                k += 1
            else:
                listC.data[k] = listB.data[j]
                j += 1
                k += 1
        # 顺序表listA剩余的元素
        while i <= self.last:
            listC.data[k] = self.data[i]
            i += 1
            k += 1
        # 顺序表listB剩余元素
        while j <= listB.last:
            listC.data[k] = listB.data[j]
            j += 1
            k += 1
        # 最后确定listC的长度
        listC.last = k - 1
        return listC

顺序表的调试与总代码

• main主函数调试

if __name__ == '__main__':
    # print('PyCharm')

    # 初始化顺序表
    list = SeqList(100)
    list.display()
    # 创建顺序表
    for i in range(10):
        list.append(chr(ord("A")+ i))
    list.display()
    # 获取顺序表的长度
    length = list.getLength()
    print('当前顺序表的长度为：%d'% length)
    # 按序号查找
    data = list.getData(10)
    print("按序号查找的结果：%s" % data)
    # 按内容查找
    index = list.locate("D")
    if index == -1:
        print("未找到元素D")
    else:
        print("按内容查找的结果：%d"% index)
    # 顺序表中任意位置插入
    list.insert(4, "T")
    list.display()
    # 任意位置删除元素
    data = list.detele(4)
    print("被删除元素：%s"% data)
    list.display()
    # 合并算法
    # 1.设置原始数据
    dataA = (8, 21, 25, 49, 62)
    dataB = (16, 37, 54, 72, 82, 90)
    # 2.创建顺序表listA
    listA = SeqList(100)
    for i in range(len(dataA)):
        listA.append(dataA[i])
    listA.display()
    # 3.创建顺序表listB
    listB = SeqList(100)
    for j in range(len(dataB)):
        listB.append(dataB[j])
    listB.display()
    # 4.合并
    listC = listA.merge(listB)
    listC.display()

• 所有代码汇总

# 顺序表的实现
class SeqList:
    """
    顺序表的定义
    """
    # 初始化顺序表
    def __init__(self, maxSize):
        """
        初始化
        :param maxSize: 顺序表的最大容量
        """
        # 设置顺序表的最大容量
        self.maxSize = maxSize
        # 记录顺序表中最后一个数据元素的位置。如果为空表，则为-1；如果为满表，则为maxSize-1
        self.last = -1
        # 创建元素列表：创建一个空间大小为指定大小的列表
        self.data = [None for _ in range(self.maxSize)]
    # 判断空表
    def isEmpty(self):
        """
        判断顺序表是否为空表
        :return:True or False
        """
        # 如果顺序表中的最后一个数据元素在列表中的位置为-1，则返回True,否则返回False
        return self.last == -1
    # 顺序表长度
    def getLength(self):
        """
        获取顺序表的长度
        :return:当前顺序表中数据元素的个数
        """
        return self.last + 1
    # 展示顺序表
    def display(self):
        """
        展示顺序表中的数据元素
        :return:
        """
        if self.isEmpty():
            print("当前顺序表为空表！")
            return
        print("顺序表的数据元素为：",end="")
        for i in range(self.last + 1):
            print(self.data[i], end=",")

    # 查找操作--按序号查找
    def getData(self, index):
        """
        按序号查找
        :param index: 待查找的位置
        :return: 查找位置的数据元素
        """
        #判断是否合法
        if index <= 0 or index > self.last + 1:
            raise IndexError("index 非法")
        """
        raise ValueError("a 必须是数字")
        raise TypeError("参数类型不匹配")
        raise KeyError("字典中不存在的键")
        raise NameError("变量未定义")
        raise ZeroDivisionError("除数不能为零")
        raise AssertionError("断言失败")
        raise SyntaxError("语法错误")
        raise IOError("文件不存在")
        raise ImportError("无法导入模块")
        raise RuntimeError("运行时错误")
        raise MemoryError("内存不足")
        raise RecursionError("递归深度超过最大限制")
        raise SystemExit("程序正常退出")
        raise OverflowError("数值溢出")
        """
        # 返回待查找位置的数据元素
        return self.data[index - 1]

    # 查找操作--按内容查找
    def locate(self, key):
        """
        按内容查找
        :param key: 待查找的值
        :return: 返回位置
        """
        # 初始化待查找关键值的位置为-1
        index = -1
        # 遍历顺序表，如果找到，则获得当前位置，并退出循环；如果没有找到，则index为-1
        for i in range(self.last + 1):
            if self.data[i] == key:
                index = i + 1
                break
        return index
    # 插入操作--尾部
    def append(self, data):
        """
        在顺序表尾部追加数据元素
        :return:
        """
        # 如果顺序表已满，表示不允许追加
        if self.last == self.maxSize - 1:
            raise IndexError("当前顺序表已满")
        self.last += 1
        self.data[self.last] = data
        return print('已在尾部追加数据元素成功！')
    # 插入操作--任意位置
    def insert(self,index,data):
        """
        在任意位置插入数据元素
        :param index: 插入的位置
        :param data: 插入的值
        :return:
        """
        if index <= 0 or index > self.last + 1:
            raise IndexError("index 非法")
        if self.last == self.maxSize - 1:
            raise IndexError("顺序表已满，不允许继续插入数据元素")
        for i in range(self.last+1, index-1, -1):
            self.data[i] = self.data[i-1]
        self.data[index-1] = data
        self.last += 1
        return print("插入成功")
    def detele(self,index):
        """
        在任意位置删除数据元素
        :param index: 插入数据元素的位置
        :return:
        """
        if self.isEmpty():
            raise IndexError("当前顺序表为空表")
        if index <= 0 or index > self.last + 1:
            raise IndexError("index 非法")
        data = self.data[index-1]
        for i in range(index - 1, self.last + 1):
            self.data[i] = self.data[i + 1]
        self.last -= 1
        return data
    # 合并操作
    def merge(self, listB):
        """
        合并算法
        :param listB: 待合并的顺序表B
        :return:
        """
        # 设置三个顺序表的指针
        i = 0
        j = 0
        k = 0
        # 初始化顺序表listC
        listC = SeqList(100)
        # 循环，进行顺序表listA和B表的合并
        while i <= self.last and j <= listB.last:
            if self.data[i] <= listB.data[j]:
                listC.data[k] = self.data[i]
                i += 1
                k += 1
            else:
                listC.data[k] = listB.data[j]
                j += 1
                k += 1
        # 顺序表listA剩余的元素
        while i <= self.last:
            listC.data[k] = self.data[i]
            i += 1
            k += 1
        # 顺序表listB剩余元素
        while j <= listB.last:
            listC.data[k] = listB.data[j]
            j += 1
            k += 1
        # 最后确定listC的长度
        listC.last = k - 1
        return listC

if __name__ == '__main__':
    # print('PyCharm')

    # 初始化顺序表
    list = SeqList(100)
    list.display()
    # 创建顺序表
    for i in range(10):
        list.append(chr(ord("A")+ i))
    list.display()
    # 获取顺序表的长度
    length = list.getLength()
    print('当前顺序表的长度为：%d'% length)
    # 按序号查找
    data = list.getData(10)
    print("按序号查找的结果：%s" % data)
    # 按内容查找
    index = list.locate("D")
    if index == -1:
        print("未找到元素D")
    else:
        print("按内容查找的结果：%d"% index)
    # 顺序表中任意位置插入
    list.insert(4, "T")
    list.display()
    # 任意位置删除元素
    data = list.detele(4)
    print("被删除元素：%s"% data)
    list.display()
    # 合并算法
    # 1.设置原始数据
    dataA = (8, 21, 25, 49, 62)
    dataB = (16, 37, 54, 72, 82, 90)
    # 2.创建顺序表listA
    listA = SeqList(100)
    for i in range(len(dataA)):
        listA.append(dataA[i])
    listA.display()
    # 3.创建顺序表listB
    listB = SeqList(100)
    for j in range(len(dataB)):
        listB.append(dataB[j])
    listB.display()
    # 4.合并
    listC = listA.merge(listB)
    listC.display()