数据结构--顺序表（C&&python）

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])

以上仅是个人（初学者）对与顺序表的初步学习，发布在此，仅是对自己起到一个后期复习和查漏补缺的作用。诸君，共勉！