【C语言】链表的一般设计步骤

最新推荐文章于 2023-03-16 23:22:08 发布
置顶 最新推荐文章于 2023-03-16 23:22:08 发布
阅读量480 收藏
点赞数 2
分类专栏： 笔记 文章标签： c语言 链表 指针 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czm___/article/details/119388806
版权

一、链表的设计原理（一般建议使用堆空间存放链表）

  1. 设计链表的节点（数据域+指针域）

  2. 创建链表头结点（head）头结点相当于定义这一条链表的起点（钥匙）
    初始化链表头结点（数据域 + 指针域）

  3. 创建链表子节点（node）子节点插入到头结点后面（可以存储更多信息）
    初始化链表子结点（数据域 + 指针域）

  4. 插入节点（insert）将创建的节点放进链表里面，创立完整链表。
    尾插法，将新节点放置链表末尾
    头插法，将新节点放置头结点后一个
    排序插法，可以按冲从小到大，也可以从大到小

  5. 剔除节点（delete）
    将不需要节点删除，将链表不需要的节点从链表中拿出来，从此和链表无关。
    原理是：使用链表头结点，遍历整个链表，将各节点中的数据与待删除数据作用是比对，可找到剔除节点的位置。将该节点从链表中删除。

  6. 修改节点内的数据
    更改节点数据域中的内容

  7. 销毁链表
    如果链表是使用堆空间存储，销毁链表时需使用free函数将每个节点的堆空间释放

二、链表代码设计 （双向循环链表）

  1. 设计链表的节点（数据域+指针域）
typedef struct double_clink_list
{
    int data;							//数据域
    struct double_clink_list * next;	//后继指针
    struct double_clink_list * prev;	//前驱指针

}double_cll,*double_cll_p;				//重命名
  1. 创建链表头结点（head）
/**********************************************************************
**函数    :double_cll_p init_double_cll(void)	
**函数说明 : 创建头结点
**形参说明 :无  
**返回值  :  成功返回 新创建的头结点地址  
			失败返回 空地址
**********************************************************************/
double_cll_p init_double_cll(void)					 	 //创建头节点
{
    double_cll_p head = calloc(1,sizeof(double_cll));	//申请堆空间存放头结点
    if(head == NULL)									//判断申请是否成功
    {
        printf("init_double_cll error\n");        
        return NULL;									//失败直接返回
    }
    head->data = 0;										//初始化数据域
    head->next = head;									//初始化后继指针
    head->prev = head;									//初始化前驱指针
    return head;										//返回头结点地址
}
  1. 创建链表子节点（node）
/**********************************************************************
**函数    :double_cll_p create_node_double_cll(int data)
**函数说明 : 创建子节点
**形参说明 : data 为存放在 子节点数据域的数据 
**返回值  :  成功返回 新创建的子结点地址  
			失败返回 空地址
**********************************************************************/
double_cll_p create_node_double_cll(int data)			//创建子节点
{
    double_cll_p node = calloc(1,sizeof(double_cll));	//申请堆空间存放子节点
    if(node == NULL)									//判断申请是否成功
    {
        printf("create_node_double_cll error\n");        
        return NULL;									//失败直接返回
    }
    node->data = data;									//初始化数据域
    node->next = node;									//初始化后继指针
    node->prev = node;									//初始化前驱指针
    return node;										//返回子结点地址
}
  1. 插入节点（insert）
/**********************************************************************
**函数    :int tail_insert_double_cll(double_cll_p node,double_cll_p head)
**函数说明 : 尾插法，将新节点放置链表末尾
**形参说明 : node 为待插入子节点的地址    head为链表头节点的地址 
**返回值  :  成功返回 0
			失败返回 -1
**********************************************************************/
int tail_insert_double_cll(double_cll_p node,double_cll_p head)//尾插法，将新节点放置链表末尾
{
    if(head == NULL || node == NULL)			//判断头结点与子节点地址是否为空
    {
        printf("tail_insert_double_cll error\n");
        return -1;								//失败直接返回-1
    }
    //以下部分理解不了的自己画个图 或者 看我下面的图
    node->prev = head->prev;					//子节点前驱指针 指向 头结点前驱指针指向的子节点
    node->next = head;							//子节点后继指针 指向 头结点
    head->prev = node;							//头节点前驱指针 指向 子结点
    node->prev->next = node;					//头结点前驱指针 指向 的子节点的后继指针 指向 新子结点
    return 0;									//成功返回0
    
}

尾插图解
在这里插入图片描述

