数据结构之————线性表ADT、以数组存储方式实现抽象类型的一个实例_什么是线性表中adt的方法

前言：基础填坑

1、ADT

在文章开始前，我们要弄明白什么是ADT（Abstract Data Type）抽象数据类型
1、ADT是用户定义的数据类型，它包含一组数据以及在这组数据上进行的操作。只定义操作的行为，没有具体的实现细节
2、它存在的目的是使我们能够独立于程序的实现细节来理解数据结构的特性。
3、抽象数据类型ADT的定义取决于它的一组逻辑特性，而与计算机内部如何表示无关

2、线性表

相同特性的数据元素 有序数列

3、python常用4种内置数据结构：列表、元组、集合、字典的对比

这里的可变性是指该数据结构创建后能否被修改

4、对数据结构的理解,第三方提供的其他数据结构（也可以自己定义，后文展示如何自己定义）

它主要指的是数据元素之间的相互关系，即数据的组织形式。简单来说，数据结构就是用来组织、存储和管理数据的方式或方法。

数据结构可以分为逻辑结构和物理结构。逻辑结构是从逻辑关系上描述数据的，它与数据的存储无关，是独立于计算机的。逻辑结构主要包括线性结构、树形结构、图形结构等。而物理结构，也叫存储结构，是指数据结构在计算机中的表示（又称映像），它包括数据元素的表示和关系的表示。物理结构主要有顺序存储和链式存储两种方式。

选择何种数据结构来组织数据，会直接影响到算法的效率。比如，我们常用的 数组（array）、链表（linkedlist）、栈（stack）、队列（queue）、树（tree）、图（graph) 等都是数据结构的具体表现形式。

所以，当我们说数据结构时，我们实际上是在谈论如何有效地组织和管理数据，以便在计算机程序中更有效地使用这些数据。

虽然python的标准库没有直接提供这些数据结构，但有许多第三方库（eg. NumPy pandas collections等）提供了这些数据结构的高效实现。

一、定义抽象基类和接口

知识储备：

1、abstract base classes模块实现，定义抽象数据类型ADT
2、ADT是用户定义的数据类型，它包含一组数据以及在这组数据上进行的操作。只定义操作的行为，没有具体的实现细节
3、list类是一个抽象基类，它定义了多种方法，这些方法要由继承list类的子类来提供具体的实现
4、raise NotImplementedError是故意在这里抛出的异常，
目的是提醒开发者在实现具体的子类时，需要为这些抽象方法提供具体的实现，这样的设计允许开发者创建不同的列表实现，比如基于数组的列表、链表等，而所有这些实现都会遵循相同的接口（即这些方法）。
这样，使用这些列表的代码就可以不必关心具体的实现细节，只需要调用这些定义好的方法即可。

代码

import abc
class List(metaclass=abc.ABCMeta):
    #用@abc.abstractmethod装饰器来实现，表示该方法需要在子类中实现
    #如果子类中4444444没有实现这些方法，会在实例化子类时候抛出typeerror错误
    @abc.abstractmethod
    def clear(self):
        # Remove all data from list
        raise NotImplementedError
    @abc.abstractmethod
    def insert(self, item):
        # Insert item at curr position
        raise NotImplementedError
    @abc.abstractmethod
    def append(self, item):
        # Insert item at tail of list
        raise NotImplementedError
    @abc.abstractmethod
    def remove(self):
        # Remove/Return current item
        raise NotImplementedError
    @abc.abstractmethod
    def setFirst(self):
        # Set current to first position
        raise NotImplementedError
    @abc.abstractmethod
    def next(self):
        # Move current to next position
        raise NotImplementedError
    @abc.abstractmethod
    def prev(self):
        # Move current to prev position
        raise NotImplementedError
    @abc.abstractmethod
    def length(self):
        # Return current length of list
        raise NotImplementedError
    @abc.abstractmethod
    def setPos(self, pos: int):
        # Set current to specified pos
        raise NotImplementedError
    @abc.abstractmethod
    def setValue(self, item):
        # Set current item's value
        raise NotImplementedError
    @abc.abstractmethod
    def currValue(self):
        # Return value of current item
        raise NotImplementedError
    @abc.abstractmethod
    def isEmpty(self) -> bool:
        # Return true if list is empty.
        raise NotImplementedError
    @abc.abstractmethod
    def isInList(self) -> bool:
        # True if current is within list
        raise NotImplementedError
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

二、List抽象类类型的一个具体化实现，采用的存储方式为数组

测试

知识储备

在Python中，if name == “main”: 这句代码是用来判断一个Python文件是否作为主程序运行，而不是被导入为一个模块。

这里的 name 是一个内置变量，它表示当前模块的名字。当一个Python文件（或模块）被直接运行时，name 的值会被设置为 “main”。但是，如果这个文件被另一个文件导入为一个模块，那么 name 的值就会是这个模块的名字。

这种结构允许一个Python文件既可以被其他文件导入使用其中的函数或类，又可以作为一个独立的程序运行。

