C语言实现单链表(不带头结点)

最新推荐文章于 2024-02-24 15:09:49 发布
最新推荐文章于 2024-02-24 15:09:49 发布
阅读量1.5k 收藏 8
点赞数 4
分类专栏： # 数据结构 文章标签： 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41999654/article/details/88934972
版权

      在之前的博客中，我写了有关线性表的顺序存储结构的顺序表，顺序表的特点是逻辑关系上，相邻的两个元素在物理位置上也相邻，因此可以随机存取表中任一元素，但是，它在进行插入删除操作时，需要移动大量的数据元素，故而在下面的内容中，讨论的是线性表的另一种存储结构（链式存储结构）中的不带头节点的单链表，由于链表不要求逻辑上相邻的元素在物理位置上也相邻，所以它没有顺序表的弱点，但是也失去了它的优点。

      附上我的有关顺序表的博客链接：

                     静态顺序表

      在下面的讨论中，我们讨论的是不带头结点的单链表，我们用一张图感受一下不带头结点的单链表如何存储数据：

              

      在下面的具体内容有：单链表结点的定义和单链表相关操作接口以及附上完整的代码，包括头文件，接口实现文件和测试文件，而操作接口包括：

      1、初始化  2、获得一个结点  3、尾插  4、尾删  5、头插  6、头删  7、查找指定元素  8、指定位置插入  9、指定位置删除  10、删除指定元素  11、删除所有指定元素  12、打印  13、销毁  14、获取链表长度

单链表结点的定义

       链表的定义：一种链式存储的线性表，用一组地址任意的存储单元存放线性表的数据元素，称存储单元为一个结点。

//结构体定义单链表的结点
typedef int DataType; 
typedef struct Node
{
    DataType data;   //当前节点所保存的元素
    struct Node* next;   //指向链表中下一个结点
}Node,List,*pNode,*pList;

       在上面的定义中，我们使用了关键字 typedef 使得结点中元素类型为 DataType ,有助于之后修改数据类型；而将 struct Node 创建新名为 Node 和 List ，和将 struct Node* 创建新名为 pNode 和 pList ，是为了帮助我们书写、阅读和理解之后的代码。

单链表的相关操作接口

1、初始化

void InitList(pList* pplist)
{
    assert(pplist != NULL);
    *pplist = NULL;
}

注：pplist是外部传进来的一个变量的地址，不敢为空指针，故需断言。在之后的代码中就不解释了。

2、获得一个结点

    因为在之后的插入中，我们需要得到一个结点进行插入操作，所以我先把获得一个结点的代码写出，代码如下：

pNode BuyNode(DataType d)
{
    pNode tmp = (pNode)malloc(sizeof(Node));    //申请一个结点大小的空间
    //判断是否申请空间成功
    if (tmp == NULL)
    {
	perror("BuyNode::malooc");
	return NULL;
    }
    //给新的结点赋值
    tmp->data = d;
    tmp->next = NULL;
    return tmp;
}

3、尾插

      核心：找到最后一个结点

void PushBack(pList* pplist,DataType d)
{
    pNode newNode = BuyNode(d);   //获得一个新的结点，存放我们要插入的数据

    assert(pplist != NULL);

    //判断获取新的结点是否成功
    if (newNode == NULL)   
    {
        exit(EXIT_FAILURE);
    }
    //空链表
    if (*pplist == NULL)
    {
	*pplist = newNode;
    }
    //非空链表，遍历单链表找到尾结点，将尾结点指向新结点
    else    
    {
	pNode cur = *pplist;
	while (cur->next != NULL)
	{
	    cur = cur->next;
	}
	cur->next = newNode;
    }
}

4、尾删

     核心：找到倒数第二个结点

