链表逆序 c语言（C语言将一个链表的逆序输出）

本文目录

• C语言将一个链表的逆序输出
• C语言如何用递归实现链表的逆序输出、释放、倒序求大神给出这三段代码谢谢！
• 从键盘上顺序输入整数，知道输入整数小于0时才停止输入，然后逆序输出这些整型（用C语言链表）
• C语言链表逆序怎么理解
• C语言用链表实现逆序输出
• 逆序输入n个数据元素的值,建立带头结点的单链表的c语言程序，怎么做
• 用c语言实现单链表的逆置，能将此程序详细的解释一下吗
• 写一个读入一个字符串，把它顺序存入一个双向链表，并按逆序输出的程序 （数据结构c语言）
• C语言链表：输入若干个正整数（输入-1为结束标志），要求按输入数据的逆序建立一个链表并输出
• 用链表的形式存储一个字符串 按正序和逆序输出字符串(数据结构考试)

C语言将一个链表的逆序输出

循环链表，把头尾接走来就行tail-》next = head;判定是否到达尾部，1.设置计数；2.判断下一个指针是否是head逆序输出1.重新开辟空间，建立逆序链表2.建立双向链表，即增加 pre指针指向前一个3.如果只是要逆序输出，调用递归算法逆序输出( 链表 ){if 下一个是否为空 输出else 逆序输出( next )end输出}

C语言如何用递归实现链表的逆序输出、释放、倒序求大神给出这三段代码谢谢！

#include 《stdio.h》#include 《time.h》#include 《stdlib.h》typedef struct node {int data;struct node *next;}*pNode,*LinkList,LNode;LinkList getEmptyList() {LinkList head = (pNode)malloc(sizeof(LNode));head-》next = NULL;return head;}void insertNode(LinkList head, int data) {int flag = 1;pNode p,q = (pNode)malloc(sizeof(LNode));q-》data = data;if(head-》next == NULL) {head-》next = q;q-》next = NULL;return;}for(p = head; p-》next && flag; p = p-》next) {if(p-》next-》data 》 data) {q-》next = p-》next;p-》next = q;flag = 0;}}if(flag) {p-》next = q;q-》next = NULL;}}void show(LinkList head) {pNode p = head-》next;while(p) {printf("%d ",p-》data);p = p-》next;}printf("\n");}void showReverse(LinkList p) {if(p-》next) showReverse(p-》next);printf("%d ",p-》data);}LinkList reverse(pNode &p, pNode &q) {pNode t;t = p-》next;p-》next = q;q = p;p = t;if(p) reverse(p,q);return q;}void destory(LinkList head) {pNode q,p = head;while(p) {q = p;p = q-》next;free(q);}}int main() {LinkList head = getEmptyList();pNode q = NULL;int i,n = 18;srand((unsigned)time(NULL));for(i = 0;i 《 n;i++)insertNode(head,rand()%100);printf("原链表:\n");show(head);printf("反向显示:\n");showReverse(head-》next);printf("\n");head-》next = reverse(head-》next,q);printf("反向后的正向显示\n");show(head);destory(head);return 0;}

从键盘上顺序输入整数，知道输入整数小于0时才停止输入，然后逆序输出这些整型（用C语言链表）

#include 《stdio.h》#include 《stdlib.h》typedef struct NODE Node;struct NODE {    int value;    Node *next;};Node *head;int main(){    int num;    Node *prev,*node;    head=(Node *)malloc(sizeof(Node));    head-》next=NULL;    scanf("%d",&num);    prev=NULL;    while(num》=0)    {        node=(Node *)malloc(sizeof(Node));        node-》value=num;        node-》next=prev;        head-》next=node;        prev=node;        scanf("%d",&num);    }    for(node=head-》next;node!=NULL;node=node-》next)        printf("%d\n",node-》value);    return 0;}

C语言链表逆序怎么理解

扣着的是头节点（头子）

车是首节点（首子）

马是次节点（次子）

牙签细的是指针指向，香头发黑的是指向，铁头细的是指向。

根据步骤写程序的伪算法（3步4循环，7张图片搞定），如下：

以下是while循环（条件：香头指向不为空）

第一个循环把马弄到车前面，

第二个循环把相弄到马前面

第三个循环把士弄到相前面

........

直到香指向为空后停止循环。

代码如下：只需要一个首结点pHead,就能把链表找到，并倒置。具体代码如下

