顺序表和链表

引子：线性表

线性表是n个具有相同特性的元素数据的有限序列，在逻辑上数据依次存储。

顺序表和链表都属于线性表。

一、顺序表

1.1概念

顺序表是一段物理地址连续的储存单元依次存储数据元素的线性结构，一般情况下采用数组存储。

分为两种类型：

①静态顺序表：用定长数组存储元素。

缺点：难以确定需要开辟的大小N，给小了不够用，给大了浪费，不实用，价值小。

例如：开辟大小为N=7的顺序表

#define N 7
typedef int SLDataType;//定义数据类型

typedef struct SeqList
{
    SLDataType array[N];//定长数组
    size_t size;//有效的数据个数
}SeqList;

②动态顺序表：使用动态开辟的数组内存

1.2接口实现

#include 
#include 
#include 
 
typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;
 
// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps);
void SeqListDestroy(SeqList* ps);
 
void SeqListPrint(SeqList* ps);
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);
void SeqListPopBack(SeqList* ps);
 
// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

#include"SeqList.h"
 
 
//初始化
void SeqListInit(SeqList* ps)
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}
 
 
//销毁
void SeqListDestroy(SeqList* ps)
{
	if (ps->a = NULL)
	{
		free(ps->a);
		ps->a = NULL;
		ps->size = 0;
		ps->capacity = 0;
	}
}
 
 
//打印
void SeqListPrint(SeqList* ps)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ",ps->a[i]);
	}
 
 
	//printf(" %d", ps->size);
 
 
	printf("\n");
}
 
 
void SLCheckCapacity(SeqList* ps)
{
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//空间不够扩容
		SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * newCapacity);
		if (tmp == NULL)//内存不足可能会失败
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}
 
 
//尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	SLCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}
 
 
 
 
 
 
//头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	SLCheckCapacity(ps);//空间不够就扩容
	//把数据往后挪动
	int end = ps->size - 1;//size是指向最后一个数据的后一个位置
	while (end >= 0)
	{
		ps->a[end+1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}
 
 
//头删
void SeqListPopFront(SeqList* ps)
{
	int i = 0;
	while (i < ps->size)
	{
		ps->a[i] = ps->a[i + 1];
		i++;
	}
	ps->size--;
}
 
 
//尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps->size > 0);
	ps->a[ps->size - 1] = 0;
	ps->size--;
}
 
 
 
 
// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x)
{
	int i = 0;
	while (i < ps->size)
	{
		if (ps->a[i] == x)
		{
			printf("%d的下标是%d\n", x, i);
			return i;
		}
		i++;
	}
	printf("顺序表中没有此项数据。\n");
	return 0;
}
 
 
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)//pos是指一个下标
{
	assert(ps);//检查指针，不能为空
	assert(ps->size >= pos && pos > 0);
	SLCheckCapacity(ps);
 
 
	int end = ps->size - 1;//size是指向最后一个数据的后一个位置
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}
 
 
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);//检查指针，不能为空
	assert(ps->size > pos && pos > 0);
	int i = pos;//size是指向最后一个数据的后一个位置
	while ( isize-1)
	{
		ps->a[i] = ps->a[i+1];
		i++;
	}
	
	ps->size--;
}

1.3有关OJ应用

1.原地删除数组中的所有元素val

2.删除排序数组中的重复项

3.合并两个有序数组

二、链表

2.1链表的概念及结构

概念：是一种物理存储结构上非连续、非顺序的存储结构。数组元素的逻辑顺序是通过链表中的指针链接次序实现的。

2.2链表的分类

①单项不带头链表

typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos);

// 在pos的前面插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLNDataType x);
// 删除pos位置
void SLTErase(SLNode** pphead, SLNode* pos);
void SLTDestroy(SLNode** pphead);

#include"SList.h"




// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}


	newnode->data = x;
	newnode->next = NULL;
	return newnode;


}