/**********************************************************************
**函数    :int head_insert_double_cll(double_cll_p node,double_cll_p head)
**函数说明 : 头插法，将新节点放置头结点后一个
**形参说明 : node 为待插入子节点的地址    head为链表头节点的地址 
**返回值  :  成功返回 0
			失败返回 -1
**********************************************************************/
int head_insert_double_cll(double_cll_p node,double_cll_p head)//头插法，将新节点放置头结点后一个
{
    if(head == NULL|| node == NULL)				//判断头结点与子节点地址是否为空
    {
        printf("head_insert_double_cll error\n");
        return -1;								//失败直接返回-1
    }
     //以下部分理解不了的自己画个图 
    node->next = head->next;			//子节点后继指针 指向 头结点后继指针指向的子节点
    head->next = node;					//头节点后继驱 指针 指向子结点
    node->prev = head;					//子节点前驱指针 指向 头结点
    node->next->prev = node;			//头结点后继指针 指向 的子节点的前驱指针 指向 新子结点
    return 0;							//成功返回0
	
	//或者
    //将新节点插入到head->next的前面 
    //tail_insert_double_cll(node,head->next);
}

/**********************************************************************
**函数    :int sort_insert_double_cll(double_cll_p node,double_cll_p head)
**函数说明 : 排序插法，可以按从从小到大排序插入，也可以从大到小排序插入
**形参说明 : node 为待插入子节点的地址    head为链表头节点的地址 
**返回值  :  成功返回 0
			失败返回 -1
**********************************************************************/
int sort_insert_double_cll(double_cll_p node,double_cll_p head)//排序插法，可以按冲从小到大，也可以从大到小
{
    if(head == NULL || node == NULL)				//判断头结点与子节点地址是否为空
    {
        printf("sort_insert_double_cll error\n");
        return -1;									//失败直接返回-1
    }
    double_cll_p  p = head;						//定义一个指针变量存放头结点地址
    for(;p->next != head;p = p->next)			//遍历整个链表，如果指针p再次指向head地址，说明已经遍历完
    {
        if(p->next->data > node->data)			//从小到大排序 插入
        {
            node->next = p->next;
            p->next = node;
            node->next->prev = node;
            node->prev = p;
            return 0;							//插入成功返回0
        }
    //     if(p->next->data < node->data)		//从大到小排序插入
    //     {
    //         node->next = p->next;
    //         p->next = node;
    //         node->next->prev = node;
    //         node->prev = p;
    //         return 0;						//插入成功返回0
    //     }
    }
    //如果链表只有头结点，那么子节点直接插入即可		
    node->next = p->next;
    p->next = node;
    node->next->prev = node;
    node->prev = p;
    return 0;					//插入成功返回0
}
  1. 剔除节点（delete）
/**********************************************************************
**函数    :int del_double_cll(double_cll_p p,double_cll_p head)
**函数说明 : 删除指定地址的节点
**形参说明 : p 为待剔除子节点的地址    head为链表头节点的地址 
**返回值  :  成功返回 0
			失败返回 -1
**********************************************************************/
int del_double_cll(double_cll_p p,double_cll_p head)//删除指定地址的节点
{
    if(p == NULL || head == NULL)			//判断头结点与子节点地址是否为空
    {
        printf("del_double_cll error\n");
        return -1;							//失败直接返回-1
    }
    p->next->prev = p->prev;				//将要删除的子节点断链
    p->prev->next = p->next;				//将要删除的子节点断链
    p->next = NULL;							//将要删除的子节点后继指针 指向 空
    p->prev = NULL;							//将要删除的子节点前驱指针 指向 空
    free(p);								//释放子节点的堆空间
    return 0;   							//剔除成功返回0
}
  1. 查找对应数据节点并返回该节点地址
/**********************************************************************
**函数    :double_cll_p find_double_cll(int data,double_cll_p head)
**函数说明 : 查找对应数据节点并返回该节点地址
**形参说明 : data 为待查找数据    head为链表头节点的地址 
**返回值  :  成功返回 待查找数据节点地址
			失败返回 空地址
**********************************************************************/
double_cll_p find_double_cll(int data,double_cll_p head)//查找对应数据节点并返回该节点地址
{
    if(head == NULL)						//判断头结点地址是否为空
    {
        printf("find_double_cll error\n");
        return NULL;					//失败直接返回空地址
    }
    double_cll_p p = head->next;		//定义一个指针变量 存放 头结点后继指针指向节点 的地址
    for(;p != head; p = p->next)		//遍历整个链表，如果指针p再次指向head地址，说明已经遍历完
    {
        if(p->data == data)   			//遍历的过程中，如果子节点数据 等于 待查找数据，则返回该子节点地址
            return p;					//返回子节点地址
    }
    return NULL;						//找不到返回 空地址
}
  1. 销毁链表
