链表使用操作

已于 2023-09-05 23:43:57 修改
阅读量249 收藏 2
点赞数
文章标签： 链表 数据结构
于 2023-09-05 23:33:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65871698/article/details/132701784
版权

1.链表常用函数

        1.malloc函数

        malloc函数在内存之中动态分配一块size大小的内存空间，它是为链表操作的基础。

        void *malloc(unsigned int size);

        2.calloc函数

        calloc函数用在内存中动态分配n个长度为size的连续空间。

        void *calloc(unsigned n,unsigned size);

        3.free函数

        free函数用来进行释放指针ptr指向的内存区域，使该部分内存可以被其它变量使用。

        void free(void *ptr);

        4.realloc函数

        realloc函数的功能将对应ptr指针指向的内存空间大小改为size；

        void *realloc(void *ptr,size_t size);

2.链表使用办法

1.头插法

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

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

// 创建新节点
struct Node* newNode(int data) 
{
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->next = NULL;
    return node;
}

// 在链表头部插入节点
void insertAtHead(struct Node** head, int data) 
{
    struct Node* newNode = createNode(data);
    newNode->next = *head;
    *head = newNode;
}

// 打印链表数据
void printList(struct Node* head) 
{
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

int main() {
    struct Node* head = NULL;

    // 在链表头部插入节点
    insertAtHead(&head, 3);
    insertAtHead(&head, 2);
    insertAtHead(&head, 1);

    printf("链表数据：");
    printList(head);

    return 0;
}

2.尾插法

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

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

// 创建新节点
struct Node* newNode(int data) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->next = NULL;
    return node;
}

