1. 链表的结构
链表是一种物理存储结构上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表
中的指针链接次序实现的。
结点的data域存放数据元素ai,而next域是一个指针,指向ai的直接后继ai+1所在的结点。
1.1链表的分类
实际中要实现的链表的结构非常多样,以下情况组合起来就有8种链表结构:
- 单向
- 双向
- 不带头
- 带头
- 循环
- 非循环
实际中常用的两种结构
- 无头单向循环链表
无头单向循环链表结构简单,一般不会单独存储数据,更多的是作为其他数据结构的子结构。
- 带头双向循环链表
带头双向循环链表最为复杂,可以单独存储数据,是实际使用中链表结构。虽然结构复杂,但是使用方便。
2. 无头单向循环链表的实现
2.0无头单向循环链表的表示
typedef int SLTDateType;
typedef struct SListNode
{
SLTDateType data;
struct SListNode* next;
}SListNode;
2.1 动态申请一个节点
// 动态申请一个节点
SListNode* BuySListNode(SLTDataType x)
{
SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
if (newnode == NULL)
{
printf("malloc fail\n");
exit(-1);
}
else
{
newnode->data = x;
newnode->next = NULL;
}
return newnode;
}
2.2 单链表打印
// 单链表打印
void SListPrint(SListNode* phead)
{
SListNode* cur = phead;
while (cur != NULL)
{
printf("%d->", cur->data);
cur = cur->next;
}
printf("NULL\n");
}
2.3 单链表尾插
// 单链表尾插
void SListPushBack(SListNode** pphead, SLTDataType x)
{
assert(pphead);
SListNode* newnode = BuySListNode(x);
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
// 找尾
SListNode* tail = *pphead;
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newnode;
// 错误写法,这里没有链接起来
/*SListNode* tail = *pphead;
while (tail != NULL)
{
tail = tail->next;
}
tail = newnode;*/
}
}
2.4 单链表的头插
// 单链表的头插
void SListPushFront(SListNode** pphead, SLTDataType x)
{
assert(pphead);
SListNode* newnode = BuySListNode(x);
newnode->next = *pphead;
*pphead = newnode;
}
2.5 单链表的尾删
// 单链表的尾删
void SListPopBack(SListNode** pphead)
{
assert(pphead);
// 也可以暴力检查为空的情况
//assert(*pphead != NULL);
// 1、空
// 2、一个节点
// 3、多个节点
if (*pphead == NULL) // 温柔检查
{
return;
}
else if ((*pphead)->next == NULL)
{
free(*pphead);
*pphead = NULL;
}
else
{
/*SListNode* prev = NULL;
SListNode* tail = *pphead;
while (tail->next != NULL)
{
prev = tail;
tail = tail->next;
}
free(tail);
tail = NULL;
prev->next = NULL;*/
SListNode* tail = *pphead;
while (tail->next->next != NULL)
{
tail = tail->next;
}
free(tail->next);
tail->next = NULL;
}
}
2.6 单链表头删
// 单链表头删
void SListPopFront(SListNode** pphead)
{
assert(pphead);
// 1、空
// 2、非空
if (*pphead == NULL)
{
return;
}
else
{
SListNode* next = (*pphead)->next;
free(*pphead);
*pphead = next;
}
}
2.7 单链表查找
// 单链表查找
SListNode* SListFind(SListNode* phead, SLTDataType x)
{
SListNode* cur = phead;
while (cur != NULL)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
2.8 单链表在pos位置之前插入x
// 单链表在pos位置之前插入x
void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x)
{
assert(pphead);
assert(pos);
// 1、pos是第一个节点
// 2、pos不是第一个节点
if (pos == *pphead)
{
SListPushFront(pphead, x);
}
else
{
SListNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
SListNode* newnode = BuySListNode(x);
prev->next = newnode;
newnode->next = pos;
}
}
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDataType x)
{
assert(pos);
//SListNode* next = pos->next;
//SListNode* newnode = BuySListNode(x);
//pos->next = newnode;
//newnode->next = next;
SListNode* newnode = BuySListNode(x);
newnode->next = pos->next;
pos->next = newnode;
}
2.9 单链表删除pos位置的值
// 单链表删除pos位置的值
void SListErase(SListNode** pphead, SListNode* pos)
{
assert(pphead);
assert(pos);
if (*pphead == pos)
{
SListPopFront(pphead);
}
else
{
SListNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
prev->next = pos->next;
free(pos);
pos = NULL;
}
}
// 单链表删除pos位置后的值
void SListEraseAfter(SListNode* pos)
{
assert(pos);
SListNode* next = pos->next;
if (next)
{
pos->next = next->next;
free(next);
next = NULL;
}
}
2.10销毁链表
void SListDestroy(SListNode** pphead)
{
assert(pphead);
SListNode* cur = *pphead;
while (cur)
{
SListNode* next = cur->next;
free(cur);
cur = next;
}
*pphead = NULL;
}
3. 带头双向循环链表的实现
3.0 带头双向循环链表的表示
typedef int LTDataType;
typedef struct ListNode
{
LTDataType data;
struct ListNode* next;
struct ListNode* prev;
}LTNode;
3.1双向链表初始化
//链表初始化
LTNode* ListInit()
{
LTNode* phead = BuyLTNode(0);
phead->next = phead;
phead->prev = phead;
return phead;
}
3.1创建新结点
// 创建返回链表的头结点.
LTNode* BuyLTNode(LTDataType x)
{
LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
if (newnode == NULL)
{
printf("malloc fail\n");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
newnode->prev = NULL;
return newnode;
}
3.2双向链表销毁
// 双向链表销毁
void ListDestory(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
LTNode* next = cur->next;
//ListErase(cur);
free(cur);
cur = next;
}
free(phead);
//phead = NULL;
}
3.3双向链表打印
// 双向链表打印
void ListPrint(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
printf("%d ", cur->data);
cur = cur->next;
}
printf("\n\n");
}
3.4双向链表尾插
// 双向链表尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
assert(phead);
//LTNode* tail = phead->prev;
//LTNode* newnode = BuyLTNode(x);
//tail->next = newnode;
//newnode->prev = tail;
//newnode->next = phead;
//phead->prev = newnode;
ListInsert(phead, x);
}
3.5双向链表尾删
// 双向链表尾删
void ListPopBack(LTNode* phead)
{
assert(phead);
// 链表为空
assert(phead->next != phead);
/* LTNode* tail = phead->prev;
LTNode* tailPrev = tail->prev;
free(tail);
tail = NULL;
tailPrev->next = phead;
phead->prev = tailPrev;*/
ListErase(phead->prev);
}
3.6 双向链表头插
// 双向链表头插
void ListPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
ListInsert(phead->next, x);
}
3.7 双向链表头删
// 双向链表头删
void ListPopFront(LTNode* phead)
{
assert(phead);
assert(phead->next != phead);
ListErase(phead->next);
}
3.8双向链表查找
// 双向链表查找
LTNode* ListFind(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
3.9双向链表在pos的前面进行插入
// 双向链表在pos的前面进行插入
void ListInsert(LTNode* pos, LTDataType x)
{
assert(pos);
/*LTNode* newnode = BuyLTNode(x);
pos->prev->next = newnode;
newnode->prev = pos->prev;
pos->prev = newnode;
newnode->next = pos;*/
LTNode* newnode = BuyLTNode(x);
LTNode* posPrev = pos->prev;
newnode->next = pos;
pos->prev = newnode;
posPrev->next = newnode;
newnode->prev = posPrev;
}
3.10双向链表删除pos位置的节点
// 双向链表删除pos位置的节点
void ListErase(LTNode* pos)
{
assert(pos);
LTNode* prev = pos->prev;
LTNode* next = pos->next;
free(pos);
pos = NULL;
prev->next = next;
next->prev = prev;
}
4.顺序表和链表的优缺点
4.1顺序表
优点:
空间利用率高、支持随机访问。
缺点:
- 中间或前面部分的插入删除时间复杂度O(N),要移动大量元素。
- 增容的代价比较大,需要连续内存空间,难以扩展。
4.2链表
优点:
- 任意位置插入删除时间复杂度为O(1)。
- 没有增容消耗,按需申请节点空间,内存利用灵活,不用了直接释放。
缺点:
以节点为单位存储,不支持随机访问。