C语言中数据结构——单链表

最新推荐文章于 2023-11-05 17:45:41 发布
最新推荐文章于 2023-11-05 17:45:41 发布
阅读量669 收藏 9
点赞数 6
分类专栏： c实用性文章 数据结构 文章标签： 数据结构 c语言 开发语言 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67846057/article/details/130276752
版权

🐶博主主页：@ᰔᩚ. 一怀明月ꦿ 

❤️‍🔥专栏系列：线性代数，C初学者入门训练，题解C，C的使用文章，「初学」C++

🔥座右铭：“不要等到什么都没有了，才下定决心去做”

🚀🚀🚀大家觉不错的话，就恳求大家点点关注，点点小爱心，指点指点🚀🚀🚀

目录

🐰单链表

🏡单链表的定义

🏡单链表的打印

🏡单链表的创建节点

🏡单链表的头插

🏡单链表的尾插

🏡单链表的尾删

🏡单链表的头删

🏡单链表的查找

🏡单链表的改动

🏡单链表的元素个数

🏡单链表的任意位置插入元素

单链表的任意位置删除元素

🏡单链表的销毁

🏡单链表中的源码

🌸main文件

🌸头文件test.h

🌸test.c文件

🐰单链表

🏡单链表的定义

typedef int SLTDataType;
typedef struct SListNode
{
    SLTDataType data;
    struct SListNode* next;//next存放的下一个节点的地址
}SLT;

🏡单链表的打印

依次打印链表中的数据

void SLTprintf(SLT* phead)
{
    SLT* cur=phead;
    while(cur!=NULL)
    {
        printf("%d ",cur->data);
        cur=cur->next;
    }
    printf("\n");
}

🏡单链表的创建节点

动态开辟一个空间，然后返回这个空间的地址，即动态开辟的节点

SLT* Buylistnode(int x)
{
    SLT* newnode=(SLT*)malloc(sizeof(SLT));
    if(newnode==NULL)
    {
        perror("malloc fail");
        return 0;
    }
    newnode->data=x;
    newnode->next=NULL;
    return newnode;
}

🏡单链表的头插

复用了动态创建节点

void SLTPushFront(SLT** pphead,SLTDataType x)
{
    SLT* newnode= Buylistnode(x);
    newnode->next=*pphead;
    *pphead=newnode;
}

🏡单链表的尾插

注意一个节点和多个节点时

void SLTPushBack(SLT** pphead,SLTDataType x)
{
    SLT* newnode=Buylistnode(x);
    if(*pphead==NULL)//当为空链表时
    {
        *pphead=newnode;
    }
    else
    {
        SLT* tail=*pphead;
        while(tail->next)
        {
            tail=tail->next;
        }
        tail->next=newnode;
    }
}

🏡单链表的尾删

这两种方法的本质都是找到倒数第二个节点

第一种尾删的方法

注意一个节点和多个节点时


void SLTPopBack(SLT** pphead)
{
    assert(*pphead);
    SLT* prev=NULL;
    SLT* tail=*pphead;
    if(tail->next==NULL)
    {
        free(tail);
        *pphead=NULL;
    }
    else
    {
        while(tail->next)
        {
            prev=tail;
            tail=tail->next;
        }
        free(tail);
        prev->next=NULL;
    }
}

第二种尾删的方法

注意一个节点和多个节点时

void SLTPopBack(SLT** pphead)
{
    assert(*pphead);
    SLT* tail=*pphead;
    if(tail->next==NULL)//只有一个节点
    {
        free(tail);
        *pphead=NULL;
    }
    else//有多个节点
    {
        while(tail->next->next)//这也是找到倒数第二个节点
        {
            tail=tail->next;
        }
        free(tail->next);
        tail->next=NULL;
    }
}

🏡单链表的头删

注意一个节点和多个节点时

void SLTPopFront(SLT** pphead)
{
    assert(*pphead);
    SLT* tail=*pphead;
    if(tail->next==NULL)//一个节点
    {
        free(tail);
        *pphead=NULL;
    }
    else//多个节点
    {
        tail=tail->next;
        free(*pphead);
        *pphead=tail;
    }
}

🏡单链表的查找

（找到了，就返回所在的位置，没找到返回-1）

