标签：node cll head 步骤 C语言 链表 double 节点

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

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;				//重命名

2. 创建链表头结点（head）

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;										//返回头结点地址
}

3. 创建链表子节点（node）

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;										//返回子结点地址
}

4. 插入节点（insert）

**尾插法**
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)//头插法，将新节点放置头结点后一个
{
    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)//排序插法，可以按冲从小到大，也可以从大到小
{
    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
}

5. 剔除节点（delete）

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
}

6. 查找对应数据节点并返回该节点地址

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;						//找不到返回 空地址
}

7. 销毁链表

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程序的私信我发邮箱

标签：node,cll,head,步骤,C语言,链表,double,节点
来源： https://blog.csdn.net/czm___/article/details/119388806

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。