下面是一个简单的例子：

#文件名: mymodule.py

def hello_world():
    print("Hello, World!")

if __name__ == "__main__":
    print("This file is being run directly.")
    hello_world()
1
2
3
4
5
6
7
8

如果你直接运行 mymodule.py，输出将会是：

This file is being run directly.
Hello, World!
1
2

但是，如果你在另一个Python文件中导入 mymodule.py，比如：

#文件名: another_file.py

import mymodule
print("Importing mymodule")
1
2
3
4

然后运行 another_file.py，输出将会是：

Importing mymodule
1

注意，This file is being run directly. 和 Hello, World! 这两行并没有输出，因为 mymodule.py 并不是直接运行的，而是被 another_file.py 导入的。

这种结构是Python编程中的一个常见模式，它使得代码更加模块化和可重用。

代码

#这个文件是List抽象类类型的一个具体化实现，采用的存储方式为数组

from listADT import List
class AList(List):
    def __init__(self, size=10):
        self.__mSize = size
        self.__numInList = 0
        self.__curr = 0
        self.__listArray = [None] * size

    def clear(self):
        self.__numInList = 0
        self.__curr = 0

    def insert(self, item):
        if not (self.__numInList < self.__mSize):
            raise ValueError("List is Full.")
        if self.__curr < 0 or self.__curr > self.__numInList:
            raise ValueError("Bad value for curr position.")
        # 将存储空间中索引从curr+1 到 numInlist-1的元素内容向后移动1个位置
        for i in range(self.__numInList, self.__curr, -1):
            self.__listArray[i] = self.__listArray[i - 1]
        # 将item放置到索引位置为curr的存储空间中
        self.__listArray[self.__curr] = item
        self.__numInList += 1

    def append(self, item):
        #判断数组是否为满
        if not (self.__numInList < self.__mSize):
            raise ValueError("List is Full.")
        self.__listArray[self.__numInList] = item
        self.__numInList += 1

    def remove(self):
        if self.isEmpty():#空数组否？
            raise ValueError("Can't delete from empty list.")
        if not self.isInList():#在数组中否？
            raise ValueError("No current element.")
        it = self.__listArray[self.__curr]
        for i in range(self.__curr, self.__numInList - 1):
            self.__listArray[i] = self.__listArray[i + 1]
        self.__numInList -= 1
        return it

    def setFirst(self):
        self.__curr = 0

    def next(self):
        self.__curr += 1

    def prev(self):
        self.__curr -= 1

    def length(self):
        return self.__numInList

    def setPos(self, pos: int):
        self.__curr = pos

    def setValue(self, item):
        if not self.isInList():
            raise ValueError("No current element.")
        self.__listArray[self.__curr] = item

    def currValue(self):
        if not self.isInList():
            raise ValueError("No current element.")
        return self.__listArray[self.__curr]

    def isEmpty(self):
        return self.__numInList == 0

    def isInList(self):
        return 0 <= self.__curr < self.__numInList

    '''
    下面的若干方法实现全部都是为了让自定义的类类型能够融入到Python的生态环境中。
    __eq__:用来判断自定义类型的两个对象是否相等，不同类型的相等性定义规则不一样；
    __iter__:让某个类型具有可迭代的能力，比如在for循环中可以用在in符号之后；
    __len__:可以作用到系统函数len()；
    __contains__:可以使用in运算符；
    __str__:用来将对象转换成字符串形式，方便print，可以作用到系统函数str()中。
    '''
    def __eq__(self, other):
        if type(other) != type(self):
            return False
        if self is other:
            return True
        if self.__numInList != other.__numInList:
            return False
        for i in range(self.__numInList):
            if self.__listArray[i] != other.__listArray[i]:
                return False
        return True

    def __iter__(self):
        for i in range(self.__numInList):
            yield self.__listArray[i]

    def __len__(self):
        return self.__numInList

    def __contains__(self, item):
        for it in self:
            if it == item:
                return True
        return False

    def __str__(self):
        s = "["
        for i in range(self.__numInList):
            s = s + str(self.__listArray[i])
            if i < self.__numInList - 1:
                s = s + ", "
        s = s + "]"
        return s

#当这个文件被当作模块时不会执行以下代码
if __name__ == "__main__":
    # 这个位置可以做一些简单的数据结构测试
    mylist = AList(100)
    print(mylist,end='/')
    mylist.insert(10)
    mylist.insert(12)
    mylist.insert(34)
    mylist.setFirst()
    mylist.insert(8)
    mylist.next()
    mylist.next()
    mylist.insert(11)
    print(mylist,end='/')
    print(mylist.remove(),end='/')
    print(mylist,end='/')
    print(len(mylist),end='/')
    for curr in mylist:
        print(curr)
    if 10 in mylist:
        print("OK")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

三、 基于数组实现的具体例子

元素插入

判断： 空间够不够，当前位置的合理存在


前件 有没有元素可删，curr是否合理

元素删除

其他方法同上分析