int SLTFind(SLT** pphead,SLTDataType x)
{
    assert(*pphead);
    SLT* try_b=*pphead;
    int Count=1;
    while(try_b->next)
    {
        if(try_b->data==x)
        {
            return Count;
        }
        Count++;
        try_b=try_b->next;
    }
    return  -1;
}

🏡单链表的改动

需要给出改动的位置以及要改动的值

void SLTChange(SLT** pphead,int pos,SLTDataType x)
{
    assert(*pphead);
    int Count=Totalsize(pphead);
    assert(pos<=Count);
    SLT* tail=*pphead;
    while(pos--)
    {
        tail=tail->next;
    }
    tail->data=x;
}

🏡单链表的元素个数

计算链表的元素个数，然后返回个数

int Totalsize(SLT** pphead)
{
    SLT* tail=*pphead;
    int Count=0;
    while(tail)
    {
        tail=tail->next;
        Count++;
    }
    return Count;
}

🏡单链表的任意位置插入元素

需要给出插入的位置以及要插入的值（说明一下，这里是插入元素的位置的后面），插入的位置一定要合法

void SLTInsertAfter(SLT** pphead,int pos, SLTDataType x)
{
    assert(pos<=Count);
    if((*pphead)==NULL)
    {
        SLTPushFront(pphead, x);
    }
    else
    {
        SLT* prev=NULL;
        SLT* tail=*pphead;
        while(pos--)
        {
            prev=tail;
            tail=tail->next;
        }
        SLT* newnode=Buylistnode(x);
        prev->next=newnode;
        newnode->next=tail;
    }
}

单链表的任意位置删除元素

删除的位置一定要合法

void SLTEraseAfter(SLT** pphead,int pos)
{
    assert(*pphead);
    assert(pos<=Count-1);
   if((*pphead)->next==NULL)
   {
       SLTPopFront(pphead);
   }
    else
    {
        SLT* prev=NULL;
        SLT* taillater=NULL;
        SLT* tail=*pphead;
        while(pos--)
        {
            prev=tail;
            tail=tail->next;
        }
        taillater=tail->next;
        free(tail);
        tail=NULL;
        prev->next=taillater;
    }
}

🏡单链表的销毁

void SLTDestroy(SLT** pphead)
{
    free(*pphead);
    *pphead=NULL;
}

🏡单链表中的源码

为方便调试单链表，这里没有使用了菜单

🌸main文件

