单链表

最新推荐文章于 2021-03-28 00:53:56 发布
最新推荐文章于 2021-03-28 00:53:56 发布
阅读量333 收藏 2
点赞数 1
分类专栏： C语言 文章标签： 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39558227/article/details/103032629
版权

文章目录

从一个错误的嵌套结构体开始入手

struct Test
{
int x;
int y;
struct Test test;
};

会陷入无限的递归出现段错误

struct Test
{
int x;
int y;
struct Test *test;//变成指针之后就不会报错
};

变成指针以后就不会循环了，因为这个语句的意思只是声明了一个指针，而不是无限循环。这就是链表的结构。

单链表

在这里插入图片描述
把结构体改变为链表的结构

//链表book
struct Book2
{
    char title[128];
    char author[40];
    struct Book2 *next;
    
};

在单链表中插入元素
先连后断，保证能找到后一个节点。

#include<stdio.h>
#include<stdlib.h>
//链表book
struct Book2
{
    char title[128];
    char author[40];
    struct Book2 *next;
    
};

void getInput(struct Book *book)
{
    printf("input book name:\n");
    scanf("%s",book->title);
    printf("input writer:\n");
    scanf("%s",book->author);
}




void addBook(strcut Book **library)//这里要进行两层的解引用，它是一个指向Book2结构的指针的指针 因为要修改指针的值，所以要传入指针的地址
{
    struct Book2 *book，*temp;
    book=(struct Book2*)malloc(sizeof(struct Book2));
    if (book==NULL)
    {
        printf("fail!\n");
        exit(1);
    }
    getInput(book);
    if(*library !=NULL)
    {
        temp=*library;
        *library=book;
        book->next=temp;//把book.next指向上一次的地址
    }
    else{//*library 是空的，即直接把head指向这个新生成的节点
        *library=book;
        book->next=NULL;
    }
    
}
void printLibrary(struct Book *library)
{
    struct Book *book;
    int count=1;
    book=library;
    while (book!=NULL)
    {
        printf("Book%d:",count);
        printf("name:%s",book->title);
        book=book->next;
        count++;
    }
}

void releaseLibrary(struct Book **library)
{
	struct Book *temp;
	
    while (*library!=NULL)
    {
    	//这里需要增加一个临时变量，使得释放能正常运行
    	temp=*library;
    	*library=(*library)->next;
        free(temp);
    }
}



int main()
{
    
    struct Book2 *library=NULL;
    addBook(&library);//这里要给library的地址，而不是library，因为要修改的并不是library，而是其前一个节点
    //打印成员
    printLibrary(library);
    releaseLibrary(library);
    return 0;
}

形参里解引用两次的解释：
首先简单来说假如你写一个函数执行完使得p=3并传回主函数，你怎么写？
一种是直接赋值/例子说明，语法简略: int func(int p){ p=3,return p }
这样做的时候你不得不在main函数里面写上 p= func§;因为函数里面的局部变量不会改变main里面的值，所以你需要“返回+赋值”两道工序。
指针的作用就是解决这道工序，传入地址再更改可以改值！
如果改为 void func(int *p){ *p=3 }即更改完毕,main里面写 func(&p); 就好。

该题同理,头插法用常人的思路只用一个" * "能不能写？能写！
以下为我的代码/这里没有语法问题(这个函数需要你能看明白)：

struct Book *add_book(struct Book *library)
{
        struct Book *book=NULL,*temp;
        book = (struct Book *)malloc(sizeof(struct Book));
        if(book==NULL)        exit(1);
        printf("请输入书名:\n");
        scanf("%s",book->title);
        printf("请输入作者:\n");
        scanf("%s",book->author);
        if(library!=NULL)
        {
                temp = library;
                library = book;
                book->next = temp; 
        }        
        else
        {
                library = book;
                book->next = NULL;
        }
        printf("插入成功\n");
        return library;
}

通常看这些代码没那么多*脑袋就不晕了，这里你要明白，这个形参里的指针library跟例子里面的常量p是一样的，无论library怎么改都不会进入main函数，所以必须要有“返回+赋值”。
于是主程序必须写成这样：{… library=add_book(library); …}。放心，该头插法可以正常运行。

现在我们跟示例一样将p变成p,函数变为void add_book(struct Book **library)，将里面所有的library直接变为library, 这样函数没有返回值，main函数里面的语句变为：add_book(&library);

用我这种思路的好处是：1.你不必纠结于“”的具体意义就能写出的函数。2.你可以主动“降维”，写单*的函数实现相同的功能，有效降低大脑负荷。

尾插法
void addBook(strcut Book **library)//这里要进行两层的解引用，它是一个指向Book2结构的指针的指针 因为要修改指针的值，所以要传入指针的地址
{
    struct Book2 *book，*temp;
    book=(struct Book2*)malloc(sizeof(struct Book2));
    if (book==NULL)
    {
        printf("fail!\n");
        exit(1);
    }
    getInput(book);
    if(*library !=NULL)
    {
        temp=*library;//这个和头插一样
        //定位单链表的尾部位置
        while(temp->next !=NULL)
        {
            temp=temp->next;
        }
        //找到最后一个节点之后插入数据
        temp->next=book;
        book->next=NULL;
    }
    else{//*library 是空的，即直接把head指向这个新生成的节点
        *library=book;
        book->next=NULL;
    }
    
}

