本文是双链表的C语言实现方法,包括双链表的创建、插入、删除、修改、查找等基本操作。
双链表是链表中的一种,他和单链表一样都是通过指针将一个个结点连接起来。他和单链表不同的地方在于:单链表的每个结点的指向只有一个,双向链表每个结点有两个指向。
双向链表结点结构体
双向链表每个结点除了存储数据data外,还有两个指针记录上一个结点和下一个结点的地址,分别是前驱指针prev和后继指针next,所以双向链表结点定义如下:
//双向链表结点结构体
typedef struct Node
{
int data; //数据
struct Node* prev; //前驱指针
struct Node* next; //后继指针
}Node;
双向链表的结构体
- 在单链表中,由于每个结点只指向下一个节点,所以我们只能通过头结点遍历链表。但是双向链表的每个结点既有指向下一个结点的指针,也有指向上一个结点的指针,所以我们要遍历双向链表可以通过其头结点,也可以通过其尾结点。
- 当我们要找的结点靠近头结点的时候,我们可以从头结点开始遍历;当我们要找的结点靠近尾结点的时候,我们可以从尾结点开始遍历。从而提高执行效率。
- 要知道我们要找的结点到底是靠近头结点还是尾结点,那我们也需要知道链表的长度。
- 所以,双向链表的结构体中需要定义头结点,尾结点以及链表长度。
//双向链表结构体
typedef struct DoubleList
{
Node* head; //头结点
Node* tail; //尾结点
size_t size; //链表长度
}DoubleList;
创建双向链表结点
和创建单链表结点类似。
//创建双向链表结点
Node* create_node(int data)
{
Node* node = (Node*)malloc(sizeof(Node));//申请内存
node->data = data;
node->prev = NULL;
node->next = NULL;
return node;
}
初始化双向链表
上面我们定义了双向链表的结构体,但是仅仅是声明了双向链表结构体中的元素,并没有对元素进行初始化,所以我们使用双向链表之前需要对其进行初始化,让头结点和尾结点等于NULL,链表长度等于0。
void init_list(DoubleList* list)
{
list->head = NULL;
list->tail = NULL;
list->size = 0;
}
释放链表
当链表不需要再使用时,我们需要将其内存释放。
void free_list(DoubleList* list)
{
while(list->size)
{
Node* tmp = list->head;
list->head = list->head->next;
free(tmp);
tmp = NULL;
list->size--;
}
}
获取头结点
//获取头结点
Node* get_head(DoubleList* list)
{
return list->head;
}
获取尾结点
//获取尾结点
Node* get_tail(DoubleList* list)
{
return list->tail;
}
获取链表长度
//获取链表长度
size_t get_size(DoubleList* list)
{
return list->size;
}
遍历链表
遍历链表打印链表中所有的元素
void show_list(DoubleList* list)
{
Node* node = list->head;
for (int i = 0; i < list->size; ++i)
{
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}
插入头结点
需要考虑两种情况:
- 链表为空,那插入的结点既是头结点,也是尾结点;
- 链表不为空,将新结点和链表通过前驱指针prev和后继指针next连接起来,并将头结点改为新插入的结点;
//插入头结点
void push_head(DoubleList* list, int data)
{
Node* new_node = create_node(data);
//链表为空
if(list->size == 0)
{
//插入的结点既是头结点,也是尾结点
list->head = new_node;
list->tail = new_node;
}
//链表不为空
else
{
//将新结点和链表通过前驱指针prev和后继指针next连接起来
new_node->next = list->head;
list->head->prev = new_node;
//将头结点改为新插入的结点
list->head = new_node;
}
list->size++;
}
插入尾结点
和插入头结点一样,需要考虑两种情况:
- 链表为空,那插入的结点既是尾结点,也是头结点;
- 链表不为空,将新结点和链表通过前驱指针prev和后继指针next连接起来,并将尾结点改为新插入的结点;
//插入尾结点
void push_tail(DoubleList* list, int data)
{
Node* new_node = create_node(data);
//链表为空
if(list->size == 0)
{
//插入的结点既是尾结点,也是头结点
list->tail = new_node;
list->head = new_node;
}
//链表不为空
else
{
//将新结点和链表通过前驱指针prev和后继指针next连接起来
list->tail->next = new_node;
new_node->prev = list->tail;
//将尾结点改为新插入的结点
list->tail = new_node;
}
list->size++;
}
在任意位置插入一个结点
- 插入前判断插入的位置是否超出链表的范围,排除插入的位置小于0以及大于链表的长度;
- 插入的位置如果等于0,等同于插入头结点;
- 插入的位置如果等于链表的长度,等同于插入尾结点;
- 插入的位置如果小于等于中间位置,那插入的位置更靠近头结点,我们可以从头结点开始往后遍历到插入的前一个位置;
- 插入的位置如果大于中间位置,那插入的位置更靠近尾结点,我们可以从尾结点开始往前遍历到插入的前一个位置;
//任意位置插入一个结点
//任意位置插入一个结点
bool insert_node(DoubleList* list, int index, int data)
{
//插入的位置超出链表的范围
if(index <0 || index > list->size)
return false;
//插入的位置如果等于0,等同于插入头结点
if(index == 0)
{
push_head(list,data);
return true;
}
//插入的位置如果等于链表的长度,等同于插入尾结点
else if(index == list->size)
{
push_tail(list,data);
return true;
}
Node* tmp = NULL;
//插入的位置如果小于等于中间位置,那插入的位置更靠近头结点
//从头结点开始往后遍历到插入的前一个位置
if(index <= list->size / 2)
{
tmp = list->head;
for(int i=0; i<index-1;i++)
{
tmp = tmp->next;
}
}
//插入的位置如果大于中间位置,那插入的位置更靠近尾结点
//从尾结点开始往前遍历到插入的前一个位置
else
{
tmp = list->tail;
for (int i = 0; i < list->size - index; ++i)
{
tmp = tmp->prev;
}
}
Node* new_node = create_node(data);
tmp->next->prev = new_node;
new_node->next = tmp->next;
tmp->next = new_node;
new_node->prev = tmp;
list->size++;
return true;
}
删除头结点
需要考虑三种情况:
- 链表为空,不操作,直接返回;
- 链表只有一个结点,释放该结点的内存,并初始化链表,将链表长度改为0,头结点和尾结点置为NULL;
- 链表结点大于1,保存头结点,新头结点等于原头结点的下一个结点,然后释放保存的头结点的内存;
//删除头结点
void del_head(DoubleList* list)
{
if(list->size == 0)
return;
if(list->size == 1)
{
free(list->head);//释放内存
init_list(list);
return;
}
Node* tmp = list->head;//保存头结点
list->head = tmp->next;
list->head->prev = NULL;
//释放内存
free(tmp);
tmp = NULL;
list->size--;
}
删除尾结点
和删除头结点类似
- 链表为空,不操作,直接返回;
- 链表只有一个结点,释放该结点的内存,并初始化链表,将链表长度改为0,头结点和尾结点置为NULL;
- 链表结点大于1,保存尾结点,新尾结点等于原尾结点的上一个结点,然后释放保存的尾结点的内存;
//删除尾结点
void del_tail(DoubleList* list)
{
if(list->size == 0)
return;
if(list->size == 1)
{
free(list->tail);//释放内存
init_list(list);
return;
}
Node* tmp = list->tail;//保存尾结点
list->tail = tmp->prev;
list->tail->next = NULL;
free(tmp);//释放内存
tmp = NULL;
list->size--;
}
删除任意位置结点
与在任意位置插入结点类似,
- 删除前判断插入的位置是否超出链表的范围,排除删除的位置小于0以及大于链表的长度;
- 删除的位置如果等于0,等同于删除头结点;
- 删除的位置如果等于链表的长度,等同于删除尾结点;
- 删除的位置如果小于中间位置,那删除的位置更靠近头结点,我们可以从头结点开始往后遍历到删除的结点;
- 删除的位置如果大于等于中间位置,那删除的位置更靠近尾结点,我们可以从尾结点开始往前遍历到删除的结点;
//删除任意位置结点
bool del_node(DoubleList* list, int index)
{
//判断插入的位置是否超出链表的范围
if(index < 0 || index > list->size)
return false;
//删除的位置如果等于0,等同于删除头结点
if(index == 0)
{
del_head(list);
return true;
}
//删除的位置如果等于链表的长度,等同于删除尾结点
if(index == list->size)
{
del_tail(list);
return true;
}
Node* tmp = NULL;
//删除的位置如果小于中间位置
if(index < list->size/2)
{
//从头结点开始往后遍历到删除的的结点
tmp = list->head;
for (int i = 0; i < index; ++i)
{
tmp = tmp->next;
}
}
//删除的位置如果大于等于中间位置
else
{
//从尾结点开始往前遍历到删除的结点
tmp = list->tail;
for (int i = 0; i < list->size - index - 1; ++i)
{
tmp = tmp->prev;
}
}
tmp->prev->next = tmp->next;
tmp->next->prev = tmp->prev;
free(tmp);//释放内存
tmp = NULL;
list->size--;
return true;
}
获取任意节点位置
- 遍历前判断插入的位置是否超出链表的范围,排除删除的位置小于0以及大于链表的长度;
- 目标结点的位置如果小于中间位置,那目标结点的位置更靠近头结点,我们可以从头结点开始往后遍历到目标结点;
- 目标结点的位置如果大于等于中间位置,那目标结点的位置更靠近尾结点,我们可以从尾结点开始往前遍历到目标结点;
//获取任意位置结点
Node* get_node(DoubleList* list, int index)
{
//判断插入的位置是否超出链表的范围
if(index < 0 || index > list->size)
return NULL;
Node* node = NULL;
//目标结点的位置如果小于中间位置
if(index < list->size / 2)
{
//从头结点开始往后遍历到目标结点
node = list->head;
for(int i =0; i < index ; i++)
{
node = node->next;
}
}
//目标结点的位置如果大于等于中间位置
else
{
//从尾结点开始往前遍历到目标结点
node = list->tail;
for (int i = 0; i < list->size - index - 1; ++i)
{
node = node->prev;
}
}
return node;
}
获取链表中指定数据所在的第一个结点
Node* find_data(DoubleList* list, int data)
{
if(list->size == 0)
return NULL;
Node* node = list->head;
while(node)
{
if(node->data == data)
return node;
node = node->next;
}
return NULL;
}
修改链表中指定结点的值
先获取到目标位置的结点,再修改目标结点的值
bool modify_node(DoubleList* list, int index, int data)
{
Node* node = get_node(list, index);
if(node)
{
node->data = data;
return true;
}
return false;
}
修改链表中指定的第一个数据
先获取目标数据所在的第一个结点,再修改改结点的值
bool modify_data(DoubleList* list, int data, int val)
{
Node* node = find_data(list, data);
if(node)
{
node->data = val;
return true;
}
return false;
}
完整代码
双向链表测试代码请前往:https://github.com/HongKnight/linked-list/tree/master/double_list
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <stdbool.h>
//创建双向链表结点
Node* create_node(int data)
{
Node* node = (Node*)malloc(sizeof(Node));//申请内存
node->data = data;
node->prev = NULL;
node->next = NULL;
return node;
}
//初始化链表
void init_list(DoubleList* list)
{
list->head = NULL;
list->tail = NULL;
list->size = 0;
}
//释放链表
void free_list(DoubleList* list)
{
while(list->size)
{
Node* tmp = list->head;
list->head = list->head->next;
free(tmp);
tmp = NULL;
list->size--;
}
}
//获取链表长度
size_t get_size(DoubleList* list)
{
return list->size;
}
//获取头结点
Node* get_head(DoubleList* list)
{
return list->head;
}
//获取尾结点
Node* get_tail(DoubleList* list)
{
return list->tail;
}
//遍历链表
void show_list(DoubleList* list)
{
Node* node = list->head;
for (int i = 0; i < list->size; ++i)
{
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}
//插入一个头结点
void push_head(DoubleList* list, int data)
{
Node* new_node = create_node(data);
//链表为空
if(list->size == 0)
{
//插入的结点既是头结点,也是尾结点
list->head = new_node;
list->tail = new_node;
}
//链表不为空
else
{
//将新结点和链表通过前驱指针prev和后继指针next连接起来
new_node->next = list->head;
list->head->prev = new_node;
//将头结点改为新插入的结点
list->head = new_node;
}
list->size++;
}
//插入一个尾结点
void push_tail(DoubleList* list, int data)
{
Node* new_node = create_node(data);
//链表为空
if(list->size == 0)
{
//插入的结点既是尾结点,也是头结点
list->tail = new_node;
list->head = new_node;
}
//链表不为空
else
{
//将新结点和链表通过前驱指针prev和后继指针next连接起来
list->tail->next = new_node;
new_node->prev = list->tail;
//将尾结点改为新插入的结点
list->tail = new_node;
}
list->size++;
}
//任意位置插入结点
bool insert_node(DoubleList* list, int index, int data)
{
//插入的位置超出链表的范围
if(index <0 || index > list->size)
return false;
//插入的位置如果等于0,等同于插入头结点
if(index == 0)
{
push_head(list,data);
return true;
}
//插入的位置如果等于链表的长度,等同于插入尾结点
else if(index == list->size)
{
push_tail(list,data);
return true;
}
Node* tmp = NULL;
//插入的位置如果小于等于中间位置,那插入的位置更靠近头结点
if(index <= list->size / 2)
{
//从头结点开始往后遍历到插入的前一个位置
tmp = list->head;
for(int i=0; i<index-1;i++)
{
tmp = tmp->next;
}
}
//插入的位置如果大于中间位置,那插入的位置更靠近尾结点
else
{
//从尾结点开始往前遍历到插入的前一个位置
tmp = list->tail;
for (int i = 0; i < list->size - index; ++i)
{
tmp = tmp->prev;
}
}
Node* new_node = create_node(data);
tmp->next->prev = new_node;
new_node->next = tmp->next;
tmp->next = new_node;
new_node->prev = tmp;
list->size++;
return true;
}
//删除头结点
void del_head(DoubleList* list)
{
if(list->size == 0)
return;
if(list->size == 1)
{
free(list->head);//释放内存
init_list(list);
return;
}
Node* tmp = list->head;//保存头结点
list->head = tmp->next;
list->head->prev = NULL;
free(tmp);//释放内存
tmp = NULL;
list->size--;
}
//删除尾结点
void del_tail(DoubleList* list)
{
if(list->size == 0)
return;
if(list->size == 1)
{
free(list->tail);//释放内存
init_list(list);
return;
}
Node* tmp = list->tail;//保存尾结点
list->tail = tmp->prev;
list->tail->next = NULL;
free(tmp);//释放内存
tmp = NULL;
list->size--;
}
//删除任意位置结点
bool del_node(DoubleList* list, int index)
{
//判断插入的位置是否超出链表的范围
if(index < 0 || index > list->size)
return false;
//删除的位置如果等于0,等同于删除头结点
if(index == 0)
{
del_head(list);
return true;
}
//删除的位置如果等于链表的长度,等同于删除尾结点
if(index == list->size)
{
del_tail(list);
return true;
}
Node* tmp = NULL;
//删除的位置如果小于中间位置
if(index < list->size/2)
{
//从头结点开始往后遍历到删除的的结点
tmp = list->head;
for (int i = 0; i < index; ++i)
{
tmp = tmp->next;
}
}
//删除的位置如果大于等于中间位置
else
{
//从尾结点开始往前遍历到删除的结点
tmp = list->tail;
for (int i = 0; i < list->size - index - 1; ++i)
{
tmp = tmp->prev;
}
}
tmp->prev->next = tmp->next;
tmp->next->prev = tmp->prev;
free(tmp);//释放内存
tmp = NULL;
list->size--;
return true;
}
//获取任意位置结点
Node* get_node(DoubleList* list, int index)
{
//判断插入的位置是否超出链表的范围
if(index < 0 || index > list->size)
return NULL;
Node* node = NULL;
//目标结点的位置如果小于中间位置
if(index < list->size / 2)
{
//从头结点开始往后遍历到目标结点
node = list->head;
for(int i =0; i < index ; i++)
{
node = node->next;
}
}
//目标结点的位置如果大于等于中间位置
else
{
//从尾结点开始往前遍历到目标结点
node = list->tail;
for (int i = 0; i < list->size - index - 1; ++i)
{
node = node->prev;
}
}
return node;
}
//获取链表中指定数据所在的第一个结点
Node* find_data(DoubleList* list, int data)
{
if(list->size == 0)
return NULL;
Node* node = list->head;
while(node)
{
if(node->data == data)
return node;
node = node->next;
}
return NULL;
}
//修改链表中指定结点的值
bool modify_node(DoubleList* list, int index, int data)
{
Node* node = get_node(list,index);
if(node)
{
node->data = data;
return true;
}
return false;
}
//修改链表中指定的第一个数据
bool modify_data(DoubleList* list, int data, int val)
{
Node* node = find_data(list,data);
if(node)
{
node->data = val;
return true;
}
return false;
}
更多链表相关代码请前往:https://github.com/HongKnight/linked-list