void PopBack(pList* pplist)
{
    assert(pplist != NULL);

    //链表为空，无可删除数据，直接返回
    if (*pplist == NULL)
    {
        return;
    }
    //只有一个结点
    if ((*pplist)->next == NULL)
    {
	free(*pplist);
	*pplist = NULL;
    }
    //一个以上的结点
    else
    {
	pNode cur = *pplist;
	while(cur->next->next != NULL)
	{
	    cur = cur->next;
	}
	//循环结束，cur指向倒数第二个结点，释放最后一个结点
	free(cur->next);
	cur->next = NULL;
    }
}

5、头插

     核心：无需考虑是否为空链表

void PushFront(pList* pplist, DataType d)
{
    pNode newNode = BuyNode(d);   //获得一个新结点

    assert(pplist != NULL);

    //判断是否申请成功
    if (newNode == NULL)
    {
	exit(EXIT_FAILURE);
    }
    //头插
    newNode->next = *pplist;
    *pplist = newNode;
}

6、头删

void PopFront(pList* pplist)
{
    assert(pplist != NULL);
    
    //链表为空，无可删除数据，直接返回
    if (*pplist == NULL)
    {
	return;
    }
    //链表不为空，将 pplist 指向第二个结点，此时第二个结点为第一个结点，需注意释放被删除的空间。
    else
    {
	pNode del = *pplist;
	*pplist = del->next;
	free(del);
	del = NULL;
    }
}

7、查找指定元素

    核心：返回的是所查找的元素的地址，方法是遍历查找。