高效尾插法

void addBook(strcut Book **library)//这里要进行两层的解引用，它是一个指向Book2结构的指针的指针 因为要修改指针的值，所以要传入指针的地址
{
    static struct Book *tail;//用来记录单链表尾部的位置，需要变成静态变量 不需要每次都进行遍历
    struct Book2 *book，*temp;
    book=(struct Book2*)malloc(sizeof(struct Book2));
    if (book==NULL)
    {
        printf("fail!\n");
        exit(1);
    }
    getInput(book);
    if(*library !=NULL)
    {
        tail->next=book;
        book->next=NULL;
    }
    else{//*library 是空的，即直接把head指向这个新生成的节点
        *library=book;
        book->next=NULL;
    }
    //最后把book设置为新的tail
    
    tail=book;
}
搜索节点
struct Book *searchBook(struct Book *library,char *target)
{
 struct Book *book;
 book=library;
 while (book!=NULL)
 {
     if(!strcmp(book->title,target)||!strcmp(book->author,target))//strcmp 若俩字符串相等则返回0 否则返回1
     {
      break;//找到就跳出   
     }
     book=book->next;
 }
 return book;
    
}
实战训练

单链表的插入相比数组，并不用把数组插入元素后面的元素都往后移动。
例：
让用户输入若干整数，然后进行插入：

struct Node
{
    int value;
    struct Node *next;
};

void insertNode(struct Node **head,int value)//value 是插进去具体的值
{
    struct Node *prev;
    struct Node *curr;
    struct Node *new;
    
    curr=*head;
    pre=NULL;
    while(curr!=NULL && curr->value<value)//来查找定位
    {
        prev=curr;
        curr=curr->next;
    }
    //申请一个内存空间来存放新的节点插入找到的位置之前
    new=(struct Node *)malloc(sizeof(struct Node));
    if (new==NULL)
    {
        exit(1);
    }
    new->value=value;
    new->next=curr;
    if (prev==NULL)//自身是一个空的单链表
    {
        *head=new;
    }
    else{
        prev->next=new;
    }
}

void printNode(struct Node *head)
{
    struct Node *curr;
    curr=head;
    while (curr!=NULL)
    {
        printf("%d\n",curr->value);
        curr=curr->next;
    }
    putchar('\n');
}




int main()
{
    struct Node *head=NULL;
    int input;
    while (1)
    {
        printf("input a num:");
        if(input==-1)
        {
            break;
        }
        insertNode(&head,input);
        printNode()
    }
    return 0;
}

例2：
链表的删除

struct Node
{
    int value;
    struct Node *next;
};

void insertNode(struct Node **head,int value)//value 是插进去具体的值
{
    struct Node *prev;
    struct Node *curr;
    struct Node *new;
    
    curr=*head;
    pre=NULL;
    while(curr!=NULL && curr->value<value)//来查找定位
    {
        prev=curr;
        curr=curr->next;
    }
    //申请一个内存空间来存放新的节点插入找到的位置之前
    new=(struct Node *)malloc(sizeof(struct Node));
    if (new==NULL)
    {
        exit(1);
    }
    new->value=value;
    new->next=curr;
    if (prev==NULL)//自身是一个空的单链表
    {
        *head=new;
    }
    else{
        prev->next=new;
    }
}

void printNode(struct Node *head)
{
    struct Node *curr;
    curr=head;
    while (curr!=NULL)
    {
        printf("%d\n",curr->value);
        curr=curr->next;
    }
    putchar('\n');
}

void deleteNode(struct Node **head,int input)
{
    struct Node *prev;
    struct Node *curr;
    curr=*head;
    prev=NULL;
    while(curr!=NULL && curr->value!=value)
    {
        
        pre=curr;
        curr=curr->next;
    }
    if (curr==NULL)
    {
        printf("not found!");
        return ;
    }
    else{
            if (prev==NULL)
            {
                *head=curr->next;
            }
            else
            {
                 pre->next=cur->next;
                cur->next=NULL;
        
            }
       
    }
}