p香=pHead-》pNext;

p铁=p香-》pNext;

p香-》pNext=NULL;

P香=p铁

while(p香 ！=NULL)

{

     p铁=p香-》pNext;

     p香-》pNext=pHead-》pNext;

     pHead-》pNext=p香；

     p香=p铁；

}

对照伪算法（三步四循环），和上面的代码是一一对应的：

第一步：香头指向首子，铁头指向次子

第二步：删掉首子指向次子（铁头所指向的那个子）的牙签

第三步：香头跟着铁头

以下循环条件：（条件：香头指向不为空）

{

    循环1：铁头移动到香头的下一个指向

    循环2：香头的下一个指向首子

    循环3：头子的下一个跟着香头

    循环4：香头跟着铁头

}

自己用道具操作几遍，然后把流程背会，以后自己根据流程写代码即可。

C语言用链表实现逆序输出

#include《stdio.h》#include《stdlib.h》#include 《malloc.h》//定义链表节点typedef struct LNode{ int data;  struct LNode *next;} LNode, *Linklist;//创建链表Linklist create(){ int i,n; //i用于下面循环,n用来存放有效节点的字数  Linklist p,L;  printf("Please input N =");  scanf("%d",&n);  L= (Linklist)malloc(sizeof(LNode)); // 分配一个不存放有效数据的头结点  L-》next=NULL;  for(i = 0; i 《 n; i++)  { p = (Linklist)malloc(sizeof(LNode));//生成新节点    scanf("%d",&p-》data);//输入元素值    p-》next = L-》next;    L-》next = p;  }  return L; //返回头节点 ;}//链表反转输出 Linklist ReverseList(Linklist L,int st)    //st为1时输出结点数据{ if(L-》next!= NULL)    ReverseList(L-》next,1);  if(st)printf("%d ", L-》data);  return L;}void put(Linklist L){ Linklist p;  p = L-》next;  while(p != NULL)  { printf("%d ", p-》data);    p = p-》next;  }  printf("\n");}int main(){ Linklist L;  L=create();  printf("A: "); put(L);  printf("B: ");  ReverseList(L,0);    //附加结点未保存数据，故第二参数为0  return 0;}

逆序输入n个数据元素的值,建立带头结点的单链表的c语言程序，怎么做

#include 《stdio.h》#include 《stdlib.h》#include 《malloc.h》//函数结果状态代码#define OK 1#define ERROR 0//Status是函数的类型，其值是函数结果状态代码typedef int Status;typedef int ElemType;//----线性表的单链表存储结构----typedef struct LNode{ ElemType data; struct LNode *next;}LNode, *LinkList;void CreateList_L(LinkList &L,int n){ //逆位序输入n个元素的值，建立带表头结点的单链线性表L。 L = (LinkList)malloc(sizeof(LNode)); L-》next = NULL; //先建立一个带头结点的单链表 for (int i=n;i》0;--i){ LinkList p = (LinkList)malloc(sizeof(LNode)); //生成新结点 scanf("%d",&p-》data); //输入元素值 p-》next = L-》next;L-》next = p; //插入到表头 }}//CreateList_LStatus ListShow_L(LinkList L){ //将带头结点的单链线性链表L的元素列出。 LinkList p = L; while(p-》next){p = p-》next;printf("%d ",p-》data);} return OK;}//ListShow_Lvoid main(){ int n; printf("请输入将要载入链表的元素个数:"); scanf("%d",&n); //初始化线性链表元素的个数 printf("请逆序输入%d个元素的值:\n",n); LinkList L; CreateList_L(L,n); //初始化线性链表 ListShow_L(L); //输出线性链表元素的值}

用c语言实现单链表的逆置，能将此程序详细的解释一下吗

算法的核心就是reverse函数，其它的都是辅助建立链表和输出链表的。从数据结构的定义来看这是一个带头节点的链表。要弄的十分明白你要耐心点画图看看。我简单的说下思路：【head是指向头结点的】p=head; //p最开始指向头结点s=p-》next; //s最开始指向第一个节点while(s-》next!=NULL)//只要没有到最后一个元素就继续。最后一个元素的next肯定为NULL{ //进入核心了楼主t=s-》next; //用t指向s后面的那个元素s-》next=p; //把s指向她前面那个，这个时候就实现了逆向了。而且是就地逆向。元素都没有动的p=s; //然后p向后移动ss=t; //s向后移动到p 这样到下一轮的时候又可以讲下下个再指向刚才那个下一个。一次内推} s-》next=p; //当最后一个的时候，还是要指向她的前一个。head-》next-》next=NULL;//头指针的下一个是指向原来的第一个。逆向后肯定是最后的那个了。所以最后的一个的next=NULL就明了了。head-》next=s;//s是逆序前的最后一个，逆序后是第一个，所以用头指向他画个图好好体会下，楼主！