pNode Find(pList plist, DataType d)
{
	pNode cur = plist;
	while (cur)
	{
		if (cur->data == d)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;   //没找到
}

8、指定位置插入

     核心：指定位置是否为第一个位置，不是的话，是否存在。

void Insert(pList* pplist, pNode pos, DataType d)
{
    pNode newNode = NULL;

    assert(pplist != NULL);
    assert(*pplist != NULL);
    assert(pos != NULL);

    //第一个位置——>头插
    if (pos == *pplist)
    {
        newNode = BuyNode(d);
        newNode->next = *pplist;
        *pplist = newNode;
    }
    else
    {
        pNode cur = *pplist;
        while (cur && cur->next != pos)  //顺序不可以颠倒
        {
            cur = cur->next;
        }
        if (cur != NULL)
        {
            newNode = BuyNode(d);
            newNode->next = pos;
            cur->next = newNode;
        }
    }
}

9、指定位置删除

    核心：同上，位置问题

void Erase(pList* pplist, pNode pos)
{
    assert(pplist != NULL);
    assert(pos != NULL);
    
    if (*pplist == NULL)
    {
        return;
    }
    //第一个结点
    if (*pplist == pos)
    {
        //头删
        pNode del = pos;
        *pplist = (*pplist)->next;
        free(del);
        del = NULL;
    }
    //不是第一个结点
    else
    {
        pNode cur = *pplist;
        while (cur&&cur->next != pos)
        {
            cur = cur->next;
        }
        if (cur != NULL)
        {
            cur->next = pos->next;
            free(pos);
            pos = NULL;
        }
    }
}

10、删除指定元素

    核心：根据前面写的查找指定元素和指定位置删除就可以实现

void Remove_1(pList* pplist, DataType d)
{
    pNode cur = NULL;
    pNode prev = NULL;

    assert(pplist != NULL);

    cur = *pplist;
    while (cur)
    {
        if (cur->data == d)
        {
            //是第一个结点
            if (*pplist == cur)
            {
                PopFront(pplist);
            }
            //非第一个结点
            else
            {
                prev->next = cur->next;
                free(cur);
                cur = NULL;
            }
            return;
        }
        else
        {
            prev = cur;
            cur = cur->next;
        }
    }
}

void Remove_2(pList* pplist, DataType d)
{
    pNode pos = NULL;

    assert(pplist != NULL);

    pos = Find(*pplist, d);
    if (pos != NULL)
    {
        Erase(pplist, pos);
    }
}

11、删除所有指定元素 

       核心：与删除指定元素略有差异，需注意删除一个以后，将cur指向删除元素后一位。

void RemoveAll(pList* pplist, DataType d)
{
    pNode cur = NULL;
    pNode prev = NULL;

    assert(pplist != NULL);

    cur = *pplist;
    while (cur)
    {
        if (cur->data == d)
        {
            //是第一个结点
            if (*pplist == cur)
            {
                PopFront(pplist);
                cur = *pplist;
            }
            //非第一个结点
            else
            {
                prev->next = cur->next;
                free(cur);
                cur = prev;
            }
        }
        else
        {
            prev = cur;
            cur = cur->next;
        }
    }
}

12、打印

void PrintList(pList plist)
{
    //无需断言，允许链表为空

    //遍历打印
    pNode cur = plist;
    while (cur)
    {
	printf("%d--->", cur->data);
	cur = cur->next;
    }
    printf("over\n");
}

13、销毁

void DestroyList(pList* pplist)
{
    pNode cur = *pplist;

    assert(pplist != NULL);

    //从前向后销毁
    while (cur != NULL)
    {
	pNode del = cur;   //保存要销毁的结点
	cur = cur->next;   //使cur下一个要被销毁的结点
	free(del);
	del = NULL;
    }
    *pplist = NULL;
}

14、获取链表长度

int GetListLength(pList plist)
{
    pNode cur = plist;
    int count = 0;   //计数
    while (cur)   //遍历
    {
	count++;
	cur = cur->next;
    }
    return count;
}

    附上完整代码

//LinkList.h

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

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

typedef int DataType;
typedef struct Node
{
    DataType data;
    struct Node* next;
}Node, *pNode, List, *pList;

void InitList(pList* pplist);
pNode BuyNode(DataType d);
void PushBack(pList* pplist,DataType d);
void PopBack(pList* pplist);
void PushFront(pList* pplist, DataType d);
void PopFront(pList* pplist);
pNode Find(pList plist, DataType d);
void Insert(pList* pplist,pNode pos, DataType d);
void Erase(pList* pplist, pNode pos);
void Remove_1(pList* pplist, DataType d);
void Remove_2(pList* pplist, DataType d);
void RemoveAll(pList* pplist, DataType d);
void PrintList(pList plist);
void DestroyList(pList* pplist);
int GetListLength(pList plist);

#endif //__LINKLIST_H__
LinkList.c

#include "LinkList.h"

void InitList(pList* pplist)
{
    assert(pplist != NULL);   
    *pplist = NULL;
}

pNode BuyNode(DataType d)
{
    pNode tmp = (pNode)malloc(sizeof(Node));
    if (tmp == NULL)
    {
        perror("BuyNode::malooc");
        return NULL;
    }
    tmp->data = d;
    tmp->next = NULL;
    return tmp;
}

void PushBack(pList* pplist,DataType d)
{
    pNode newNode = BuyNode(d);

    assert(pplist != NULL);

    if (newNode == NULL)
    {
        exit(EXIT_FAILURE);
    }
    if (*pplist == NULL)   //空链表
    {
        *pplist = newNode;
    }
    else
    {
        pNode cur = *pplist;
        while (cur->next != NULL)
        {
            cur = cur->next;
        }
        cur->next = newNode;
    }
}

void PopBack(pList* pplist)
{
    assert(pplist != NULL);

    //链表为空，无可删除数据，直接返回
    if (*pplist == NULL)
    {
        return;
    }
    //只有一个结点
    if ((*pplist)->next == NULL)
    {
        free(*pplist);
        *pplist = NULL;
    }
    //一个以上的结点
    else
    {
        pNode cur = *pplist;
        while(cur->next->next != NULL)
        {
            cur = cur->next;
        }
        //循环结束，cur指向倒数第二个结点，释放最后一个结点
        free(cur->next);
        cur->next = NULL;
    }
}

void PushFront(pList* pplist, DataType d)
{
    pNode newNode = BuyNode(d);

    assert(pplist != NULL);

    if (newNode == NULL)
    {
        exit(EXIT_FAILURE);
    }
    newNode->next = *pplist;
    *pplist = newNode;
}

void PopFront(pList* pplist)
{
    assert(pplist != NULL);

    if (*pplist == NULL)
    {
        return;
    }
    else
    {
	pNode del = *pplist;
	*pplist = del->next;
	free(del);
	del = NULL;
    }
}

pNode Find(pList plist, DataType d)
{
    pNode cur = plist;
    while (cur)
    {
        if (cur->data == d)
        {
            return cur;
        }
        cur = cur->next;
    }
    return NULL;
}

void Insert(pList* pplist, pNode pos, DataType d)
{
    pNode newNode = NULL;

    assert(pplist != NULL);
    assert(*pplist != NULL);
    assert(pos != NULL);

    //第一个位置——>头插
    if (pos == *pplist)
    {
        newNode = BuyNode(d);
        newNode->next = *pplist;
        *pplist = newNode;
    }
    else
    {
        pNode cur = *pplist;
        while (cur && cur->next != pos)  //顺序不可以颠倒
        {
            cur = cur->next;
        }
        if (cur != NULL)
        {
            newNode = BuyNode(d);
            newNode->next = pos;
            cur->next = newNode;
        }
    }
}

void Erase(pList* pplist, pNode pos)
{
    assert(pplist != NULL);
    assert(pos != NULL);
    
    if (*pplist == NULL)
    {
        return;
    }
    //第一个结点
    if (*pplist == pos)
    {
        //头删
        pNode del = pos;
        *pplist = (*pplist)->next;
        free(del);
        del = NULL;
    }
    //不是第一个结点
    else
    {
        pNode cur = *pplist;
        while (cur&&cur->next != pos)
        {
            cur = cur->next;
        }
        if (cur != NULL)
        {
            cur->next = pos->next;
            free(pos);
            pos = NULL;
        }
    }
}

void Remove_1(pList* pplist, DataType d)
{
    pNode cur = NULL;
    pNode prev = NULL;

    assert(pplist != NULL);

    cur = *pplist;
    while (cur)
    {
        if (cur->data == d)
        {
            //是第一个结点
            if (*pplist == cur)
            {
                PopFront(pplist);
            }
            //非第一个结点
            else
            {
                prev->next = cur->next;
                free(cur);
                cur = NULL;
            }
            return;
        }
        else
        {
            prev = cur;
            cur = cur->next;
        }
    }
}

void Remove_2(pList* pplist, DataType d)
{
    pNode pos = NULL;

    assert(pplist != NULL);

    pos = Find(*pplist, d);
    if (pos != NULL)
    {
        Erase(pplist, pos);
    }
}

void RemoveAll(pList* pplist, DataType d)
{
    pNode cur = NULL;
    pNode prev = NULL;

    assert(pplist != NULL);

    cur = *pplist;
    while (cur)
    {
        if (cur->data == d)
        {
            //是第一个结点
            if (*pplist == cur)
            {
                PopFront(pplist);
                cur = *pplist;
            }
            //非第一个结点
            else
            {
                prev->next = cur->next;
                free(cur);
                cur = prev;
            }
        }
        else
        {
            prev = cur;
            cur = cur->next;
        }
    }
}

void PrintList(pList plist)
{
    pNode cur = plist;
    while (cur)
    {
    printf("%d--->", cur->data);
    cur = cur->next;
    }
    printf("over\n");
}

void DestroyList(pList* pplist)
{
    pNode cur = *pplist;

    assert(pplist != NULL);

    while (cur != NULL)
    {
        pNode del = cur;
        cur = cur->next;
        free(del)
        del = NULL;
    }
    *pplist = NULL;
}

int GetListLength(pList plist)
{
    pNode cur = plist;
    int count = 0;
    while (cur)
    {
        count++;
        cur = cur->next;
    }
    return count;
}

 

test.c

#include "LinkList.h"

void TestPushBack()
{
    pList plist = NULL;
    InitList(&plist);
    PushBack(&plist, 1);
    PushBack(&plist, 2);
    PushBack(&plist, 3);
    PushBack(&plist, 4);
    PrintList(plist);  //1  2  3  4
    printf("len = %d\n", GetListLength(plist));  //4
    DestroyList(&plist);
    PrintList(plist);  //
}

void TestPopBack()
{
    pList plist = NULL;
    InitList(&plist);
    PushBack(&plist, 1);
    PushBack(&plist, 2);
    PushBack(&plist, 3);
    PushBack(&plist, 4);
    PrintList(plist);   //1  2  3  4
    PopBack(&plist);  
    PrintList(plist);   //1  2  3
    PopBack(&plist);  
    PrintList(plist);   //1  2
    PopBack(&plist);  
    PrintList(plist);   //1
    PopBack(&plist);  
    PrintList(plist);   //
    DestroyList(&plist);
    PrintList(plist);   //
}

void TestPushFront()
{
    pList plist = NULL;
    InitList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PrintList(plist);   //4  3  2  1
    DestroyList(&plist);
    PrintList(plist);  //
}

void TestPopFront()
{
    pList plist = NULL;
    InitList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PrintList(plist);   //4  3  2  1
    PopFront(&plist);
    PrintList(plist);   //3  2  1
    PopFront(&plist);
    PrintList(plist);   //2  1
    PopFront(&plist);
    PrintList(plist);   //1
    PopFront(&plist);
    PrintList(plist);   //
    DestroyList(&plist);
    PrintList(plist);  //
}

void TestFind()
{
    pList plist = NULL;
    pNode pos = NULL;
    InitList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PrintList(plist);   //4  3  2  1
    pos = Find(plist, 3);
    if (pos != NULL)
    {
        printf("%d\n", pos->data);
    }
    DestroyList(&plist);
    PrintList(plist);  //
}

void TestInsert()
{
    pList plist = NULL;
    pNode pos = NULL;
    InitList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PrintList(plist);   //4  3  2  1
    pos = Find(plist, 3);
    if (pos != NULL)
    {
        Insert(&plist, pos, 5);
    }
    PrintList(plist);   //4  5  3  2  1
    pos = Find(plist, 4);
    if (pos != NULL)
    {
        Insert(&plist, pos, 6);
    }
    PrintList(plist);   //6  4  5  3  2  1
    DestroyList(&plist);
    PrintList(plist);  //
}

void TestErase()
{
    pList plist = NULL;
    pNode pos = NULL;
    InitList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PrintList(plist);   //4  3  2  1
    pos = Find(plist, 3);
    if (pos != NULL)
    {
        Erase(&plist, pos);
    }
    PrintList(plist);   //4  2  1
    pos = Find(plist, 4);
    if (pos != NULL)
    {
        Erase(&plist, pos);
    }
    PrintList(plist);   //2  1
    DestroyList(&plist);
    PrintList(plist);  //
}

void TestRemove()
{
    pList plist = NULL;
    InitList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 1);
    PushFront(&plist, 4);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PrintList(plist);   //3  2  4  1  3  2  1
    Remove_1(&plist, 2);
    PrintList(plist);   //3  4  1  3  2  1
    Remove_2(&plist, 3);
    PrintList(plist);   //4  1  3  2  1
    RemoveAll(&plist, 1);
    PrintList(plist);   //4  3  2 
    DestroyList(&plist);
    PrintList(plist);  //
}

