1.顺序表的定义
typedef int SLDataType;
//顺序表的动态存储
typedef struct SequentialList {
SLDataType* arr;
size_t size;//顺序表中元素的个数
size_t capacity;//顺序表的容量
}SeqList;
解释:首先重命名顺序表中元素的类型,这样可以方便管理顺序表中的元素类型,只需将int更改。
再重命名结构体,减少后面代码的冗长。
2.顺序表的初始化
void SeqListInit(SeqList* List)
{
List->arr = NULL;
List->size = List->capacity = 0;
}
3.顺序表的销毁
void SeqListDestory(SeqList* List)
{
free(List->arr);
List->arr = NULL;
List->size = List->capacity = 0;
}
4.顺序表的打印
void SeqListPrint(SeqList* List)
{
for (int i = 0; i < List->size; i++)
{
printf("%d ", List->arr[i]);
}
printf("\n");
}
5.顺序表的扩容
void SeqListCheckCapacity(SeqList* List)
{
if (List->size == List->capacity)
{
int newcapacity = List->capacity == 0 ? 4 : List->capacity * 2;
SLDataType* tmp = (SLDataType*)realloc(List->arr, newcapacity * sizeof(SLDataType));
if (tmp == NULL)
{
printf("realloc fail\n");
exit(-1);
}
List->arr = tmp;
List->capacity = newcapacity;
}
}
解释:如果顺序表元素的个数和容量相等,将容量扩大两倍(因为2倍是一个较为合适的大小)
6.顺序表的尾插
void SeqListPushBack(SeqList* List, SLDataType x)
{
SeqListCheckCapacity(List);
List->arr[List->size] = x;
List->size++;
}
7.顺序表的尾删
void SeqListPopBack(SeqList* List)
{
//温柔处理
//if (List->size > 0)
// {
//List->arr[List->size - 1] = 0;
// List->size--;
//}
//暴力处理
assert(List->size > 0);
List->size--;
//倘若不进行判断,假如删除过多,会使size的大小为一个非常大的数(由于size的类型size_t)。
}
解释:在进行删除前,需先判断是否顺序表中还有元素。而温柔方式和暴力方式的区别是:当顺序表中元素不足时,温柔方式不会报错,而暴力方式会报错。
8.顺序表的头插
void SeqListPushFront(SeqList* List, SLDataType x)
{
SeqListCheckCapacity(List);//扩容
int end = List->size + 1;
while (--end > 0)
{
List->arr[end] = List->arr[end - 1];
}
List->arr[end] = x;
List->size++;
}
解释:在进行插入前,先判断顺序表是否需要扩容
9.顺序表的头删
void SeqListPopFront(SeqList* List)
{
assert(List->size > 0);
int begin = -1;
while (++begin < List->size - 1)
{
List->arr[begin] = List->arr[begin + 1];
}
--List->size;
}
解释:同样的,在删除之前,判断顺序表中元素是否足够,同样也分为温柔方式和暴力方式,此处省略温柔方式(个人更喜欢暴力处理方式)
10.顺序表的查找(下标)
int SeqListFind(SeqList* List, SLDataType x)
{
for (int i = 0; i < List->size; i++)
{
if (x == List->arr[i])
{
return i;
}
}
return -1;//没有找到返回-1
}
11.顺序表的任意位置插入
void SeqListInsert(SeqList* List, size_t pos, SLDataType x)
{
assert(pos > 0 && pos <= List->size + 1);
SeqListCheckCapacity(&List);
int i;
for (i = List->size - 1; i > pos - 1; i--)
{
List->arr[i] = List->arr[i - 1];
}
++List->size;
List->arr[i] = x;
}
解释:pos是插入第几个的位置,而不是下标,并且在插入之前判断位置(pos)是否合法
12.顺序表的任意位置删除
void SeqListErase(SeqList* List, size_t pos)
{
assert(pos > 0 && pos < List->size + 1);
for (int i = pos - 1; i < List->size - 1; i++)
{
List->arr[i] = List->arr[i + 1];
}
--List->size;
}
解释:同样的,pos是插入第几个的位置,而不是下标。并且在删除之前判断位置(pos)是否合法
python伪代码:
class SequentialList:
def __init__(self):
"""初始化顺序表"""
self.capacity = 10 # 顺序表的容量
self.size = 0 # 顺序表的大小
self.elements = [0] * self.capacity # 一个列表,储存顺序表中的元素,初始化全为0
def __del__(self):
"""销毁顺序表"""
del self.elements # 删除对象的element属性,可以释放该属性所占用的内存
def ssize(self):
"""获取顺序表元素的个数"""
return self.size
def is_empty(self):
"""判断顺序表是否为空"""
return self.size == 0
def resize(self):
"""顺序表扩容"""
new_capacity = self.capacity * 2
new_elements = [0] * new_capacity
for i in range(self.size):
new_elements[i] = self.elements[i]
self.capacity = new_capacity
self.elements = new_elements
def insert(self, index, element):
"""在指定的index插入element"""
if index < 0 or index > self.size:
raise ValueError("Invalid index")
if self.size == self.capacity:
self.resize()
for i in range(self.size - 1, index - 1, -1):
self.elements[i] = self.elements[i - 1]
self.elements[index] = element
self.size += 1
def remove(self, index):
"""删除index处的元素"""
if index < 0 or index > self.size:
raise ValueError("Invalid index")
for i in range(index + 1, self.size):
self.elements[i - 1] = self.elements[i]
self.size -= 1
def get(self, index):
"""获取index处的元素"""
if index < 0 or index > self.size:
raise ValueError("Invalid index")
return self.elements[index]
def find_index(self, element):
"""查找element的下标"""
for i in range(self.size):
if self.elements[i] == element:
return i
return -1 # 没找到
def __iter__(self):
"""迭代顺序表中的元素"""
for i in range(self.size):
yield self.elements[i]
def __str__(self):
"""打印顺序表"""
return "Sequential List:" + str(self.elements[:self.size])
以上仅是个人(初学者)对与顺序表的初步学习,发布在此,仅是对自己起到一个后期复习和查漏补缺的作用。诸君,共勉!