【数据结构】顺序表、链表

写的不好，欢迎批评指正。

顺序表

顺序表是一种支持随机访问下标的数据结构。通常用数组进行实现。

typedef int SQDataType;

typedef struct SeqList{
	SQDatatype* arr;
	size_t size;
	size_t capacity;
}SeqList;

顺序表的创建

SeqList* SeqCreate()
{
	SeqList* ptr = (SeqList*)malloc(sizeof(SeqList));
	if(ptr == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	ptr->arr = NULL;
	ptr->size = 0;
	ptr->capacity = 0;
	return ptr;
}

顺序表的扩容

void SeqCheckCapacity(SeqList* ptr)
{
	assert(ptr);
	if(ptr->size * sizeof(SQDataType) == ptr->capacity)
	{
		size_t NewCapacity = ptr->capacity == 0 ? sizeof(SQDataType) : 2 * ptr->capacity;
		SQDataType* tmp = (SQDataType*)realloc(ptr->arr, NewCapacity);
		if(tmp == NULL)
		{
			perror("cealloc fail");
			return;
		}
		ptr->arr = tmp;
	}
}

顺序表尾插

void SeqBackPush(SeqList* ptr, SQDataType x)
{
	assert(ptr);
	SeqCheckCapacity(ptr);
	ptr->arr[ptr->size] = x;
	ptr->size++;
}

顺序表尾删

void SeqBackPop(SeqList* ptr)
{
	assert(ptr);
	ptr->size--;
}

顺序表头插

void SeqFrontPush(SeqList* ptr, SQDataType x)
{
	assert(ptr);
	SeqCheckCapacity(ptr);
	for(int i = ptr->size - 1; i > 0; i--)// 执行size - 1次
	{
		ptr->arr[i] = ptr->arr[i - 1];
	}
	ptr->arr[0] = x;
	ptr->size++;
}

顺序表头删

void SeqFrontPop(SeqList* ptr)
{
	assert(ptr);
	assert(ptr->size);
	SeqCheckCapacity(ptr);
	for(int i = 0; i < ptr->size - 1; i++)// 执行size - 1次
	{
		ptr->arr[i] = ptr->arr[i + 1];
	}
	ptr->size--;
}

在随机位置后插入值

void SeqInsert(SeqList* ptr, SQDataType x, int pos)/pos为要插入的位置下标
{
	SeqCheckCapacity(ptr);
	assert(pos <= ptr->size - 1);
	int len = ptr->size;
	for(int i = len; i > pos, i--)
	{
		ptr->arr[i] = ptr->arr[i - 1];
	}
	ptr->arr[pos + 1] = x;
}

查找某个元素

int SeqFind(SeqList* ptr, SQDataType x)
{
	int len = ptr->size;
	for(int i = 0; i < len; i++)
	{
		if(ptr->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

顺序表的大小

size_t SeqSize(SeqList* ptr)
{
	assert(ptr);
	return ptr->size;
}

判断顺序表是否为空

int SeqEmpty(SeqList* ptr)
{
	if(ptr->size == 0)
	return 1;

	else
	return 0;
}

销毁顺序表

void Destroy(SeqList* ptr)
{
	free(ptr->arr);
	ptr->arr = NULL;
	ptr->size = 0;
	ptr->capacity = 0;
	free(ptr);
}

链表

链表分为单链表和双链表，带或不带哨兵位，是否循环。
以下为单向不带哨兵位不循环链表。

typedef int LTDataType;

typedef struct ListNode{
	LTDataType val;
	struct ListNode* next;
}Node;

链表节点的创建

Node* CreateNode()
{
	Node* ptr = (Node*)malloc(sizeof(Node));
	if(ptr == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	ptr->val = 0;
	ptr->next = NULL;
}

链表的头插

void ListHeadPush(Node** pphead, LTDataType x)
{
	Node* NewNode = CreateNode();
	NewNode->next = *pphead;
	NewNode->val = x;
	*pphead = NewNode;
}

链表的头删

void ListHeadPop(Node** phead)
{
	Node* del = *phead;
	assert(**phead && *phead);
	*phead = (*phead)->next;
	free(del);
	del = NULL;
}

链表的尾插

void ListBackPush(Node* phead, LTDataType x)
{
	Node* cur = phead;
	while(cur->next != NULL)
	{
		cur = cur->next;
	}
	Node* NewNode = CreateNode();
	cur->next = NewNode;
	NewNode->val = x;
}

链表的尾删

void ListBackPop(Node** pphead)
{
	Node* cur = phead;
	assert(cur);
	if(cur->next == NULL)//只有一个节点
	{
		free(cur);
		*pphead = NULL;
	}
	else
	{
		while(cur->next->next != NULL)//找倒数第二个节点
		{
			cur = cur->next;
		}
		Node* del = cur->next;
		free(del);
		cur->next = NULL;
	}
}

在随机位置后插入值

void ListInsert(Node** pphead, Node* Insert, LTDataType x)
{
	if(*pphead == NULL && Insert == NULL)
	{
		Node* NewNode = CreateNode();
		NewNode->val = x;
		NewNode->next = head;
		*pphead = NewNode;
	}
	else
	{
		assert(pphead && Insert && *pphead);
		Node* NewNode = CreateNode();
		NewNode->next = Insert->next;
		Insert->next = NewNode;
		NewNode->val = x;
	}
}

链表的大小

int ListSize(Node* phead)
{
	int count = 0;
	assert(phead);
	Node* cur = phead;
	while(cur)
	{
		cur = cur->next;
		count++;
	}
	return count;
}

查找某个元素

Node* ListFind(Node* phead, LTDataType x)
{
	Node* cur = phead;
	while(cur)
	{
		if(cur->val == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

判断是否为空

int ListEmpty(Node* phead)
{
	if(ListSize(phead))
	{
		return 0;
	}
	else
	{
		return 1;
	}
}