#include"test.h"
void test1(void)
{
    SLT* plist=NULL;
    SLTPushFront(&plist, 1);
    SLTPushFront(&plist, 2);
    SLTPushFront(&plist, 3);
    SLTPushFront(&plist, 4);
    SLTprintf(plist);
    printf("\n");
    SLTPushBack(&plist, 4);
    SLTPushBack(&plist, 3);
    SLTPushBack(&plist, 2);
    SLTPushBack(&plist, 1);
    SLTprintf(plist);
}
void test2(void)
{
    SLT* plist=NULL;
    SLTPushFront(&plist, 1);
    SLTPushFront(&plist, 2);
    SLTPushFront(&plist, 3);
    SLTPushFront(&plist, 4);
    SLTPushBack(&plist, 4);
    SLTPushBack(&plist, 3);
    SLTPushBack(&plist, 2);
    SLTPushBack(&plist, 1);
    SLTprintf(plist);
//    SLTPopBack(&plist);
//    SLTPopBack(&plist);
//    SLTPopBack(&plist);
//    SLTPopBack(&plist);
//    SLTPopBack(&plist);
//    SLTPopBack(&plist);
//    SLTPopBack(&plist);
//    SLTprintf(plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTprintf(plist);
}
void test3(void)
{
    SLT* plist=NULL;
    SLTPushFront(&plist, 1);
    SLTPushFront(&plist, 2);
    SLTPushFront(&plist, 3);
    SLTPushFront(&plist, 4);
    SLTPushBack(&plist, 4);
    SLTPushBack(&plist, 3);
    SLTPushBack(&plist, 2);
    SLTPushBack(&plist, 1);
    SLTprintf(plist);
    int ret=SLTFind(&plist,4);
    printf("position is('-1'is not find)：%d\n",ret);
}
void test4(void)
{
    SLT* plist=NULL;
    SLTPushFront(&plist, 1);
    SLTPushFront(&plist, 2);
    SLTPushFront(&plist, 3);
    SLTPushFront(&plist, 4);
    SLTPushBack(&plist, 4);
    SLTPushBack(&plist, 3);
    SLTPushBack(&plist, 2);
    SLTPushBack(&plist, 1);
    SLTprintf(plist);
    SLTChange(&plist, 23, 100);
    SLTprintf(plist);
}
void test5(void)
{
    SLT* plist=NULL;
    SLTPushFront(&plist, 1);
    SLTPushFront(&plist, 2);
    SLTPushFront(&plist, 3);
    SLTPushFront(&plist, 4);
    SLTPushBack(&plist, 4);
    SLTPushBack(&plist, 3);
    SLTPushBack(&plist, 2);
    SLTPushBack(&plist, 1);
    SLTprintf(plist);
    int ret=Totalsize(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTPopFront(&plist);
    SLTprintf(plist);
    ret=Totalsize(&plist);
    printf("total is :%d\n",ret);
}
void test6(void)
{
    SLT* plist=NULL;
 //   SLTPushFront(&plist, 1);
//    SLTPushFront(&plist, 2);
//    SLTPushFront(&plist, 3);
//    SLTPushFront(&plist, 4);
//    SLTPushBack(&plist, 4);
//    SLTPushBack(&plist, 3);
//    SLTPushBack(&plist, 2);
//    SLTPushBack(&plist, 1);
    SLTprintf(plist);
    SLTInsertAfter(&plist, 1, 100);
    SLTprintf(plist);
}
void test7(void)
{
    SLT* plist=NULL;
    SLTPushFront(&plist, 1);
//    SLTPushFront(&plist, 2);
//    SLTPushFront(&plist, 3);
//    SLTPushFront(&plist, 4);
//    SLTPushBack(&plist, 4);
//    SLTPushBack(&plist, 3);
//    SLTPushBack(&plist, 2);
//    SLTPushBack(&plist, 1);
    SLTprintf(plist);
    SLTEraseAfter(&plist, 1);
    SLTprintf(plist);
}
void test8(void)
{
    SLT* plist=NULL;
    SLTPushFront(&plist, 1);
    SLTPushFront(&plist, 2);
    SLTPushFront(&plist, 3);
    SLTPushFront(&plist, 4);
    SLTPushBack(&plist, 4);
    SLTPushBack(&plist, 3);
    SLTPushBack(&plist, 2);
    SLTPushBack(&plist, 1);
    SLTprintf(plist);
    SLTDestroy(&plist);
    SLTprintf(plist);
}
int main()
{
    //test1();//完成头插尾插
    //test2();//完成尾删
    //test3();//查找
    //test4();//改动
    //test5();//判断链表有多少个元素
    // test6();//任意插入元素
    //test7();//任意删除元素
    test8();//销毁链表
}

🌸头文件test.h

#ifndef test_h
#define test_h
#include <stdio.h>
#endif /* test_h */
#include<stdlib.h>
#include<assert.h>

typedef int SLTDataType;
typedef struct SListNode
{
    SLTDataType data;
    struct SListNode* next;//next存放的下一个节点的地址
}SLT;

//单链表的打印
void SLTprintf(SLT* phead);
//单链表的头插
void SLTPushFront(SLT** pphead,SLTDataType x);
//单链表的尾插
void SLTPushBack(SLT** pphead,SLTDataType x);
//单链表的尾删
void SLTPopBack(SLT** pphead);
//单链表的头删
void SLTPopFront(SLT** pphead);
//单链表的查找（找到了，就返回所在的位置，没找到返回-1）
int SLTFind(SLT** pphead,SLTDataType x);
//单链表的改动（改变给出位置的值）
void SLTChange(SLT** pphead,int pos,SLTDataType x);
//单链表的元素个数
int Totalsize(SLT** pphead);
//单链表的任意位置插入元素
void SLTInsertAfter(SLT** pphead,int pos, SLTDataType x);
//单链表的任意位置删除元素
void SLTEraseAfter(SLT** pphead,int pos);
//单链表的销毁
void SLTDestroy(SLT** pphead);

🌸test.c文件

#include "test.h"

void SLTprintf(SLT* phead)
{
    SLT* cur=phead;
    while(cur!=NULL)
    {
        printf("%d ",cur->data);
        cur=cur->next;
    }
    printf("\n");
}
SLT* Buylistnode(int x)
{
    SLT* newnode=(SLT*)malloc(sizeof(SLT));
    if(newnode==NULL)
    {
        perror("malloc fail");
        return 0;
    }
    newnode->data=x;
    newnode->next=NULL;
    return newnode;
}
void SLTPushFront(SLT** pphead,SLTDataType x)
{
    SLT* newnode= Buylistnode(x);
    newnode->next=*pphead;
    *pphead=newnode;
}
void SLTPushBack(SLT** pphead,SLTDataType x)
{
    SLT* newnode=Buylistnode(x);
    if(*pphead==NULL)
    {
        *pphead=newnode;
    }
    else
    {
        SLT* tail=*pphead;
        while(tail->next)
        {
            tail=tail->next;
        }
        tail->next=newnode;
    }
}
//这两种方法的本质都是找到倒数第二个节点
//第一种尾删的方法
void SLTPopBack(SLT** pphead)
{
    assert(*pphead);
    SLT* prev=NULL;
    SLT* tail=*pphead;
    if(tail->next==NULL)
    {
        free(tail);
        *pphead=NULL;
    }
    else
    {
        while(tail->next)
        {
            prev=tail;
            tail=tail->next;
        }
        free(tail);
        prev->next=NULL;
    }
}
//第二种尾删的方法
//void SLTPopBack(SLT** pphead)
//{
//    assert(*pphead);
//    SLT* tail=*pphead;
//    if(tail->next==NULL)//只有一个节点
//    {
//        free(tail);
//        *pphead=NULL;
//    }
//    else//有多个节点
//    {
//        while(tail->next->next)//这也是找到倒数第二个节点
//        {
//            tail=tail->next;
//        }
//        free(tail->next);
//        tail->next=NULL;
//    }
//}



void SLTPopFront(SLT** pphead)
{
    assert(*pphead);
    SLT* tail=*pphead;
    if(tail->next==NULL)//一个节点
    {
        free(tail);
        *pphead=NULL;
    }
    else//多个节点
    {
        tail=tail->next;
        free(*pphead);
        *pphead=tail;
    }
}

int SLTFind(SLT** pphead,SLTDataType x)
{
    assert(*pphead);
    SLT* try_b=*pphead;
    int Count=1;
    while(try_b->next)
    {
        if(try_b->data==x)
        {
            return Count;
        }
        Count++;
        try_b=try_b->next;
    }
    return  -1;
}
int Totalsize(SLT** pphead)
{
    SLT* tail=*pphead;
    int Count=0;
    while(tail)
    {
        tail=tail->next;
        Count++;
    }
    return Count;
}
void SLTChange(SLT** pphead,int pos,SLTDataType x)
{
    assert(*pphead);
    int Count=Totalsize(pphead);
    assert(pos<=Count);
    SLT* tail=*pphead;
    while(pos--)
    {
        tail=tail->next;
    }
    tail->data=x;
}

void SLTInsertAfter(SLT** pphead,int pos, SLTDataType x)
{
    if((*pphead)==NULL)
    {
        SLTPushFront(pphead, x);
    }
    else
    {
        SLT* prev=NULL;
        SLT* tail=*pphead;
        while(pos--)
        {
            prev=tail;
            tail=tail->next;
        }
        SLT* newnode=Buylistnode(x);
        prev->next=newnode;
        newnode->next=tail;
    }
}

void SLTEraseAfter(SLT** pphead,int pos)
{
    assert(*pphead);
   if((*pphead)->next==NULL)
   {
       SLTPopFront(pphead);
   }
    else
    {
        SLT* prev=NULL;
        SLT* taillater=NULL;
        SLT* tail=*pphead;
        while(pos--)
        {
            prev=tail;
            tail=tail->next;
        }
        taillater=tail->next;
        free(tail);
        tail=NULL;
        prev->next=taillater;
    }
}

void SLTDestroy(SLT** pphead)
{
    free(*pphead);
    *pphead=NULL;
}

 🌸🌸🌸如果大家还有不懂或者建议都可以发在评论区，我们共同探讨，共同学习，共同进步。谢谢大家！ 🌸🌸🌸 

ᰔᩚ. 一怀明月ꦿ
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
数据结构c语言版单链表的创建和输出
06-08
（1）键盘输入n，建立长度为n的单链表并输出； （2）键盘输入x。在单链表中查找值为x的结点并删除，最后输出链表。
C语言实现单链表及其打印
mastershooter的博客
09-24 909
（比如第一个空间地址是A，第二个是B，第三个是C，第四个是D，那么第一个空间的指针是第二个空间的地址，第二个空间的指针是第三个空间的地址，以此类推）单链表与顺序表的不同之处就是：单链表并不会和顺序表一样有对应的下标，单链表的每个空间的地址是不连续的，但是每个空间都会有一个指针指向下一个空间，所以从空间来说是连续的。由上图可看见，n1->next是存有n2的地址，n2->next是存有n3的地址，而最后一个n4->next是指向空，此时说明我们的单链表创建成功了。当然是赋NULL，空指针。
输出一个有序单链表
weixin_44588315的博客
06-28 943
一、单链表 单链表，就是线性表的链式存储结构，又称线性链表。 它的特点是：用一组任意的存储单元存储线性表的数据元素，即结点之间在逻辑上是连续的，在物理上是不连续的。 单链表是带有头结点的，头节点只起到“哨兵”的作用，它的数据域是不使用的，指针域指向第一个数据域的位置。 以下代码是单链表各个结点的逻辑表示：data是节点的数据域，next是指针域——存储下一个结点的地址。 struct list ...
输出单链表c语言代码,用C语言实现单链表的各种操作
weixin_35473679的博客
05-21 2416
2013本篇文章是对用C语言实现单链表的各种操作进行了详细的分析介绍，需要的朋友参考下最近，从新复习了一下数据结构中比较重要的几个部分，现在把自己的成果记录下来，主要就是仿照严蔚敏的《数据结构》(C 语言版)，中的例子和后面的习题进行改编的。首先，是单链表的各种实现，其中，包含了一些常考的知识点。例如，单链表的逆置，单链表的合并，找到单链表的中间节点等的算法实现。下面这个是单链表的结构体的定义：t...
创建一个单链表，并输出单链表（C++）
t18438605018的博客
09-14 7201
1.题目要求 创建一个带头结点的单链表，并打印输出链表的值 分析：首先要搞清楚什么是头结点，正常情况下一个单链表是不带头结点的。为了对单链表插入或删除操作的方便，特意引入了头结点。头结点指向链表中第一个结点。 如图所示，展示了“不带头结点的单链表”和“带头结点的单链表”。两者比较，“带头结点的单链表”实际上就在“不带头结点的单链表”前增加了一个结点。这个可以有数据域（比如存储表长等），也可以数据域中不存储东西，但它的指针域一定指向单链表的第一个元素。 2.代码 #include<iostream&g
数据结构——单链表.zip
09-16
本资料包"数据结构——单链表.zip"专注于单链表的实现，特别针对严蔚敏教授的数据结构教材内容进行了完整的编程实现。下面，我们将深入探讨单链表及其相关操作。 单链表是一种线性数据结构，每个元素称为节点，每个...
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
数据结构——基于C语言实现单链表的应用.rar
08-11
在这个主题中，我们专注于一个特定的数据结构——单链表，并讨论其在C语言中的实现。单链表是一种线性数据结构，其中每个元素（称为节点）包含两个部分：数据域，用于存储实际信息，以及指针域，指向链表中的下一个...
数据结构——单链表的具体操作
12-22
素在单链表中的位置。　 ① 输入的形式和输入值的范围：插入元素时需要输入插入的位置和元 素的值；删除元素时输入删除元素的位置；查找操作时需要输入元 素的值。在所有输入中，元素的值都是整数　 ② 输出的...
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
数据结构——单链表的输出——我的学习之路
qq_43923446的博客
04-17 4033
#include using namespace std; typedef struct node{ int data; struct node *next; }node,*linklist; node *Create()//链表创建函数 { linklist head,p,tail; cout<<“请输入链表数据，以0结束！！！”<<endl; head=p=tail=n...
创建单链表并输出单链表
图灵动力的博客
07-19 5876
创建一个单链表并输出单链表 ①基本思路： 定义一个结构体，包含数据域和指针域，前者为该结点保存的用户数据，后者为该结点保存的下一个相邻结点的地址。 定义一个结点创建函数(返回head)，用head指向第一个结点、p1开辟新节点、p2连接新节点。 定义一个结点输出函数，用do…while形式依次打印出每一个结构体成员数据域。 在main()函数中，依次调用上述函数。 ②源代码： /* 创建一个单链表，每个结点包含三个元素，学生编号、分数、保存下一个节点地址的指针 */ #include <stdio
单链表的建立与输出
Jason
12-05 2341
1 #include 2 #include 3 #define LEN sizeof(struct node) 4 typedef struct node* Node; 5 struct node 6 { 7 int num; 8 struct node *next; 9 }; 10 11 int n = 0; 12 //创建单链表 13
单链表创建和输出（简单使用）
Miraitowup的博客
01-27 6644
单链表创建和输出（简单使用） 代码实现 #include<stdio.h> typedef struct Lnode{ int data; struct Lnode*next; }Lnode,*LinkList; //尾插法 void Greate(LinkList &L,int n) { L=new Lnode; //创建头节点 L->next=NULL; LinkList r; r=L; printf("请依次输入各元素\n"); for(int i
上机二——单链表
最新发布
m0_75017568的博客
11-05 106
【问题描述】已知某带头结点的单链表中存放着若干整数，请删除该单链表中元素在[x, y]之间的所有结点，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。【输入形式】三行，第一行：两个有序链表中元素的个数，第二行：第一个链表中的元素以空格间隔，第三行：第二个链表中的元素以空格间隔。【输入形式】三行，第一行：两个有序链表中元素的个数，第二行：第一个链表中的元素以空格间隔，第三行：第二个链表中的元素以空格间隔。第二行：单链表中元素的个数。【输出形式】合并后的没有重复元素的有序链表中的数据以空格间隔。
【C语言】单链表的初始化，创建和输出
m0_60511809的博客
11-20 7005
链表主要分为四种：单向链表，双向链表，单向循环链表，双向循环链表。这里的单链表默认为单项非循环链表。 要确定一个数组，需要知道两个参数，一个是数组名，即数组首元素地址，另一个是数组元素个数。而要确定一个单链表，只需要知道头指针，因为头指针指向头结点，头结点存放首结点的地址，首结点存放下一个结点的地址，······，直到最后一个结点。 所以单链表的初始化就是创建一个头指针，指向头结点，而头结点的指针域为空，表示空单链表。 单链表的创建可以分...
单链表的实现代码
m0_51469347的博客
10-06 775
#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <stdlib.h> #include <time.h> // 定义 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; // 定义结点结构 typedef struct Node {
头插法进行单链表的创建并输出随机数
joie_de_的博客
12-06 534
这里用头插法进行链表的创建 千万不要忘记初始化链表，不然有可能会出错 #include<stdio.h> #include<stdlib.h> #include<time.h> typedef struct LNode { int data; struct LNode *next; } Link,*LinkList; //初始化单链表 int InitList(LinkList *L) { *L = (LinkList)malloc(sizeof(L...
链表值打印
donglindonglin的博客
06-16 779
题目描述 输入一个链表，从尾到头打印链表每个节点的值。 题目不难，有几个点要注意：      代码思路借助栈，遍历的时候入栈，由于数据结构中栈的特点是先进后出，所以遍历的过程中压栈，推栈，完了弹栈加到ArrayList中。      有两个容易出错的地方：                 第一，第一次测试用例，{}返回[ ],null是null，而[ ]是new Ar
《数据结构》C语言版讲义——严蔚敏配套
"严蔚敏教授的数据结构讲义，用C语言描述，适用于计算机专业基础学习，包含习题和解答，强调理解和实践" 严蔚敏教授的《数据结构》讲义是计算机科学教育中的经典参考资料，主要面向计算机专业的学生和准备各类...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值