// 单链表打印
void SListPrint(SListNode* plist)
{
	//assert(plist);
	SListNode* cur = plist;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}


// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	SListNode* newnode = BuySListNode(x);
	if (*pplist == NULL)
	{
		*pplist = newnode;
		
	}
	else
	{
		SListNode* tail = *pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
	
}


// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	SListNode* newnode = BuySListNode(x);
	newnode->next=*pplist;
	*pplist = newnode;
}


// 单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(*pplist);
	if ((*pplist)->next == NULL)//只有一个数据
	{
		free(*pplist);
		*pplist = NULL;
	}
	else//有多个数据 
	{
		SListNode* tail = *pplist;
	
		while (tail->next->next!= NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
	


}




// 单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(*pplist);
	SListNode* tmp = *pplist;
	*pplist = tmp->next;
	free(tmp);
}




// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	SListNode* cur = plist;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	printf("找不到此数据！\n");
	return NULL;
}




// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}




// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	SListNode* tmp = pos->next->next;
	free(pos->next);
	pos->next = tmp;
}


// 在pos的前面插入
void SLTInsert(SListNode** pphead, SListNode* pos, SLTDateType x)
{
	assert(*pphead);
	if (*pphead == pos)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SListNode* cur = *pphead;
		
		while (cur->next != pos)
		{
			
			cur = cur->next;
		}


		SListNode* newnode = BuySListNode(x);
		newnode->next = pos;
		cur->next = newnode;
	}
	


}


// 删除pos位置
void SLTErase(SListNode** pphead, SListNode* pos)
{
	assert(*pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SListNode* cur = *pphead;


		while (cur->next != pos)
		{


			cur = cur->next;
		}


		
		SListNode* tmp = pos->next;
		free(cur->next);
		cur->next = tmp;
	}
}




void SLTDestroy(SListNode** pphead)//销毁
{
	SListNode* cur = *pphead;
	SListNode* prev = NULL;
	while (cur->next != NULL)
	{
		prev = cur;
		cur = cur->next;
		prev->data = 0;
		free(prev);
	}
}

②双向带头循环链表

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

#include"ListNode.h"






// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->_data = 0;
	newnode->_next = newnode;
	newnode->_prev = newnode;
	return newnode;
}






// 双向链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead;
	ListNode* next = NULL;
	while (1)
	{
		next = cur->_next;
		free(cur);
		cur = next;
		if (cur == pHead)
		{
			break;
		}
	}
}


// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead;
	printf("头节点");
	while (cur->_next!=pHead)
	{
		printf("<=>%d",cur->_next->_data);
		cur = cur->_next;
	}
	printf("\n");
}


// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* cur = pHead->_prev;
	ListNode* newnode = ListCreate();
	newnode->_data = x;
	cur->_next = newnode;
	newnode->_prev = cur;
	newnode->_next = pHead;
	pHead->_prev = newnode;
}


// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	assert(pHead->_prev != pHead);
	ListNode* cur = pHead->_prev;
	pHead->_prev->_prev->_next = pHead;
	pHead->_prev = pHead->_prev->_prev;
	free(cur);
}


// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* newnode = ListCreate();
	newnode->_data = x;
	newnode->_next = pHead->_next;
	newnode->_prev = pHead;
	pHead->_next->_prev = newnode;
	pHead->_next = newnode;
}


// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->_next;
	pHead->_next->_next->_prev = pHead;
	pHead->_next = pHead->_next->_next;
	free(cur);
}


// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		if (cur->_data == x)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}


// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* cur = pos->_prev;
	ListNode* newnode = ListCreate();
	newnode->_data = x;
	cur->_next = newnode;
	newnode->_prev = cur;
	newnode->_next = pos;
	pos->_prev = newnode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
	pos->_prev->_next = pos->_next;
	pos->_next->_prev = pos->_prev;
	free(pos);
	pos = NULL;
}