ds_03_list

wwwwood

已于 2023-10-21 17:50:44 修改

阅读量45

点赞数

分类专栏： ds 文章标签：数据结构

于 2023-10-10 09:27:14 首次发布

本文链接：https://blog.csdn.net/qq_33331020/article/details/133738008

版权

ds 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

前言

以顺序结构存储数据时，插入和删除时要移动大量元素，耗费时间。
链式存储结构是用一组任意的存储单元来存储数据元素，这组存储单元可连续，可不连续，可存于内存中未被占用的任意位置：
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
链表相对数组的优势在于，它提供了搞笑的重拍数据的能力。代价是不能快速访问表中的任意数据项，而只能沿着链表，一个一个节点地访问，直到找到这个数据项。
为了便于对链表进行操作，会在链表的第一个节点前再附设一个节点，称为头结点，不用来存储有意义数据（存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;
}