/**********************************************************************
**函数    :int free_double_cll(double_cll_p head)
**函数说明 : 释放链表所有内存
**形参说明 : head为链表头节点的地址 
**返回值  :  成功返回 0
			失败返回 -1
**********************************************************************/
int free_double_cll(double_cll_p head)//释放链表所有内存
{
    if(head == NULL)					//判断头结点地址是否为空
    {
        printf("double_cll not exist\n");
        return -1;						//失败直接返回-1
    }
    double_cll_p p = head;				//定义一个指针变量 存放 头结点 的地址
    for(;p->next != head;)				//遍历整个链表，如果指针p再次指向head地址，说明已经遍历完
    {
        p = p->next;					//变量p指向下一个节点
        free(p->prev);					//释放前一个节点的 堆空间（断链）
    } 
    free(p);							//释放头节点 堆空间
    return 0;							//链表销毁成功返回 0
}

完整 C程序 和 头文件

//双向循环链
#include "double_cll.h"

int main(int argc,char *argv[])
{
    double_cll_p head = init_double_cll();//创建头结点
    int data;//输入数据
    double_cll_p q = NULL;//存放需要删除节点的地址
    while(1)
    {
        scanf("%d",&data);//从键盘读取一个数据
        if(data>0)
        { 
            if(NULL==find_double_cll(data,head))//禁止输入重复的数据
            {
                double_cll_p node = create_node_double_cll(data);//创建子节点
                sort_insert_double_cll(node,head);//使用排序插入方式将子节点插入到链表   
            }
            else
            {
                printf("data repetition \n");
            }
            show_double_cll(head); //使用链表正顺序输出  

        }
        else if(data ==0)
            break; 
        else
        {
            if((q=find_double_cll(-data,head))!=NULL)//查找是否存在需要删除的数据
            {
                del_double_cll(q,head);//删除指定节点地址的 整个节点
            }
            else
            {
                printf("data absence \n"); 
            }
            show_double_cll(head);//使用链表正顺序输出  
        }
    }
    free_double_cll(head);//释放内存
    return 0;
}


double_cll_p init_double_cll(void)//创建头节点
{
    double_cll_p head = calloc(1,sizeof(double_cll));
    if(head == NULL)
    {
        printf("init_double_cll error\n");        
        return NULL;
    }
    head->data = 0;
    head->next = head;
    head->prev = head;
    return head;
}

double_cll_p create_node_double_cll(int data)//创建子节点
{
    double_cll_p node = calloc(1,sizeof(double_cll));
    if(node == NULL)
    {
        printf("create_node_double_cll error\n");        
        return NULL;
    }
    node->data = data;
    node->next = node;
    node->prev = node;
    return node;
}

int tail_insert_double_cll(double_cll_p node,double_cll_p head)//尾插法，将新节点放置链表末尾
{
    if(head == NULL || node == NULL)
    {
        printf("tail_insert_double_cll error\n");
        return -1;
    }
    node->prev = head->prev;
    node->next = head;
    head->prev = node;
    node->prev->next = node;
    return 0;
}

int head_insert_double_cll(double_cll_p node,double_cll_p head)//头插法，将新节点放置头结点后一个
{
    if(head == NULL|| node == NULL)
    {
        printf("head_insert_double_cll error\n");
        return -1;
    }
    node->next = head->next;
    head->next = node;
    node->prev = head;
    node->next->prev = node;
    return 0;

    //将新节点插入到head->next的前面
    //tail_insert_double_cll(node,head->next);
}

int sort_insert_double_cll(double_cll_p node,double_cll_p head)//排序插法，可以按冲从小到大，也可以从大到小
{
    if(head == NULL || node == NULL)
    {
        printf("sort_insert_double_cll error\n");
        return -1;
    }
    double_cll_p  p = head;
    for(;p->next != head;p = p->next)
    {
        if(p->next->data > node->data)//从小到大排序插入
        {
            node->next = p->next;
            p->next = node;
            node->next->prev = node;
            node->prev = p;
            return 0;
        }
    //     if(p->next->data < node->data)//从大到小排序插入
    //     {
    //         node->next = p->next;
    //         p->next = node;
    //         node->next->prev = node;
    //         node->prev = p;
    //         return 0;
    //     }
    }
    node->next = p->next;
    p->next = node;
    node->next->prev = node;
    node->prev = p;
    return 0;
}