int main()
{
    TestPushBack();
    TestPopBack();
    TestPushFront();
    TestPopFront();
    TestFind();
    TestInsert();
    TestErase();
    TestRemove();

    system("pause");
    return 0;
}

 

lxt-cn
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表求和
Syameimaru_Aya_的博客
03-31 785
I.   问题描述        你有两个用链表代表的整数，其中每个节点包含一个数字。数字存储按照在原来整数中相反的顺序，使得第一个数字位于链表的开头。写出一个函数将两个整数相加，用链表形式返回和。给出两个链表 3->1->5->null 和 5->9->2->null，返回 8->0->8->null II.   解题思路        新建一个链表,节点是其他两个节点加和对10取余数。在
数据结构：C语言实现----不带头结点单链表总结
kimEHEH的博客
08-11 637
不带头结点的单链表结构体声明 typedef struct Node { int data; struct Node *next; }Node, *LinkList; （1）初始化 void InitLinkList(LinkList *plist) //plist为二级指针，主函数传递第一个结点指针的地址 { assert(plist!=NULL); if(plist == NULL) return; *plist = NULL; } （2）求链表长度 int Lis.
不带头结点的单链表的实现
weixin_43831728的博客
02-25 1224
SList.h //不带头结点的单链表 //不带头结点的话，那么链表表中的第一个节点一顶存储的是有效元素 #pragma once //保证头文件不被重复包含 #include<assert.h> #include<stdlib.h> #include<stdio.h> //如果想要对链表进行操作，那么首先需要一个结点的结构体 typedef i...
[C语言、C++]数据结构作业：线性表-单链表(无头节点)的基本操作
Yhisken的博客
09-30 673
[C语言、C++]数据结构作业：线性表-单链表(无头节点)的基本操作
C语言数据结构——单链表(不带头)
qq_65980796的博客
02-13 2193
一、单链表：1.1 概念、1.2 链表结构分析、1.3 单链表的基本操作、1.4 单链表的基本操作源码。
C语言实现单链表（带头结点）的基本操作
03-25
这里我们将深入探讨如何在C语言中实现一个带头结点的单链表，包括其创建、插入、删除、遍历和打印等基本操作。 首先，我们需要定义链表的节点结构。带头结点的链表会在链表的开头有一个特殊的节点，它的数据部分...
基于C语言实现单链表(不带头结点)
最新发布
03-28
本教程将详细讲解如何在C语言中实现一个不带头结点的单链表，包括链表的基本操作如创建、插入、删除、遍历等。 首先，我们需要定义链表节点的结构体。在C语言中，结构体是一种自定义的数据类型，可以用来封装多种...
C语言实现单链表（带头结点）的基本操作.zip
02-28
本项目"**C语言实现单链表（带头结点）的基本操作.zip**"显然专注于通过C语言创建和操作带有头结点的单链表。头结点是一个特殊的节点，它的数据字段通常不存储实际的数据，而是用作链表的起点。 首先，我们讨论链表...
单循环链表（不带表头）的C语言实现（详细）
qq_983030560的博客
12-19 1694
单循环链表（不带表头）的C语言实现，非常详细
链表-----节点最大值，累加和，统计节点个数，逆序数据建立链表以及回文字符串
2302_78946488的博客
02-24 1131
在这里描述函数接口。例如： int max_node( struct node *p)p是链表头指针,返回链表上最大的ch属性值。p是链表头指针,返回链表上所有节点ch属性值的累加和。head是链表头指针，返回值是节点个数函数createlist利用scanf从输入中获取一系列正整数，当读到−1时表示输入结束。按输入数据的逆序建立一个链表，并返回链表头指针。函数Judge_char判断输入字符串char *s是否为回文，若是则返回1，否则返回0。
无头节点的单链表
07-17
无头节点单链表的实现可是说是对C语言指针一个最直接、最贴合实际、也是最具有归纳性的程序设计应用。许多C语言基础面试题都涉及单链表的实现和构造，其目的就是考察面试者对C语言基础数据类型是否有足够的了解，对C语言指针是否掌握。链表的实现可以简单也可以很复杂，只是我们对待问题的态度不同，回想起了大学刚学习链表的时候，总是对链表中用到的结构体和链表节点有很多的迷茫，直到后来仔细研究了一番，并且写下了这个代码才解开了心中很久的困惑。 回看了一下自己写的这个单链表的实现，注释写的非常详细了，包括了单链表中二级指针的应用场景，为什么要使用二级指针这些问题都有一个详细的总结，也包括链表节点的结构体和学生个人信息结构体的这些区分。可以说是楼主就是从这个阶段才正真开始对结构体，对指针，对链表的“数据域”，“指针域”有了较为清晰的了解。 上传这些代码完全因为楼主确实想把自己学习过程中的遇到到一些问题和错误认识，以及一些经验共享出来，希望帮助那些和曾经的我一样充满迷茫困惑的同学朋友。
数据结构单链表实现（不带头节点）C语言
Davidljjj的博客
04-04 135
按照王道数据结构考研的知识实现（尾插法，头插法王道未提供，自己写的，有瑕疵，但基本能实现）
PTA 6-2链表遍历
m0_65186465的博客
03-30 2803
本题要求实现一个函数，从链表的头指针开始遍历整个链表输出每个节点字符数据。 输入样例： 5 输出样例： abcde void countnode(struct node *head) { char k=0; while(head!=NULL) { printf("%c",k+head->ch); head=head->next; } } ...
链表(1)C语言实现 单链表 无头结点 基本操作 无头结点单链表的基本操作 详解 链表的概念及结构 数据结构
weixin_63666347的博客
04-28 2468
3.链表 3.1 链表的概念及结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的 注意： 1.从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续 2.现实中的结点一般都是从堆上申请出来的 3.从堆上申请的空间是按照一定的策略来分配的，两次申请的空间可能连续也可能不连续 3.2 链表的分类 1. 单向或者双向 2. 带头或者不带头 3. 循环或者非循环 3.3 单链表的实现 ...
数据结构-链表结构
wumanxin2018的博客
12-08 619
数据结构-链表结构
数据结构C语言-不带头结点的单链表头插法/尾插法创建
gxy03的博客
03-30 1万+
最近有点忙，今天才开始看数据结构单链表的部分，由于考研，看了《王道复习指导书》上只讲了带头结点的单链表操作，只是文末提了下不带头节点的什么情况，在此结合王道复习书，电脑上写了运行了下不带头结点的。 // // Created by gxj on 2021/3/30. // #include <stdio.h> #include <stdlib.h> typedef int ElementType; //单链表结构体,LNode表示结点，LinkList表示链表，其实两者一样的
c语言创建带头结点和不带头节点的单链表(头插法&尾插法)
热门推荐
weixin_42274486的博客
03-20 1万+
说明 最近开始学习数据结构相关的知识，看到单链表的内容，对于单链表的创建的头插法和尾插法两种方法，又根据单链表是否带有头结点，这样会产生四种情况。作为刚刚开始学习数据结构的小白，很是迷茫，通过参考《大话数据结构》等，现在对单链表的创建做一个总结，以备日后复现。如果下面的内容有错误，还请多多指出。 定义结点 typedef struct LNode{ int data; struct...
数据结构（C语言）-- 单链表
weixin_53000329的博客
04-24 1516
文章目录前言一、要学什么、掌握什么二、深入了解1.数据构成2.头指针、头结点、首元结点二、深入了解二、深入了解二、深入了解总结 前言 链表，别名链式存储结构或单链表，用于存储逻辑关系为 “一对一” 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。 一、要学什么、掌握什么 1. 熟练掌握线性表的基本操作在链式存储结构上的实现 2. 掌握单链表的建立、插入、删除等基本操作； 二、深入了解 1.数据构成 数据域：存放数据本身的信息。 指针域：
C语言实现单链表（不带头节点）的删除插入完整代码
qq_54628272的博客
02-10 2942
注意：不带头节点的单链表删除插入操作第一个节点的时候都要特殊讨论 以下代码是用C语言实现的完整代码可上机运行 #include<stdio.h> #include<malloc.h> struct linknode { int data; struct linknode* next; }; void init(struct linknode** L) { (*L) = NULL; } void insect(struct linknode** L, int i, ..
c语言删除单链表（带头结点，头插入法建立单链表）的第i个结点
04-01
以下是删除单链表第i个结点的C语言代码，其中假设单链表的头结点为head： ```c #include #include typedef struct Node { int data; struct Node* next; } Node; // 头插入法建立单链表 Node* createList(int...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值