// 在链表尾部插入节点
void insertAtTail(struct Node** head, int data) {
    struct Node* newNode = createNode(data);
    
    if (*head == NULL) {
        *head = newNode;
    } else {
        struct Node* temp = *head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}

// 打印链表数据
void printList(struct Node* head) {
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

int main() {
    struct Node* head = NULL;

    // 在链表尾部插入节点
    insertAtTail(&head, 1);
    insertAtTail(&head, 2);
    insertAtTail(&head, 3);

    printf("链表数据：");
    printList(head);

    return 0;
}

3.双向链表

双向链表（Doubly Linked List）是一种常见的链表数据结构，它与单向链表类似，但每个节点都有一个指向前一个节点的指针（prev），除了指向后一个节点的指针（next）。

双向链表中的每个节点包含三个部分：

  1. 数据（可以是任意类型的数据）。
  2. 指向前一个节点的指针（prev）。
  3. 指向后一个节点的指针（next）。

通过这两个指针，每个节点可以在链表中的前后移动。

相较于单向链表，双向链表的优点在于：

  1. 可以从任意方向遍历链表：由于每个节点都有一个指向前一个节点的指针，所以可以从头到尾或者从尾到头遍历链表。
  2. 删除操作更高效：删除节点时，不需要像单向链表那样找到待删除节点的前一个节点，而是直接更新前后节点的指针即可。

然而，双向链表的缺点是占用更多的内存空间，因为每个节点需要存储额外的指针。

双向链表提供了更灵活的操作，使得在某些场景下更为方便。例如，在需要频繁插入和删除节点的情况下，双向链表能够更高效地执行这些操作。

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

// 双向链表节点结构
struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
};

// 在链表头部插入节点
void insertAtHead(struct Node** head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->prev = NULL;
    
    if (*head != NULL) {
        (*head)->prev = newNode;
    }
    
    newNode->next = *head;
    *head = newNode;
}

// 在链表尾部插入节点
void insertAtTail(struct Node** head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    
    if (*head == NULL) {
        newNode->prev = NULL;
        *head = newNode;
        return;
    }
    
    struct Node* temp = *head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    
    temp->next = newNode;
    newNode->prev = temp;
}

// 打印链表数据（正向）
void printForward(struct Node* head) {
    struct Node* temp = head;
    printf("正向打印链表数据：");
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

// 打印链表数据（逆向）
void printBackward(struct Node* head) {
    struct Node* temp = head;
    if (temp == NULL) {
        return;
    }
    
    while (temp->next != NULL) {
        temp = temp->next;
    }
    
    printf("逆向打印链表数据：");
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->prev;
    }
    printf("\n");
}

int main() {
    struct Node* head = NULL;

    // 在链表头部插入节点
    insertAtHead(&head, 3);
    insertAtHead(&head, 2);
    insertAtHead(&head, 1);

    // 在链表尾部插入节点
    insertAtTail(&head, 4);
    insertAtTail(&head, 5);

    // 正向打印链表数据
    printForward(head);

    // 逆向打印链表数据
    printBackward(head);

    return 0;
}

举个函数学生信息的链表函数

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

struct student
{
    int num;
    char name[64];
    float score;
    struct student* pnext;
};
//全局定义
void input(void);//进行成绩的录入
void delect(void);//进行学生信息的删除
void revise(void);//进行学生信息的修改
void find(void);//进行学生信息的查找
void show(void);//显示学生信息
struct student *phead=NULL;//全局定义链表头函数

int main()
{
    int choice=0;
face:
    while(1)
    {
        printf("********学生管理系统********\n");
        printf("*****1.进行学生信息记录*****\n");
        printf("*****2.进行学生信息删除*****\n");
        printf("*****3.进行学生信息修改*****\n");
        printf("*****4.进行学生信息查找*****\n");
        printf("*****5.返回学生信息界面*****\n");
        printf("*****6.退出学生管理系统*****\n");
        printf("请输入您所需要进行的操作\n");
        scanf("%d",&choice);
        if((choice>0&&choice<7)||(choice=99))
        {
            if(choice==1)
            {
                input();//记录
            }
            else if(choice==2)
            {
                delect();//删除
            }
            else if(choice==3)
            {
                revise();//选择
            }
            else if(choice==4)
            {
                find();//查找
            }
            else if(choice==5)
            {
                printf("正在返回学生主界面......\n");
                goto face;
            }
            else if(choice==6)
            {
                printf("正在退出学生信息管理系统......\n");
                goto over;
            }
            else if(choice==99)
            {
                show();
            }
        }
        else
        {
            printf("您所输入的数字不合规则\n");
            goto face;
        }
    }
over:
    printf("谢谢使用\n");
}
void input(void)//进行成绩的录入
{
    struct student *pnew=NULL;
    struct student *ptemp=phead;
    pnew=(struct student*)malloc(sizeof(struct student));//给新录入的数开辟空间
    pnew->pnext=NULL;
    printf("学号\n");
     scanf("%d",&pnew->num);
    printf("姓名\n");
     scanf("%s",pnew->name);
    printf("成绩\n");
     scanf("%f",&pnew->score);
    if(phead==NULL)
    {
        phead=pnew;
    }
    else
    {
        while(ptemp->pnext!=NULL)
        {
            ptemp=ptemp->pnext;
        }
        ptemp->pnext=pnew;
    }
    return;
}
void delect(void)//进行学生信息的删除
{
    int num1=0;
    struct student *ptemp=phead;
    struct student *pdel=NULL;
    printf("请输入您所需要进行删除的学号\n");
    scanf("%d",&num1);
    if (phead==NULL)
    {
        printf("该空间并不存在该学生\n");
        return;
    }
    if (ptemp->num==num1)//判定第一个节点是否为要进行删除的节点
    {
        pdel=phead;
        phead=phead->pnext;
        free(pdel);
        printf("已经删除了对应学号的学生\n");
        return ;
    }
    while(ptemp->pnext!=NULL)//如果不是第一个节点
    {
        if(ptemp->pnext->num==num1)
        {
            pdel=ptemp->pnext;
            ptemp->pnext=ptemp->pnext->pnext;
            free(pdel);
            printf("已经删除了对应学号的学生\n");
            return ; 
        }
        ptemp=ptemp->pnext;
    }
    printf("查无此人\n");
}
void revise(void)//进行学生信息的修改
{
    int num1;
    struct student *pnew=phead;
    printf("正在进行修改中......\n");
    printf("请输入您想所需要进行修改的学生学号\n");
    scanf("%d",&num1);
    while(pnew!=NULL)
    {
        if(pnew->num==num1)
        {
        printf("请输入您所需要进行修改的信息\n");
        printf("学号\n");
        scanf("%d",&pnew->num);
        printf("姓名\n");
        scanf("%s",pnew->name);
        printf("成绩\n");
        scanf("%f",&pnew->score);
        printf("修改成功\n");
        break;
        }
        pnew=pnew->pnext;
    }
    if (pnew=NULL)
    {
        printf("未查到需要修改的学生\n");
    }
} 
void find(void)//进行学生信息的查找
{
    int num1;
    struct student *pfind=phead;
    printf("正在进行查找中......\n");
    printf("请输入您想所需要进行查找的学生学号\n");
    scanf("%d",&num1);
    while(pfind!=NULL)
    {
        if(pfind->num==num1)
        {
        printf("学号\t姓名\t成绩\n");
        printf("%d\t",pfind->num);
        printf("%s\t",pfind->name);
        printf("%.2f\n",pfind->score);
        break;
        }
        pfind=pfind->pnext;
    }
    if (pfind=NULL)
    {
        printf("未查到该学生\n");
    }
}
void show(void)//显示学生信息
{
    struct student *ptemp=NULL;//进行中间变量的定义
    int ilndex=0;
    printf("*****所有学生信息如下*****\n");
    printf("\n");
    printf("学号\t姓名\t成绩\n");
    ptemp=phead;

    while(ptemp!=NULL)
    {
        printf("%d\t",ptemp->num);
        printf("%s\t",ptemp->name);
        printf("%.2f\n",ptemp->score);
        ptemp=ptemp->pnext;
        ilndex++;
    }
    printf("一共录入了%d个同学\n",ilndex);
}
许方平
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
使用python实现链表操作
09-20
本文将详细介绍如何使用Python来实现链表的操作，包括单链表和双链表。 一、链表概念 链表由一系列节点构成，每个节点包含数据和指向下一个节点的引用。在Python中，我们可以通过定义一个类来模拟这种结构。单链表...
链表基本操作（详解）
Czc1357618897的博客
11-30 1万+
链表的基本操作 这里写目录标题链表的基本操作一：单链表的基础知识二：单链表的建立头插法尾插法三：单链表的遍历四：单链表结点数目判断五：单链表的插入链表头插入任意结点插入链表尾部插入六：单链表的删除七 ：单链表的查询 一：单链表的基础知识 为什么需要链表？ 我们在使用数组存放数据是非常方便，但是由于数组的长度是固定的，所以当存储不同的元素数量时，就很容易出现问题。如果向数组中添加的数量大于数组大小时候，信息无法完全被保存。所以我们需要另一种存储方式来存储数据，其中存储的元素的个数不受限制。这种存储方式就是链
【数据结构】链表的十三种操作
littlegengjie的博客
10-25 1258
双向链表链表的初始化、销毁、清空、链表长度、求双向链表前驱、后继、遍历链表，头插法输入链表、双向链表逆序存放。
【c 语言 】malloc函数详解
最新发布
m0_74195174的博客
03-29 3264
本文将详细解析malloc函数的功能、工作步骤、语法、使用方法以及注意事项，帮助读者更好地理解和应用这一强大的内存管理工具
链表的基本操作
eminemi的博客
07-13 7215
链表的基本操作包括建立（批量存入数据）、打印（输出所有数据）、删除（在批量数据中删除指定数据）、插入（在批量数据中添加一个数据）等。
通讯录（单链表的操作方法）
weixin_63032791的博客
01-05 3551
发现大部分的文章对于链表的基本方法讲述很模糊，今天我为大家根据这个“通讯录”仔细讲解一下链表的的操作。 第一步:定义头文件 #include<stdio.h> #include<stdlib.h> #include<io.h> #include<windows.h> //清屏操作 #include<malloc.h> //动态分配内存 第二步:定义结构体指针变量 typedef struct N
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 16万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
PHP链表操作简单示例
01-20
本文实例讲述了PHP链表操作。分享给大家供大家参考，具体如下： 在php中运行数据结构，基本都是用数组模拟的，只是用一直思想而已。 今天遇到的这个问题是，两个链表进行合并。 链表合并效果图 问题描述：A链表是...
python如何对链表操作
12-16
链表 链表(linked list)是由一组被称为结点的数据元素组成的数据结构，每个结点都包含结点本身的信息和指向下一个结点的地址。 由于每个结点都包含了可以链接起来的地址信息，所以用一个变量就能够访问整个结点序列...
C语言链表操作
10-10
C语言链表操作，新手强烈推荐必看内容，不看会后悔。。。
【数据结构-链表】链表的基本操作
Mount256的博客
10-26 1752
【数据结构-链表】链表的基本操作
数据结构之链表的基本操作
qq_62617615的博客
03-15 671
指针域的next类型是struct node*(指向struct node类型的指针类型)，因为next要只想下一个结点（struct node 类型）在上述程序段中，有意的对代码进行简化，再用定义变量（即静态内存分配）的方式创建链表结点。访问连表示总是从第一个开始顺序访问，因此需要定义一个专门的指针，用于指向链表的第一个结点，并称之为头指针。例1，创建一个包含3个结点的简单链表，每个节点包含一个整形数据成员和一个指针成员。然后，依次在链表结点的数据域中存入数据，并通过指针域将链表结点连接起来。
【数据结构】链表的基本操作
m0_53171456的博客
03-11 8248
规划 /* 链表的基本操作 */ #include<iostream> #include<algorithm> #define ElemType int using namespace std; typedef struct LNode{ ElemType data; //数据域 LNode *next; //指针域 } *LinkList; //链表的初始化 void IniteList(LinkList &L){ L = new LNode; //创建头结点
链表操作的几个高效技巧
weixin_30902675的博客
05-29 189
针对leetcode上面的20多个链表的算法题，总结了一下链表操作中的几个技巧。 1. 快慢指针 快慢指针是在遍历链表的时候使用两个指针，快指针每次比慢指针多跑一步或多步，或者快指针先跑n步。这在查找倒数第n个结点、找中间结点时只需要遍历一次，在判断链表是否有环时不需要额外的空间。例如，查找一个链表中间结点， ListNode * findMid(ListNode * head) { ...
数据结构之链表操作（单链表，单向循环链表，双向循环链表）查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等操作
qq_45698138的博客
05-16 2029
一、线性表 线性表结构的数据是依次排列（一对一） （1）顺序结构：数组，顺序栈，顺序队列（顺序表） （2）链式存储：链表，链式栈，链式队列（线性表） 二、链表 2.1、链表 ​ 链表是一种具体的数据结构 ​ 1、逻辑上：一对一的排列 ​ 2、存储上：非连续的 ​ 3、算法：查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等等 ​ 4、链表分类 ​ 单向链表，双向链表，单向循环链表，双向循环链表 ​ 5、链式存储特点 ​ 不需要一块连续
malloc函数用法
李楠的IT博客
03-19 4万+
1、函数声明 void *malloc(int size); 说明：malloc向系统申请分配size字节的内存空间，返回类型为void*类型。 2、使用 int *p; p = (int *)malloc( sizeof(int) ); 注意： （1）因为malloc返回的是不确定类型的指针，所以返回之前必须经过类型强制转换，否则编译报错，如：“ 不能将void*赋值给int*变量
链表节点的创建，优先使用malloc
GodNotAMen的博客
03-09 2124
1、链表节点的动态分配 在用一条打印语句打印链表节点值时，发现链表节点的信息发生了改变，见下图： 后来才知道在这之前调用了一个插入节点的函数Insert，这个节点的创建方式是直接通过LNode node;来创建的，这样做的结果是节点node为局部变量，当函数Insert结束后这个节点所在的空间将被释放。 但由于这片空间还没有被再次利用，所以在打印语句之前看上去一切正常，知道执行打印语句时这片空间被打印语句当作缓冲区被利用，此时内存地址中的值发生改变，也就发生了图二的情况。 2、链表节点的释放 如图所示，
链表的操作
05-25
链表是一种常见的线性数据结构，它由一系列节点组成，每个节点都包含一个数据元素和一个指向下一个节点的指针。...需要注意的是，在进行链表操作时，一定要注意指针的变化，以避免出现空指针异常等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值