int show_double_cll(double_cll_p head)//按链表正顺序输出
{
    if(head == NULL)
    {
        printf("show_double_cll error\n");
        return -1;
    }
    double_cll_p p = head;
    for(;p->next!=head;p = p->next)
    {
        printf("%d\t",p->next->data);
    }
    printf("\n");
    return 0;
}

double_cll_p find_double_cll(int data,double_cll_p head)//查找对应数据节点并返回该节点地址
{
    if(head == NULL)
    {
        printf("find_double_cll error\n");
        return NULL;
    }
    double_cll_p p = head->next;
    for(;p != head; p = p->next)
    {
        if(p->data == data)   
            return p;//重复返回1
    }
    return NULL;//没有重复
}

int free_double_cll(double_cll_p head)//释放链表所有内存
{
    if(head == NULL)
    {
        printf("double_cll not exist\n");
        return -1;
    }
    double_cll_p p = head;
    for(;p->next != head;)
    {
        p = p->next;
        free(p->prev);
    } 
    free(p);
    return 0;
}

int del_double_cll(double_cll_p p,double_cll_p head)//删除指定地址的节点
{
    if(p == NULL || head == NULL)
    {
        printf("del_double_cll error\n");
        return -1;
    }
    p->next->prev = p->prev;
    p->prev->next = p->next;
    p->next = NULL;
    p->prev = NULL;
    free(p);
    return 0;   
}

#ifndef __double_cll_h__
#define __double_cll_h__

#include<stdio.h>
#include <stdlib.h> 

typedef struct double_clink_list
{
    int data;
    struct double_clink_list * next;
    struct double_clink_list * prev;

}double_cll,*double_cll_p;


double_cll_p init_double_cll(void);//创建头节点
double_cll_p create_node_double_cll(int data);//创建子节点

int tail_insert_double_cll(double_cll_p node,double_cll_p head);//尾插法，将新节点放置链表末尾
int head_insert_double_cll(double_cll_p node,double_cll_p head);//头插法，将新节点放置头结点后一个
int sort_insert_double_cll(double_cll_p node,double_cll_p head);//排序插法，可以按冲从小到大，也可以从大到小

int show_double_cll(double_cll_p head);//按链表正顺序输出
double_cll_p find_double_cll(int data,double_cll_p head);//查找对应数据节点并返回该节点地址
int free_double_cll(double_cll_p head);//释放链表所有内存
int del_double_cll(double_cll_p p,double_cll_p head);//删除指定地址的节点

#endif

结束语：需要完整C程序的私信我发邮箱

