前言
- 以顺序结构存储数据时,插入和删除时要移动大量元素,耗费时间。
- 链式存储结构是用一组任意的存储单元来存储数据元素,这组存储单元可连续,可不连续,可存于内存中未被占用的任意位置:
-
- 链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
- 链表相对数组的优势在于,它提供了搞笑的重拍数据的能力。代价是不能快速访问表中的任意数据项,而只能沿着链表,一个一个节点地访问,直到找到这个数据项。
- 为了便于对链表进行操作,会在链表的第一个节点前再附设一个节点,称为头结点,不用来存储有意义数据(存0),尾节点同理。
1 单链表
1.1 单链表的定义:复习
//单链表的定义
//声明单链表节点的结构体
typedef struct node{
int data;//节点数据
struct node *next;//保存下一个节点的首地址
}node_t;
//声明描述整个单链表的结构体
typedef struct list{
struct node *head;//保存头节点的地址 //单链表这里用的变量,也可用指针
struct node *tail;//保存尾节点的地址
}list_t;
1.2 单链表的操作:复习
- 链表的初始化
- 链表的释放
- 链表的遍历
- 链表中顺序插入数据
- 链表中前端插入数据
- 链表中尾段插入数据
- 链表中删除节点
1.3 单链表头文件 list.h
//list.h 单链表的头文件
#ifndef __LIST_H_
#define __LIST_H_
//定义节点
typedef struct node{
int data;//数据
struct node* next;//记录下一个节点的地址
}node_t;
//定义链表
typedef struct list{
struct node* head;//记录链表头节点的地址
struct node* tail;//记录链表尾节点的地址
}list_t;
// list_t list;
//链表的操作
//链表的初始化
void list_init(list_t* l);
//链表的释放
void list_deinit(list_t* l);
//向链表中头部插入数据
void list_add_first(list_t* l,int data);
//向链表中尾部插入数据
void list_add_last(list_t* l,int data);
//按顺序插入节点
void list_add(list_t* l,int data);
//链表的遍历
void list_travel(list_t* l);
//删除指定节点
void list_del(list_t* l,int data);
#endif //__LIST_H_
1.4 单链表的实现 list.c
//list.c 单链表的实现
#include"list.h"
#include<stdio.h>
#include<stdlib.h>
//链表的初始化
//list_t list;
//list_init(&list);
void list_init(list_t* l){
//分配头节点,将地址存入head指针
l->head = malloc(sizeof(node_t));
//分配尾节点,将地址存入tail指针
l->tail = malloc(sizeof(node_t));
//头尾节点,存0
l->head->data = 0;
l->tail->data = 0;
//头节点中next指针指向尾节点
// 头节点中的next指针 = 尾节点的地址
l->head->next = l->tail;
//尾节点中next指针指向NULL
l->tail->next = NULL;
}
//链表的释放
void list_deinit(list_t* l){
//将头结点的地址,赋值给pnode指针,pnode指谁,谁释放
node_t* pnode = l->head;
while(pnode != NULL){//当pnode值为NULL,也就是指向了尾节点之后,循环结束
//将下一个节点的地址,存入tmp里
node_t* tmp = pnode->next;
//释放前节点
free(pnode);
//pnode指向下一个节点
pnode = tmp;
}
}
//向链表中头部插入数据
void list_add_first(list_t* l,int data){
//创建新节点
node_t* new = malloc(sizeof(node_t));
new->data = data;
new->next = NULL;
//将新节点插入到链表头部(头节点和第一个有效节点之间)
//将第一个有效节点的地址存入tmp
node_t* tmp = l->head->next;
//将新节点的地址赋值给next指针
l->head->next = new;
//将第一个节点的地址赋值给新节点的next指针
new->next = tmp;
}
//向链表中尾部插入数据
void list_add_last(list_t* l,int data){
//分配新节点
node_t* new = malloc(sizeof(node_t));
new->data = data;
new->next = NULL;
//找位置,并将新节点插入
for(node_t* p = l->head;p != l->tail;p = p->next){
// first mid last 找位置
node_t* first = p;
node_t* mid = first->next;
node_t* last = mid->next;
//当mid指向尾节点时,first指针指向就是最后一个有效节点
//新节点应该插入在mid和first之间
if(mid == l->tail){
//将新节点的地址赋值给最后一个有效节点的next指针
first->next = new;
//将尾节点的地址赋值给新节点的next指针
new->next = mid;
break;
}
}
}
//顺序插入节点
void list_add(list_t* l,int data){
//创建新节点
node_t* new = malloc(sizeof(node_t));
new->data = data;
new->next = NULL;
//找位置,并插入
for(node_t* p = l->head;p != l->tail;p = p->next){
//找位置
node_t* first = p;
node_t* mid = first->next;
node_t* last = mid->next;
//当mid指向的节点,第一次比新节点大
//新节点应该插入在first 和 mid之间
//如果mid指向尾节点,说明新节点最大,插入尾节点之前
if(mid->data > new->data || mid == l->tail){
//将新节点的地址出入first指向的节点的next指针
first->next = new;
//将mid指针指向的节点的地址存入新节点的next指针
new->next = mid;
break;
}
}
}
//链表的遍历
void list_travel(list_t* l){
//循环输出每个节点的数据
for(node_t* p = l->head;p != l->tail;p = p->next){
node_t* first = p;
node_t* mid = first->next;
node_t* last = mid->next;
if(mid != l->tail){
printf("%d ",mid->data);
}
}
printf("\n");
}
//删除指定节点
void list_del(list_t* l,int data){
//找要删除的节点
for(node_t* p = l->head;p != l->tail;p = p->next){
node_t* first = p;
node_t* mid = first->next;
node_t* last = mid->next;
//当mid指向的节点的值 和 data相等,则删除
if(mid->data == data && mid != l->tail){
//将last指向节点的地址赋值给first指向节点的next指针
first->next = last;
//释放节点
free(mid);
break;
}
}
}
1.5 单链表测试 main.c
//main.c 单链表测试
#include"list.h"
int main(void){
//定义链表
list_t l;
//初始化
list_init(&l);
//顺序插入 30 40 50
list_add(&l,30);
list_add(&l,40);
list_add(&l,50);
//遍历链表
list_travel(&l);
//头部插入 20
list_add_first(&l,20);
//尾部插入 60
list_add_last(&l,60);
//遍历链表
list_travel(&l);
//删除节点
list_del(&l,40);
//遍历链表
list_travel(&l);
//顺序插入
list_add(&l,40);
//遍历链表
list_travel(&l);
//释放
list_deinit(&l);
return 0;
}
2. 双链表
2.1 双链表的定义:复习
//双链表的定义
//声明描述双链表节点的结构体
typedef struct node{
int data;//数据
struct node *next;//保存下一个节点的首地址
struct node *prev;//保存上一个节点的首地址
}node_t;
//声明描述整个双链表的结构体
typedef struct list{
struct node head;//头节点 //双链表这里用的变量,也可用指针
struct node tail;//尾节点
}list_t;
2.2 双链表的操作:复习
-
双链表的初始化
-
双链表的释放
-
双链表判空
-
获取双链表有效节点个数
-
双链表中顺序插入数据
-
双链表中前端插入数据
-
双链表中尾段插入数据
-
双链表中删除指定节点
-
双链表中删除第一个节点
-
双链表中删除最后一个节点
-
根据节点编号获取节点数据
2.3 双链表头文件 list.h
//list.h 双链表头文件
#ifndef __LIST_H__
#define __LIST_H__
#include<stdio.h>
#include<stdlib.h>
//定义节点
typedef struct node{
int data;//数据
struct node* next;//记录后一个节点地址
struct node* prev;//记录前一个节点地址
}node_t;
//定义链表
typedef struct list{
struct node head;//头结点
struct node tail;//尾节点
}list_t;
//链表的操作
//链表的初始化
void list_init(list_t* l);
//链表的释放
void list_deinit(list_t* l);
//链表判空
int list_empty(list_t* l);
//头部插入节点
void list_add_head(list_t* l,int data);
//尾部插入节点
void list_add_tail(list_t* l,int data);
//顺序插入节点
void list_add(list_t* l,int data);
//删除节点
void list_del(list_t* l,int data);
//遍历链表
void list_travel(list_t* l);
#endif //__LIST_H__
2.4 双链表的实现 list.c
//list.c 双链表的实现
#include"list.h"
//链表的初始化
// list_t list; // list.head list.tail
// list_init(&list);
void list_init(list_t* l){
//头结点里的数据赋值为0;
l->head.data = 0;
//尾节点里的数据赋值为0;
l->tail.data = 0;
//将尾节点的地址给头结点的next指针
l->head.next = &l->tail;
//将头结点的地址给尾节点的prev指针
l->tail.prev = &l->head;
//头节点的prev指针赋值未NULL
l->head.prev = NULL;
//尾节点的next指针赋值为NULL
l->tail.next = NULL;
}
//释放链表
void list_deinit(list_t* l){
while(l->head.next != &l->tail){
node_t* first = &l->head;//first永远记录头节点地址
node_t* mid = first->next;
node_t* last = mid->next;
//释放mid指向的节点
//让first和last指向的两个节点相连
first->next = last;
last->prev = first;
//释放mid
free(mid);
}
}
//链表判空
int list_empty(list_t* l){
//如果头结点后,是尾节点,则空
if(l->head.next == &l->tail){
return 1;
}else{
return 0;
}
}
//头部插入节点
void list_add_head(list_t* l,int data){
//创建新节点
node_t* new = malloc(sizeof(node_t));
new->prev = NULL;
new->next = NULL;
new->data = data;
//first指向头结点,mid指向first之后,last指向mid之后
node_t* first = &l->head;
node_t* mid = first->next;
node_t* last = mid->next;
//头节点的next指针,指向新节点
first->next = new;
//新节点的next指针,指向第一个有效节点
new->next = mid;
//第一个有效节点的prev值指针,指向新节点
mid->prev = new;
//新节点的prev指针,指向头节点
new->prev = first;
}
//尾部插入节点
void list_add_tail(list_t* l,int data){
//创建新节点
node_t* new = malloc(sizeof(node_t));
new->prev = NULL;
new->next = NULL;
new->data = data;
//first指向尾节点
node_t* first = &l->tail;
//mid指向最后有效节点
node_t* mid = first->prev;
//让最后节点的后指针,指向新节点
mid->next = new;
//新节点的后指针指向尾节点
new->next = first;
//尾节点的前指针,指向新节点
first->prev = new;
//新节点的前指针指向最后有效节点
new->prev = mid;
}
//顺序插入节点
void list_add(list_t* l,int data){
//创建新节点
node_t* new = malloc(sizeof(node_t));
new->prev = NULL;
new->next = NULL;
new->data = data;
//找位置,插入新节点
for(node_t* p = &l->head;p != &l->tail;p = p->next){
node_t* first = p;
node_t* mid = first->next;
node_t* last = mid->next;
//mid指向的节点的数据第一次大于新节点的数据
//则新节点应该插入在first和mid之间
//如果mid指向尾节点,说明新节点的值最大
if(mid->data > new->data || mid == &l->tail){
//first指向节点的后指针,指向新节点
first->next = new;
//新节点的后指针 指向mid指向的节点
new->next = mid;
//mid指向的节点的前指针,指向新节点
mid->prev = new;
//新节点的前指针,指向first指向的节点
new->prev = first;
break;
}
}
}
//删除节点
void list_del(list_t* l,int data){
for(node_t* p = &l->head;p != &l->tail;p = p->next){
node_t* first = p;
node_t* mid = first->next;
node_t* last = mid->next;
//当mid指向要删除的节点,
//将first和last指向的节点相连
if(mid->data == data && mid != &l->tail){
//fish指向的节点的后指针,指向last指向的节点
first->next = last;
//last指向的节点的前指针,指向first指向的节点
last->prev = first;
//释放
free(mid);
break;
}
}
}
//遍历链表
void list_travel(list_t* l){
for(node_t* p = &l->head;p != &l->tail;p = p->next){
node_t* first = p;
node_t* mid = first->next;
node_t* last = mid->next;
if(mid != &l->tail){
printf("%d ",mid->data);
}
}
printf("\n");
}
2.5 双链表测试 main.c
//main.c 双链表测试
#include"list.h"
int main(void){
//定义链表
list_t list;
//初始化操作
list_init(&list);
//头部插入节点
list_add_head(&list,20);
list_add_head(&list,10);
list_travel(&list);
//尾部插入节点
list_add_tail(&list,60);
list_add_tail(&list,70);
list_travel(&list);
//顺序插入节点
list_add(&list,25);
list_add(&list,77);
list_add(&list,48);
list_add(&list,39);
list_add(&list,56);
list_travel(&list);
//删除节点
list_del(&list,77);
list_del(&list,39);
list_travel(&list);
//释放
list_deinit(&list);
list_travel(&list);
return 0;
}