int main()
{
    struct Node *head=NULL;
    int input;
    while (1)
    {
        printf("input a num:");
        if(input==-1)
        {
            break;
        }
        deleteNode(&head,input);
        printNode()
    }
    return 0;
}
yuyijie_1995
关注
专栏目录
C单链表详解--从零开始（一）
catchyou118的博客
12-20 386
链表：由N个节点(Node)组成，每个节点包含数据域和指针域，如果指针域只有下一个节点的地址则为单链表，此处只说单链表方便学习。 静态链表的实现：静态链表物理地址是连续的，空间申请后已经固定。 `#include "stdio.h" //创建静态单链表 //1.声明节点的数据域和指针域，方便学习节点Node,设置一个数据 struct Node { int num; //定义节点数据域 ...
2.1单链表
zaizai520的博客
03-02 189
前言 和数组一样，链表是一个线性的数据结构。不同的是，数组需要一段连续的内存来存放数据，而链表的数据不需要连续的内存来存放，链表可以通过指针将一组零散的内存连接起来用来存放数据，这些零散的内存就对应链表上的节点。 为什么需要链表？ 数组相比于链表，有如下缺点： 因为数组的大小是固定的。一经声明便会占据整块连续的内存。因此必须事先知道需要多少内存。如果分配内存过大，可能会造成浪费和内存不足。如果分...
c/c++常见面试题02
jialing678的博客
04-02 1662
1 两个字符串s、t，把t字符串插入到s字符串中，s字符串有足够的空间存放t字符串 void insert(char *s, char *t, int i) { char *q = t; char *p =s; if(q == NULL)return; while(*p!='\0') { p++; } while(*q!=0) { *p=*q; p++; q++; ...
单链表详解（C语言版）
热门推荐
qq_44075108的博客
09-27 2万+
本文介绍单链表的定义、常用操作、优化和使用的注意点等内容。
（萌新笔记）C语言的复习笔记（2）
CourserLi的博客
11-21 338
初始时间：大一（上） 11月 更新时间：大一（上） 11月 本文仅供有些C语言基础，想回顾知识点的伙伴阅读
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、...
使用C++实现单链表的基本操作：1、创建单链表2、遍历单链表3、单链表插入4、删除单链表5、判断是否为空6、单链表的
03-27
本文将详细阐述如何使用C++来实现单链表的基本操作，包括创建、遍历、插入、删除、判断空、计算长度以及查找节点。 首先，我们从创建单链表开始。单链表是由一系列节点组成的数据结构，每个节点包含一个数据元素和...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
用C语言实现单链表的各种操作(一)
12-25
例如，单链表的逆置，单链表的合并，找到单链表的中间节点等的算法实现。下面这个是单链表的结构体的定义： 代码如下:typedef struct LNode{ ElemType data; struct LNode *next;}LinkList;下面的基本的单链表的...
小甲鱼视频讲的单链表头插法例子的问题
qq_23304241的博客
03-01 428
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; struct Book { char title[128]; char author[40]; struct Book *next; }; void getInput(struct Book *book) { printf("请输入书名："...
彻底理解链表中为何使用二级指针或者一级指针的引用
踏莎行的博客
10-01 1万+
在用c/c++写数据结构程序时，链表和二叉树中经常需要用到二级指针或者一级指针的引用，那么什么时候用什么时候不用呢？ 先看一个简单的c++链表操作程序： （虽然风格有点像c，不过这个是cpp文件，不要在意这些细节） [cpp]view plaincopy /* code:Linklist author:tashaxing
c++图书编号与价格 链表的创建及显示
在风雨中奔跑
07-05 1400
#include using namespace std; class book //创建一个book类 { public: int num; double price; book *next; }; book *head=NULL;//将头节点赋值为空 book *creat()//创建链表函数 { book *p1,*p2;//p1指向新开辟的对象，p2指向后
单链表中插入元素之头插法
khq溪风的博客
04-06 3140
头插法 #include<stdio.h> #include<stdlib.h> #include<string.h> void getinput(struct Book *book); void addBook(struct Book **library); void printLibrary(struct Book *library); void rel...
C语言 多级指针 解引用
静沐暖阳的博客
05-21 1376
1.解引用int main() {int a = 10; int b = 20; printf("%d %d\n",a,b);//10 20int *p = &a;//p里保存a的地址 *p = 100;//对p解引用，将p指向的地址的内容赋为100 p = &b;//p指向b *p = 200;//将p指向的地址的内容赋为200 printf("%d %d\n",a,b);// 100 200i
（语法）理解链表：建立，插入
谦虚谨慎
03-25 1436
链表是将一个个独立的数据利用指针将他们链接起来，达到方便访问，调用的一个功能，下面通过一个小程序对链表进行分析： #include using namespace std; struct student //定义类型为student的一个结构体 { int id; char name[16]; student* next; }; student m_head = { 0 };
单链表的c++和c语言的写法（一）
就爱摆烂
03-28 478
单链表的c++和c语言的写法（一） 使用c++语法写一个单链表。 首先定义一个类，取名为LinkNode。 #include<iostream> using namespace std; typedef struct SListNode//结构体 { int data; SListNode* next; }SN,SListNode; class LinkNode { public: void SListNodeInit(); //初始化函数 void SListNodePrint
链表为什么有些情况下要使用二重指针
qq_39579087的博客
01-05 1725
链表 一个疑问 今天在复习链表时遇见了几个问题，其实是拖了很久的问题，现在尝试分析一下 结构体： typedef struct Node{ int data; struct Node *next; }Node; main() Node *list=NULL; CreatNode(list); printf("%d",list->data); Node * Cr...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值