CZM___
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言实现链表贪吃蛇
08-19
本文将详细介绍了C语言实现链表贪吃蛇游戏的设计思路和实现步骤，涵盖了游戏的主要模块，包括移动光标模块、打印地图模块、产生食物模块、蛇的生命状态判断模块、运行模块和结束模块等。同时，本文还提供了完整的...
c语言链表操作示例分享
09-04
总结来说，这个C语言链表操作示例展示了如何使用结构体和指针创建和操作链表，包括链表节点的定义、链表的初始化、插入新节点以及打印链表内容的基本步骤。对于初学者来说，这是一个很好的学习链表操作的起点。
基于C语言的链表的创建
navylhjjlh的博客
03-10 4088
基于C语言的链表的创建
C语言版数据结构（从0开始）2.链表（建立链表，有图有代码）
qq_44970368的博客
01-29 662
线性表的链式表示和实现链表1.链表的概念2.链表的特点3.结点的组成单链表1.单链表概念2.单链表的描述3.C语言结构定义4.单链表的基本运算建立单链表1.头插法建表：2.尾插法建表：3.尾插法建表的改进算法查找运算1.按序号查找2.按值查找：插入运算1.后插操作2.前插操作3.改进的前插算法删除运算循环链表1.循环链表的概念2.循环链表特点3.C语言实现4.基本运算（12种）建立单循环链表销毁链...
C语言实现单链表（超多配图，这下不得不学会单链表了）
2301_76269963的博客
03-16 7999
C语言实现单链表
C语言通用链表的创建及使用
m0_72066007的博客
09-06 1102
链表是一种物理 存储单元上非连续、非顺序的 存储结构 ，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
手把手教你写链表，小学生看了都说好~
weixin_39266374的博客
07-11 765
摘要：明明我们在之前已经接触了数组，感到数组已经是万能的数据存储位置了。但是，如果我们一直在使用比较复杂的数据（也就是比较多的数据时），肯定会感到很反感。因为对于数组这种数据结构，在你自己使用之前，一定要对其大小进行一番定义。这样一来，它的存储空间在数据处理过程中便显得极为不方便。因为谁也不想对将要处理的数据做一个空间的预算，这几乎是所有程序员都很忌讳的，并且还要让其空间足够大，这样才能满足我们的要求（但如果分配的太多，难免会浪费内存）。 所以，这就是为啥你要用链表、学链表。链表是一种数据结构，它弥补了数组
链表的设计
qq_43666632的博客
09-09 711
链表的设计与实现
设计链表（单链表）
weixin_43141795的博客
09-05 1239
设计链表（单链表） LeetCode 中设计单链表 代码块 class MyLinkedList { public: /** Initialize your data structure here. */ //初始化，生成头结点（哑结点） ListNode *pHead; MyLinkedList() { //ListNode *pHead; pHead = (ListNod...
c语言有序链表合并.rar
最新发布
04-26
下面是使用C语言合并两个有序链表的大致步骤和相关代码： 步骤： 创建一个新的链表来保存合并后的结果。 使用两个指针分别遍历两个链表。 将较小的那个节点链接到新链表的末尾。 移动对应的小节点指针到下一节点。...
建立正序链表 c语言链表正序输出,建立正序链表,该怎么处理
07-05
建立正序链表c语言链表正序输出 在计算机科学中，链表是一种基本的数据结构，它可以用来存储和管理大量数据。建立正序链表是指在链表中插入元素，使得链表中的元素按照一定的顺序排列。下面，我们将详细讨论建立...
C语言链表基本操作.doc
10-20
C语言链表基本操作知识点总结 在本文中，我们将详细介绍C语言链表基本操作的知识点，包括链表的建立、插入、删除、查找、倒置和删除等操作。 链表的建立 在C语言中，链表是一种动态分配的数据结构，每个结点都...
leetcode算法题-链表-设计链表
MarkusZhang的博客
02-02 401
题目描述 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则...
制作一个链表的方法
xvjixiang的专栏
04-15 919
首先，链表需要有
Leetcode-707. 设计链表
han jan的博客
08-05 4698
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1...
设计链表的实现。
shuliuguang的博客
06-13 333
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。 addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第
创建一个单链表节点
小灰灰的博客
04-08 7002
#include&lt;stdio.h&gt; #include&lt;strings.h&gt; #include&lt;stdlib.h&gt; //目的 将创建节点的代码封装成一个函数 //构建一个链表的节点，指针是p，暂时指向NULL struct node{ int data; //有效数据 struct node *pNext; //指向下一个节...
数据结构之单链表的增删查改等操作画图详解
小赵小赵福星高照的博客
08-05 2386
单链表 文章目录单链表链表的概念及其结构概念结构链表的实现开辟一个新结点链表的销毁打印链表单链表的尾插单链表的头插单链表的头删单链表的尾删找到单链表中的一个结点在pos位置后插入结点在pos位置前插入一个结点pos位置后删除结点pos位置删除结点返回链表大小判断链表是否为空源代码SList.h(单链表结构及其函数的声明)SList.c(单链表函数的实现)test.c(单链表功能的测试) 为什么有了顺序表，还需要有链表这样的数据结构呢？ 顺序表存在的问题： 中间或者头部插入删除，需要挪动数据时间复杂度为
基于linux下的C语言学习 1---C程序过程分析
czm___的博客
01-19 3229
一、C语言程序运行过程 1.编辑 选择一个适合的程序编辑软件，比如Notepad++，或者sublime编辑软件，更高级的有VSCode。 2.编译 预处理 ：其过程为将头文件的具体内容从指定路径拷贝一份到当前程序中，若程序中有宏定义内容，则将宏定义展开，同时删除程序中的所有注释内容。生成一个后缀为.i的文件。 命令为 gcc hello.c -E -o hello.i 编译 ：其过程为检查源程序是否存在语法错误，如若通过检测，则将.i文件翻译成汇编文件。生成一个后缀为.s的文件。 命令为 gc
c语言 链表的查询
09-06
- *1* *2* [一看就懂-c语言链表的查找，删除，清空【初阶】](https://blog.csdn.net/weixin_64524066/article/details/122373656)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值