精华内容
下载资源
问答
  • 输出描述:可能有多组测试数据,对于每组数据,将n个整数建立升序链表,之后遍历链表并输出。输入例子:43 5 7 9输出例子:3 5 7 9AC code:#include#include#include#include#include#include#...

    题目描述

    建立一个升序链表并遍历输出。

    输入描述:

    输入的每个案例中第一行包括1个整数:n(1<=n<=1000),接下来的一行包括n个整数。

    输出描述:

    可能有多组测试数据,对于每组数据,

    将n个整数建立升序链表,之后遍历链表并输出。

    输入例子:

    4

    3 5 7 9

    输出例子:

    3 5 7 9

    AC code:

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #define LL long long

    #define exp 1e-9

    #define MAXN 1000010

    using namespace std;

    typedef struct LNode{

    int data;

    LNode *next;

    }LNode;

    int main()

    {

    //freopen("D:\\in.txt","r",stdin);

    int i,n;

    while(scanf("%d",&n)!=EOF)

    {

    LNode *head,*p,*pre,*newNode;

    head = (LNode *)malloc(sizeof(LNode));

    head->next=NULL;

    for(i=1;i<=n;i++)

    {

    newNode = (LNode *)malloc(sizeof(newNode));

    scanf("%d",&newNode->data);

    p=head->next;

    pre=head;

    while(p)

    {

    if(p->data>newNode->data)

    {

    break;

    }

    else

    {

    pre=p;

    p=p->next;

    }

    }

    newNode->next=p;

    pre->next=newNode;

    }

    p=head->next;

    printf("%d",p->data);

    p=p->next;

    while(p)

    {

    printf(" %d",p->data);

    p=p->next;

    }

    puts("");

    }

    return 0;

    }

    展开全文
  • 最近临近期末的C语言课程设计比平时练习作业一下难了不止一个档次,第一次接触到了C语言的框架开发,了解了View(界面层)、... 本篇文章在于巩固链表的基础知识(整理自《C语言程序设计教程--人民邮电出版社》第十...

      最近临近期末的C语言课程设计比平时练习作业一下难了不止一个档次,第一次接触到了C语言的框架开发,了解了View(界面层)、Service(业务逻辑层)、Persistence(持久化层)的分离和耦合,一种面向过程的MVC的感觉。

      而这一切的基础就在于对链表的创建、删除、输出、写入文件、从文件读出......

      本篇文章在于巩固链表的基础知识(整理自《C语言程序设计教程--人民邮电出版社》第十章——指针与链表),只对链表的概念及增删改查作出探讨,欢迎指教。

      一、链表结构和静态/动态链表

      二、单链表的建立与遍历

      三、单链表的插入与删除

      四、双向链表的概念

      五、双向链表的建立与遍历

      六、双向链表的元素查找

      七、循环链表的概念

      八、合并两个链表的实例

      九、链表实战

      拓展思维、拉到最后去看看 (•̀ᴗ•́) ̑̑

      一、链表结构和静态/动态链表

      链表是一种常见的数据结构——与数组不同的是:

      1.数组首先需要在定义时声明数组大小,如果像这个数组中加入的元素个数超过了数组的长度时,便不能正确保存所有内容;链表可以根据大小需要进行拓展。

      2.其次数组是同一数据类型的元素集合,在内存中是按一定顺序连续排列存放的;链表常用malloc等函数动态随机分配空间,用指针相连。

      链表结构示意图如下所示:

    a3c903f0617f8a2bdf8e25241f7f2d4d.png

      在链表中,每一个元素包含两个部分;数据部分和指针部分。数据部分用来存放元素所包含的数据,指针部分用来指向下一个元素。最后一个元素的指针指向NULL,表示指向的地址为空。整体用结构体来定义,指针部分定义为指向本结构体类型的指针类型。

      静态链表需要数组来实现,即把线性表的元素存放在数组中。数组单元存放链表结点,结点的链域指向下一个元素的位置,即下一个元素所在数组单元的下标。这些元素可能在物理上是连续存放的,也有可能是不连续的,它们之间通过逻辑关系来连接——这就要涉及到数组长度定义的问题,实现无法预知定义多大的数组,动态链表随即出现。

      动态链表指在程序执行过程中从无到有地建立起一个链表,即一个一个地开辟结点和输入各结点的数据,并建立起前后相连的关系。

      二、单链表的建立与遍历

      单链表中,每个结点只有一个指针,所有结点都是单线联系,除了末为结点指针为空外,每个结点的指针都指向下一个结点,一环一环形成一条线性链。

      链表的创建过程:

    ddc8c240996ffc6c0f78bf4c0fbc2926.png

      接下来在源码中建立并遍历输出一个单链表。

      #include 
      #include 
      #include 
      /*单向链表*/
      struct Student/*建立学生信息结构体模型*/
      {
      char cName[20];/*学生姓名*/
      int iNumber;/*学生学号*/
      struct student *next;/*指向本结构体类型的指针类型*/
      };
      int iCount;/*全局变量表示链表长度*/
      struct Student *Create();/*创建链表函数声明*/
      void print(struct Student *);/*遍历输出链表函数声明*/
      int main()
      {
      int insert_n=2;/*定义并初始化要插入的结点号*/
      int delete_n=2;/*定义并初始化要删除的结点号*/
      struct Student *pHead;/*声明一个指向学生信息结构体的指针作pHead为头结点传递*/
      pHead=Create();/*创建链表,返回链表的头指针给pHead*/
      print(pHead);/*将指针pHead传入输出函数遍历输出*/
      return 0;
      }
      struct Student *Create()
      {
      struct Student *pHead=NULL;/*初始化链表,头指针为空*/
      struct Student *pEnd,*pNew;
      iCount=0;/*初始化链表长度*/
      pEnd=pNew=(struct Student *)malloc(sizeof(struct  Student));/*动态开辟一个学生信息结构体类型大小的空间,使得pEnd和pNew同时指向该结构体空间*/
      scanf("%s",pNew->cName);/*从输入流获取第一个学生姓名*/
      scanf("%d",&pNew->iNumber);/*从输入流获取第一个学生学号*/
      while(pNew->iNumber!=0)/*设定循环结束条件——学号不为0时*/
      {
      iCount++;/*链表长度+1,即学生信息个数+1*/
      if(iCount==1)/*如果链表长度刚刚加为1,执行*/
      {
      pNew->next=pHead;/*使指针指向为空*/
      pEnd=pNew;/*跟踪新加入的结点*/
      pHead=pNew;/*头结点指向首结点*/
      }
      else/*如果链表已经建立,长度大于等于2时,执行*/
      {
      pNew->next=NULL;/*新结点的指针为空*/
      pEnd->next=pNew;/*原来的结点指向新结点*/
      pEnd=pNew;/*pEnd指向新结点*/
      }
      pNew=(struct Student *)malloc(sizeof(struct Student));/*再次分配结点的内存空间*/
      scanf("%s",pNew->cName);/*从输入流获取第一个学生姓名*/
      scanf("%d",&pNew->iNumber);/*从输入流获取第一个学生学号*/
      }
      free(pNew);/*释放结点空间*/
      return pHead;/*返回创建出的头指针*/
      }
      void print(struct Student *pHead)
      {
      struct Student *pTemp;/*定义指向一个学生信息结构体类型的临时指针*/
      int iIndex=1;/*定义并出事哈变量iIndex,用来标识第几个学生(信息)*/
      printf("总共%d个学生(信息):n",iCount);
      pTemp=pHead;/*指针得到首结点的地址*/
      while(pTemp!=NULL)/*当临时指针不指向NULL时*/
      {
      printf("第%d个学生信息:n",iIndex);
      printf("姓名:%s",pTemp->cName); /*输出姓名*/
      printf("学号:%d",pTemp->iNumber);/*输出学号*/
      pTemp=pTemp->next;/*移动临时指针到下一个结点*/
      iIndex++;/*进行自加运算*/
      }
      }

      三、单链表的插入与删除

      在本实例中,插入时根据传递来的学号,插入到其后。

      删除时根据其所在链表的位置,删除并释放该空间。

      主函数增加如下:

      int main()
      {
      int insert_n=2;/*定义并初始化要插入的结点号*/
      int delete_n=2;/*定义并初始化要删除的结点号*/
      struct Student *pHead;/*声明一个指向学生信息结构体的指针作pHead为头结点传递*/
      pHead=Create();/*创建链表,返回链表的头指针给pHead*/
      pHead=Insert(pHead,insert_n);/*将指针pHead和要插入的结点数传递给插入函数*/
      print(pHead);/*将指针pHead传入输出函数遍历输出*/
      Delete(pHead,delete_n);/*将指针pHead和要删除的结点数传递给删除函数*/
      print(pHead);/*将指针pHead传入输出函数遍历输出*/
      return 0;
      }

      插入函数:

      struct Student *Insert(struct Student *pHead,int number)
      {
      struct Student *p=pHead,*pNew;/*定义pNew指向新分配的空间*/
      while(p&&p->iNumber!=number)
      p=p->next;/*使临时结点跟踪到要插入的位置(该实例必须存在学号为number的信息,插入其后,否则出错)*/
      printf("姓名和学号:n");
      /*分配内存空间,返回该内存空间的地址*/
      pNew=(struct Student *)malloc(sizeof(struct Student));
      scanf("%s",pNew->cName);
      scanf("%d",&pNew->iNumber);
      pNew->next=p->next;/*新结点指针指向原来的结点*/
      p->next=pNew;/*头指针指向新结点*/
      iCount++;/*增加链表结点数量*/
      return pHead;/*返回头指针*/
      }

      删除函数:

      void Delete(struct Student *pHead,int number)

      {

      int i;

      struct Student *pTemp;/*临时指针*/

      struct Student *pPre;/*表示要删除结点前的结点*/

      pTemp=pHead;/*得到链表的头结点*/

      pPre=pTemp;

      for(i=0;i

      {/*通过for循环使得Temp指向要删除的结点*/

      pPre=pTemp;

      pTemp=pTemp->next;

      }

      pPre->next=pTemp->next;/*连接删除结点两边的结点*/

      free(pTemp);/*释放要删除结点的内存空间*/

      iCount--;/*减少链表中的结点个数*/

      }

      四、双向链表的概念

      双向链表基于单链表。单链表是单向的,有一个头结点,一个尾结点,要访问任何结点,都必须知道头结点,不能逆着进行。而双链表添加了一个指针域,通过两个指针域,分别指向结点的前结点和后结点。这样的话,可以通过双链表的任何结点,访问到它的前结点和后结点。

      在双向链表中,结点除含有数据域外,还有两个链域,一个存储直接后继结点的地址,一般称为右链域;一个存储直接前驱结点地址,一般称之为左链域。

      双向链表结构示意图:

    6bceebffe79b7c5ea8ba49d2ca92229c.png

    addad915cb61d4e8649c770bda0a8eb7.png

      五、双向链表的建立与遍历

      双向链表的源码实战和单链表类似,只是多了第二个指针域的控制,这里直接贴上没有注释的源代码。

      #include #include 
      #include 
      #define N 10
      typedef struct Node
      {
      char name[20];
      struct Node *llink,*rlink;
      }STUD;
      STUD *creat(int);void print(STUD *);
      int main()
      {
      int number;
      char studname[20];
      STUD *head,*searchpoint;
      number=N;
      head=creat(number);
      print(head);
      printf("请输入你要查找的人的姓名:");
      scanf("%s",studname);
      searchpoint=search(head,studname);
      printf("你所要查找的人的姓名是:%s",*&searchpoint->name);
      return 0;
      }
      STUD *creat(int n)
      {
      STUD *p,*h,*s;
      int i;
      if((h=(STUD *)malloc(sizeof(STUD)))==NULL)
      {
      printf("不能分配内存空间");
      exit(0);
      }
      h->name[0]='0';
      h->llink=NULL;
      h->rlink=NULL;
      p=h;
      for(i=0;i 
      {
      if((s=(STUD *)malloc(sizeof(STUD)))==NULL)
      {
      printf("不能分配内存空间");
      exit(0);
      }
      p->rlink=s;
      printf("请输入第%d个人的姓名",i+1);
      scanf("%s",s->name);
      s->llink=p;
      s->rlink=NULL;
      p=s;
      }
      h->llink=s;
      p->rlink=h;
      return(h);
      }void print(STUD *h)
      {
      int n;
      STUD *p;
      p=h->rlink;
      printf("数据信息为:n");
      while(p!=h)
      {
      printf("%s ",&*(p->name));
      p=p->rlink;
      }
      printf("n");
      }

      六、双向链表的元素查找

      查找函数 STUD *search(STUD *,char *);

      STUD *search(STUD *h,char *x)
      {
      STUD *p;
      char *y;
      p=h->rlink;
      while(p!=h)
      {
      y=p->name;
      if(strcmp(y,x)==0)
      return(p);
      else
      p=p->rlink;
      }
      printf("没有查到该数据!");
      }

      七、循环链表的概念

      类似于单链表,循环链表也是一种链式的存储结构,由单链表演化而来。

      单链表的最后一个结点的指针指向NULL,而循环链表的最后一个结点的指针指向链表头结点。

      这样头尾相连,形成了一个环形的数据链。

      循环链表的建立不需要专门的头结点。

      判断循环链表是否为尾结点时,只需判断该节点的指针域是否指向链表头节点。

      八、合并两个链表的实例

      建立两个带头节点的学生链表,每个节点包含学号、姓名和成绩,链表都按学号升序排列,将它们合并为一个链表仍按学号升序排列。

      算法分析:

      合并链表用merge()函数实现。函数中定义3个工作指针a、b、c,其中a、b分别指向La链表、Lb链表的当前结点,C指向合并后的链表尾结点。合并后链表的头结点共用La链表的头结点。

      ①合并前,先让a和b分别指向两个链表的第一个结点,c指向La链表的头结点。

      ②合并时应该分3种情况讨论,即La和Lb都没有处理完;La没处理完,但Lb处理完毕;Lb没处理完,但La处理完毕。

      ③合并过程中应始终将La和Lb链表中较小的一个链接在Lc中,方能保持有序。

      void merge(struct stud *La,struct stud *Lb)
      {
      struct stud *a,*b,*c;
      c=La;
      a=La->next;/* 合并前 */
      b=Lb->next;
      while(a!=NULL && b!=NULL)/* La和Lb都没处理完 */
      {
      if(a->num <= b->num)
      {
      c->next=a;
      c=a;
      a=a->next;
      }
      else
      {
      c->next=b;
      c=b;
      b=b->next;
      }
      }
      if(a!=NULL)
      c->next=a;/* 若La没有处理完 */
      else
      c->next=b;/* 若Lb没有处理完 */
      free(Lb); /* 释放Lb的头结点 */
      }

    最后给大家分享一个关于C语言链表详细的资料供大家参考学习

    - C语言玩转链表 -

    展开全文
  • cast和dynamic_cast的类型检查 双链表建立,删除,打印 1.static_cast和dynamic_cast的类型检查 static_cast的类型检查:只检查无关类之间的转换 CBaseY* pY1 = static_cast 「C语言」单链表/双向链表的建立/遍历/...

    #include

    #include

    #include

    #define bzero(a, b) memset(a, 0, b)//windows平台下无bzero函数。 增加宏拓展移植性

    struct node

    {

    int data; //有效数据

    struct node *pLast;//指向上一个节点的指针

    struct node *pNext;//指向下一个节点的指针

    };

    struct node * make_node(int data)

    {

    struct node *p=(struct node*)malloc(sizeof(struct node));

    if(NULL==p)

    {

    printf("malloc error\n");

    return NULL;

    }

    //清理申请到的内存

    bzero(p,sizeof(struct node));

    //填充节点

    p->data=data;

    p->pLast=NULL;

    p->pNext=NULL;//将来要指向下一个节点的首地址

    //实际操作时将下一个节点的malloc 返回的指针给他。

    return p;

    }

    void ergodic(struct node *pH)//遍历

    {

    int cnt=;

    struct node *p=pH;

    /* printf("------开始遍历------\n");//这样包含头结点

    while(NULL!=p->pNext)

    {

    printf("第%d节点数据为为%d\n",cnt,p->data);

    p=p->pNext;

    cnt++;

    }

    printf("第%d节点数据为为%d\n",cnt,p->data);

    printf("------结束遍历------\n");

    } */

    printf("------开始遍历------\n");

    while(NULL!=p->pNext)

    {

    cnt++;

    p=p->pNext;

    printf("第%d节点数据为为%d\n",cnt,p->data);

    }

    printf("------结束遍历------\n");

    }

    void reverse_ergodic(struct node *pT)//反向遍历

    {

    int cnt=;

    struct node *p=pT;

    printf("------开始遍历------\n");

    while(NULL!=p->pLast)

    {

    cnt++;

    printf("第%d节点数据为为%d\n",cnt,p->data);

    p=p->pLast;

    }

    printf("------结束遍历------\n");

    }

    void in_tail(struct node *pH,struct node *p_new)

    { //先找到尾节点

    //插入

    int cnt=;

    struct node *p=pH;

    while(NULL!=p->pNext)

    {

    p=p->pNext;

    cnt++;

    }

    p->pNext=p_new; //插到之前最后的节点后面(后向指针)

    p_new->pLast=p; //之前最后的节点后面防盗新节点的向前的指针(前向指针)

    pH->data=cnt+;// 头节点数据代表链表个数

    //前指针的pLast与新指针的pNext无变动

    }

    void in_head(struct node *pH,struct node *p_new)

    { //1。将原1好节点地址给新节点后向指针

    //2。将头指针指向新节点

    //3。原1号节点前向指针指向新节点

    //4。新节点前向指针指向头结点

    int cnt=;

    struct node *p=pH;

    while(NULL!=p->pNext)

    {

    p=p->pNext;

    cnt++;

    }

    if(NULL==pH->pNext)

    {

    pH->pNext=p_new;

    p_new->pLast=pH;

    }else

    {

    p_new->pNext=pH->pNext;

    pH->pNext=p_new;

    p_new->pNext->pLast=p_new; //不判断的话p_new->pNext->pLast会引发段错误

    p_new->pLast=pH;

    }

    pH->data=cnt+;// 头节点数据代表链表个数

    //前指针的pLast与新指针的pNext无变动

    }

    void del_1(struct node *pH,int num)//根据节点数删除 不能删除0(头节点)

    {

    //1找到

    //2删除

    //删除(释放内存。指向下一个)

    int cnt=;

    struct node *p=pH;

    struct node *p_sb;;//临时变量释放内存用

    while(NULL!=p->pNext)

    {

    cnt++;

    if(num==cnt)

    {

    p_sb=p->pNext;//p为预删除点的上一个节点

    p->pNext=p->pNext->pNext;//跳过欲删除节点指向下下个节点(删除正向节点)

    if(NULL==p->pNext)

    {

    //说明P为现在最后一个节点

    }

    else

    {

    p->pNext->pLast=p;//(删除反向节点)

    }

    free(p_sb);//释放内存

    break;

    }

    p=p->pNext;//不满足上述条件时 寻找下一个节点

    }

    }

    void del_2(struct node *pH,int data)//删除指定数据

    {

    //1找到

    //2删除

    //删除(释放内存。指向下一个)

    struct node *p=pH;

    struct node *p_sb;;//临时变量释放内存用

    while(NULL!=p->pNext)

    {

    if(data==p->pNext->data)//p为预删除点的上一个节点

    { p_sb=p->pNext;

    p->pNext=p->pNext->pNext;//跳过欲删除节点指向下下个节点(删除正向节点)

    if(NULL==p->pNext)

    {

    //说明P为现在最后一个节点

    }

    else

    {

    p->pNext->pLast=p;//(删除反向节点)

    }

    free(p_sb);

    continue;

    }

    p=p->pNext;

    }

    }

    int main()

    {

    struct node *pHead=make_node();//初始化头节点;

    in_head(pHead,make_node());

    in_head(pHead,make_node());

    in_head(pHead,make_node());

    in_head(pHead,make_node());

    reverse_ergodic(pHead->pNext->pNext->pNext->pNext);

    ergodic(pHead);

    ergodic(pHead);

    del_2(pHead,);

    reverse_ergodic(pHead->pNext->pNext);

    ergodic(pHead);

    return ;

    }

    20140502 static&lowbar;cast和dynamic&lowbar;cast的类型检查 双链表建立,删除,打印

    1.static_cast和dynamic_cast的类型检查 static_cast的类型检查:只检查无关类之间的转换 CBaseY* pY1 = static_cast

    「C语言」单链表&sol;双向链表的建立&sol;遍历&sol;插入&sol;删除

    最近临近期末的C语言课程设计比平时练习作业一下难了不止一个档次,第一次接触到了C语言的框架开发,了解了View(界面层).Service(业务逻辑层).Persistence(持久化层)的分离和耦合, ...

    单链表的插入删除操作&lpar;c&plus;&plus;实现&rpar;

    下列代码实现的是单链表的按序插入.链表元素的删除.链表的输出 // mylink.h 代码 #ifndef MYLINK_H #define MYLINK_H #include

    &lbrack;PHP&rsqb; 数据结构-链表创建-插入-删除-查找的PHP实现

    链表获取元素1.声明结点p指向链表第一个结点,j初始化1开始2.j

    C语言习题 链表建立,插入,删除,输出

    Problem B: C语言习题 链表建立,插入,删除,输出 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 222  Solved: 92 [Subm ...

    单链表创建、删除、查找、插入之C语言实现

    本文将详细的介绍C语言单链表的创建.删除.查找.插入以及输出功能 一.创建 #include #include typedef int E ...

    单链表的插入伪算法和用C语言创建单链表,并遍历

    非循环单链表插入结点伪算法讲解 q插入p之后的伪算法:第一种表示方法:r = p->pNext; // p->pNext表示的是所指向结点的指针域,指针域又是指向下一个结点的地址p-&gt ...

    YTU 2430&colon; C语言习题 链表建立,插入,删除,输出

    2430: C语言习题 链表建立,插入,删除,输出 时间限制: 1 Sec  内存限制: 128 MB 提交: 576  解决: 280 题目描述 编写一个函数creatlink,用来建立一个动态链表 ...

    单链表&amp&semi;双链表的头插入&amp&semi;尾插入

    #include #include"stdlib.h" struct student { int data; struct student *pnex ...

    随机推荐

    在update语句中使用子查询

    在update 中的 where 子句中使用子查询: UPDATE mg_page_log as a  SET  page_num=1 WHERE id in( SELECT id  from mg_ ...

    实验记录:Oracle redo logfile的resize过程

    实验记录:Oracle redo logfile的resize过程. 实验环境:RHEL 6.4 + Oracle 11.2.0.3 单实例 文件系统 实验目的:本实验是修改redo logfile的 ...

    树莓派(Raspberry Pi)修改时区

    1.安装ntp sudo apt-get install ntpdate 2.修改时区 tzselect 3.选择自己的时区 1)选择大洲 2)选择国家 3)选择城市 4)选择YES 5)或者使用命令 ...

    fir&period;im Weekly - 我回来了

    Hey, 大家好,距离 fir.im 新版上线已匆忙过去一周多的时间,新版的fir正在慢慢稳定优化中,感谢大家的反馈与支持!后续我们将上线 FAQ 帮助中心,如还有疑问请邮件至 help@fir.im ...

    Android 贝塞尔曲线 折线图

    1.贝塞尔曲线:http://baike.baidu.com/view/60154.htm,在这里理解什么是贝塞尔曲线 2.直接上图: 3.100多行代码就可以画出贝塞尔曲线,直接上代码 packag ...

    &lbrack;转载&rsqb;STL map中的一些基本函数

    来源:(http://blog.sina.com.cn/s/blog_61533c9b0100fa7w.html) - C++ map的基本操作和使用_Live_新浪博客 Map是c++的一个标准容器 ...

    Json-lib用法

    Json-lib用法 1.需要的jar包有一下几个,别的文章中没有xom这个jar包,但我的工程中如果没有这个包,那么,json数据转换为xml数据的程序中在执行XMLSerializer xmlSe ...

    三、CSS样式——链接

    CSS链接的四种状态: a:link ——普通的.未被访问的链接 a:visited ——用户已访问的链接 a:hover ——鼠标指针位于链接的上方 a:active ——链接背点击的时刻 常见的链 ...

    JavaScript 运行机制详解

    一.为什么JavaScript是单线程? JavaScript语言的一大特点就是单线程,也就是说,同一个时间只能做一件事.那么,为什么JavaScript不能有多个线程呢?这样能提高效率啊. Java ...

    框架tensorflow1

    TensorFlow   1 分类: 1,protocol Buffer  处理结构化数据工具: (xml,json) 2,Bazel        自动化构建工具, 编译: tensor 张量:   ...

    展开全文
  • #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Node { int id;//数据域 struct Node* next;...//链表的头结点地址右函数值返回 Node* SListCreat() { Node...

    在这里插入图片描述
    在这里插入图片描述

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    typedef struct Node
    {
    	int id;//数据域
    	struct Node* next;//指针域
    }Node;
    
    //创建头节点
    //链表的头结点地址右函数值返回
    Node* SListCreat()
    {
    	Node* head = NULL;
    
    	//头结点作为标志位,不存储有效数据
    	head = (Node*)malloc(sizeof(Node));
    	if (head == NULL)
    	{
    		return NULL;
    	}
    
    	//给head的成员变量赋值
    	head->id = -1;
    	head->next = NULL;
    
    	Node* pCur = head;
    	Node* pNew = NULL;
    
    	int data;
    	while (1)
    	{
    		printf("请输入数据:");
    		scanf("%d", &data);
    
    		if (data == -1)//输入-1,推出
    		{
    			break;
    		}
    
    		//新节点动态分配空间
    		pNew = (Node*)malloc(sizeof(Node));
    		pNew->id = data;
    		pNew->next = NULL;
    
    		//链表建立关系
    
    		//当前节点的next指向pNew
    		pCur->next = pNew;
    
    		//pNew的下一个节点的指向NULL
    		pNew->next = NULL;
    
    		//把pCur移动到pNew,pCur指向pNew
    		pCur = pNew;
    
    	}
    	return head;
    }
    
    //链表的遍历
    int SListPrint(Node* head)
    {
    	if (head == NULL)
    	{
    		return -1;
    	}
    
    	//取出第一个有效节点(即头结点的next)
    	Node* pCur = head->next;
    
    	printf("head->");
    	while (pCur != NULL)
    	{
    		printf("%d->", pCur->id);
    
    		//当前节点往下移动一位,pCur指向下一个
    		pCur = pCur->next;
    	}
    	printf("NULL\n");
    	return 0;
    }
    
    
    
    
    int main(void)
    {
    	Node* head = NULL;
    
    	head = SListCreat();//创建头结点
    	SListPrint(head);
    
    
    	system("pause");
    	return;
    }
    
    展开全文
  • Time Limit: 1000 ms Memory Limit: 256 mb ...将n个整数建立升序链表,之后遍历链表并输出。 输入输出样例 输入样例#: 复制 4 3 5 7 9 输出样例#: 复制 3 5 7 9 题目来源 华中科技大学 代码如下: #i
  • C语言两种非递归方式实现中序遍历链表二叉树 二叉树采用二叉链表存储结构,按照先序遍历的方式创建下面这棵二叉树。然后分别用中序遍历的两种非递归算法遍历这棵二叉树。最后释放二叉树的每个结点的存储空间。提示:...
  • 遍历链表

    2021-02-18 15:42:56
    1.如果链表中的数据不连续,只需要把链表中的头节点拿出来(point=head,定义指针指向链表的头),利用指针,可以遍历整个链表。 2.代码实现 #include <stdio.h> struct Test { int data;//定义结构体的数据...
  • 图和二叉树;链表的建立;以及二叉树的遍历等等后序先序中序遍历
  • 1.什么是链表? 链表是一种常见的数据结构,链表是由多个结点(自引用结构体)串成的表。...只有通过头指针我们才能找到链表,遍历链表中的每一个结点。 2.创建链表步骤分解 1.结构体声明 struct no
  • 案例:本文主要描述Java创建链表ListNode及遍历链表 一、首先创建一个maven工程,配置依赖包 无特殊依赖 二、开始写入自动化测试代码 class ListNode { //类名 :Java类就是一种自定义的数据结构 int val; //数据 ...
  • c语言写的遍历二叉树 包括前序,中序,后序
  • 所以你应该已经弄懂了 struct 的定义和 typedef 是怎么回事吧。 那么,在 main 中你定义了 a、b、c 这三个 NODE... 那么整个 while 就是利用 p 指针,遍历了一遍 a b c 节点链接而成的链表(对,这样的结构就叫“链表”)
  • 时间限制:1 秒 内存限制:32 兆 特殊判题:否 提交:2733 解决:1181 题目描述: 建立一个升序链表并遍历...将n个整数建立升序链表,之后遍历链表并输出。 样例输入: 4 3 5 7 9
  • C语语言言循循环环链链表表实实现现贪贪吃吃蛇蛇游游戏戏本文实例为大家分享了C语言表实现贪吃蛇游戏的具体代码,供大家参考,具体 容如下总总体体思思想想利用循环链表将一条蛇的坐标进行存储,然后利用gotoxy ()...
  • 题目描述 建立一个升序链表并遍历输出。...将n个整数建立升序链表,之后遍历链表并输出。 示例 输入 4 3 5 7 9 输出 3 5 7 9 提示! 先排序,后建表。尾插法是关键。 Code #include<iostream>...
  • 华科机考:遍历链表

    2019-10-03 06:07:29
    时间限制:1秒空间限制:32768K 题目描述 建立一个升序链表并遍历输出。...输出描述: 可能有多组测试数据,对于每组数据, 将n个整数建立升序链表,之后遍历链表并输出。 输入例子: 4 3 5 7 9 输出例子: 3 ...
  • "NO.1篇幅较长,请空闲时观看前言整个项目包括三个文件——mylist.h | —mylist.c | —student.cmylist.h和mylist.c写有链表创建和文件读写,student.c则是写界面和功能。基于C语言的学生管理系统(含文件)(一)上篇...
  • 题目1181:遍历链表 时间限制:1 秒 内存限制:32 兆 特殊判题:否 提交:3483 解决:1465 题目描述: 建立一个升序链表并遍历输出。 输入: 输入的每个案例中第一行包括1个整数:n(1<=n<=1000...
  • C语言链表的创建、遍历、插入和删除

    千次阅读 多人点赞 2017-07-18 17:22:49
    C语言链表的创建、遍历、插入和删除C语言链表的创建遍历插入和删除 链表结构定义 基本功能实现 边界条件判断和错误情况处理 总结链表结构定义struct Node { int value; struct Node* next; }; typedef struct ...
  • 单链表转置完整函数如下: struct ListNode* reverseList(struct ListNode* head){ if(head==NULL||head->... }//考虑到特殊情况,链表为空便不需要反转 struct ListNode *p=head;//先将头结点记为p str...
  • 题目1181:遍历链表

    2014-08-05 16:05:40
    题目描述: 建立一个升序链表并遍历输出。...将n个整数建立升序链表,之后遍历链表并输出。 样例输入: 4 3 5 7 9 样例输出: 3 5 7 9 来源: 2000年华中科技大学计算机研究生机试真题

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,957
精华内容 13,982
关键字:

c语言遍历链表

c语言 订阅