写一个读入一个字符串，把它顺序存入一个双向链表，并按逆序输出的程序 （数据结构c语言）

#include "stdio.h"struct node { struct node *front; char c; struct node *next;};struct node *input(struct node *top);int main(void) {struct node T,*top=&T,*tail=&T,*p=NULL;T.front=NULL;T.next=NULL;T.c=’\0’;tail=input(top);p=tail-》front;while(p!=NULL){ printf("%c",p-》c); p=p-》front;} return 0;}struct node *input(struct node *top){int i=0;struct node *t;char x;while((x=getchar())!=’\n’){ top-》c=x; t=(struct node *)malloc(sizeof(struct node)); top-》next=t; t-》front=top; t-》next=NULL; t-》c=’\0’; top=top-》next;} return top;}

C语言链表：输入若干个正整数（输入-1为结束标志），要求按输入数据的逆序建立一个链表并输出

#include 《stdio.h》#include 《time.h》#include 《stdlib.h》struct list { int data; struct list *next;};int main(){ int i; struct list *p, *head, *q; head = (struct list*) malloc(sizeof(struct list)); head-》next = NULL; while (scanf("%d", &i), i!=-1) { p = (struct list*)malloc(sizeof(struct list)); p-》data = i; p-》next = head-》next; head-》next = p; } p = head-》next; while (p) { printf("%d ", p-》data); p = p-》next; } putchar(10); p = head-》next; while (p) { q = p; p = p-》next; free(q); } free(head); return 0;}

用链表的形式存储一个字符串 按正序和逆序输出字符串(数据结构考试)

这个字符串的输出，考虑到有正序和逆序，采用链表，可以考虑用双链表。这样输出效率会比较高。

建议用循环双链表（带头结点），方便程序处理，简化操作流程，步骤明晰，便于调试。

关键函数可分为：

1，结构的定义

2，初始化链表

3，输出（正序，逆序）

4，释放链表

5，主函数

以下C语言代码在VC6.0中编译通过：

#include 《stdio.h》

#include 《stdlib.h》

#include 《conio.h》

#include 《malloc.h》

#include 《string.h》

/*定义*/

typedef struct node

{

  char c;

  struct node *llink,*rlink;

}stud;

/*建立链表*/

stud * creat(void)

{

  stud *p,*h,*s;

  char a;

  if((h=(stud *)malloc(sizeof(stud)))==NULL)

  {

    printf("不能分配内存空间!");

    exit(0);

  }

  h-》c = 0;

  h-》llink=NULL;

  h-》rlink=NULL;

  p=h;

  while(1)

  {

a = getchar();

if(a==’\n’)

break;

    if((s= (stud *) malloc(sizeof(stud)))==NULL)

    {

      printf("不能分配内存空间!");

      exit(0);

    }

    p-》rlink=s;

    s-》c =a;

    s-》llink=p;

    s-》rlink=NULL;

    p=s;

  }

  h-》llink=s;

  p-》rlink=h;

  return(h);

}

/*正序*/

void print1(stud *h)

{

  stud *p;

  p=h-》rlink;

  printf("字符串(正序)：");

  while(p!=h)

  {

    printf("%c",p-》c);

    p=p-》rlink;

  }

  printf("\n");

}

/*逆序*/

void print2(stud *h)

{

  stud *p;

  p=h-》llink;

  printf("字符串(逆序)：");

  while(p!=h)

  {

    printf("%c",p-》c);

    p=p-》llink;

  }

  printf("\n");

}

/*释放*/

void free_stud(stud *h)

{

  stud *p,*q;

  p=h-》llink;

  while(p!=h)

  {

    q=p;

    p=p-》llink;

    free(q);

  }

  free(h);

}

/*主函数*/

int main()

{

  stud *head=NULL;

  head=creat();

  print1(head);

  print2(head);

  free_stud(head);

  return 0;

}