⑴ 逆序输入n个数据元素的值,建立带头结点的单链表的c语言程序，怎么做
#include
#include
#include
//函数结果状态代码
#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_L
Status ListShow_L(LinkList L){
//将带头结点的单链线性链表L的元素列出。
LinkList p = L;
while(p->next){p = p->next;printf("%d ",p->data);}
return OK;
}//ListShow_L
void main(){
int n;
printf("请输入将要载入链表的元素个数:");
scanf("%d",&n); //初始化线性链表元素的个数
printf("请逆序输入%d个元素的值:\n",n);
LinkList L;
CreateList_L(L,n); //初始化线性链表
ListShow_L(L); //输出线性链表元素的值
}
⑵ c语言题：在键盘输入10个整数 逆序存放并输出
比较简单的方法是创建一个数组
从下标为9开始递减进行输入至下标为0
这样存储就会是倒序的了
然后再从下标为0开始递增输出到下标为9
另一种方法是创建两个数组
比如a和b，先顺序地将10个数据存储在a里
然后通过一个循环来将数据逆序存储在数组b里
这样数组b里就是逆序存储的了
最后顺序输出数组b
当然还有一种方法
可以使用一个链表（或者数组也可以）
然后使用栈的方式存储数据
题目中要求数据的存放是逆序的
这其实要具体地看存储的方式了
以栈来说，栈是一种先进后出的数据结构
从这种层面上来看的话它存储的数据就是“逆序”的
但如果使用一个数组来实现的话存储在数组里的数据就可能是顺序的（不使用逆序有方式将数据存储在数组里）
一个简单的例子
#include<stdio.h>
#definePUSH(i)(*p=i,++p)
#definePOP(i)(--p,i=*p)
intmain(intargc,char**argv)
{
inta[10];
inti,r;
int*p=a;
for(i=0;i<10;++i)
{
scanf("%d",&r);
PUSH(r);
}
for(i=0;i<10;++i)
{
POP(r);
printf("%d",r);
}
printf(" ");
return0;
}
该例子，如果从栈这种数据结构的方式来看
先输入的数据会被压入到栈底
最后的数据在栈顶，从栈顶到栈底来看的话
数据的存储就是逆序的
如果从数组下标来看的话就是顺序的
这里我们可以将指针反转过来
#include<stdio.h>
#definePUSH(i)(*p=i,--p)
#definePOP(i)(++p,i=*p)
intmain(intargc,char**argv)
{
inta[11];
inti,r;
int*p=a+10;
for(i=0;i<10;++i)
{
scanf("%d",&r);
PUSH(r);
}
for(i=0;i<10;++i)
{
POP(r);
printf("%d",r);
}
printf(" ",a[0]);
return0;
}
那么在数组的层面上来说也会是逆序的了
而以数组的顺序或逆序方式来说的话
使用链表的方式则已经没有相对明确的“顺序”或者“逆序”了
当然我们也可以使用逆序链表的方法业创建栈数据结构
由于栈数据结构的性质决定了这种数据存储的方式
⑶ C语言链表节点逆序问题
首先说你十个字符串输出结果是九个字符串的问题，你好好看你的for循环代码，你实际上只能输入九个字符串的，并不是你提示的那样能输入是个字符串，你好好看看i的边界问题。
然后就是输出九个字符串都是一样的问题，你先看你输入的字符串用的是什么接收（就是用的什么变量），九个字符串，你都用的a指针指向的那个空间，问题来了。对于链表中的节点，他们自己其实都是独立的存储空间，比如第一个节点用的是地址为1的空间，第二个节点用的地址为100的空间，他们都是相互独立的，而你的代码，所有节点都是用的a指针指向的那个内存空间。所以实际上你的链表只有一个有效节点的，并不是你想的那样哦。然后你链表都是同一个内存空间，而且你输入也是用的这个空间，对于输入来说，你重复的用的话，它就是重复的覆盖而已，你第一个字符串是abc 那么当第二个字符串输入时（假设bcd），那么bcd就会把abc覆盖掉，这就是为什么你输出会是最后一个串输出九次的原因，不知道懂了没，这个要有点点计算机内存的知识。。。
⑷ 键盘输入一组数字,用单链表形式存储,输入完成后分别按顺序和逆序输出所输入数字。
楼主你好
具体代码如下：
#include<stdio.h>
#include<stdlib.h>
#define MAX 80
typedef struct node
{
int data;
struct node *next;
}N;
N *head=(N *)malloc(sizeof(N));//创建头结点
void Creat()
{
N *p;//用于插入新节点
N *r=head;//尾指针 开始指向头结点
printf("请输入任意个数据(用回车结束输入、空格间隔:1 2 3……)\n:");
do{
p=(N *)malloc(sizeof(N));
scanf("%d",&p->data);
r->next=p;
r=p;
}while(getchar()!='\n');
r->next=NULL;
}
void Disp()//实现顺序输出和逆序输出
{
N *p=head->next;//用于遍历单链表
int a[MAX];
int i=0,j;
printf("顺序输出:\n");
while(p)
{
printf("%d ",p->data);
a[i]=p->data;
p=p->next;
i++;
}
printf("\n逆序输出:\n");
for(j=i-1;j>=0;j--)
printf("%d ",a[j]);
printf("\n");
}
void main()
{
Creat();
Disp();
}
希望能帮助你哈
⑸ 链表的逆序输出(递归调用 )
是函数调用栈存储的指针。每次递归调用，函数帧栈里面都存放了指针。
上面函数递归调用的最后一次，l为null，之后函数调用栈依次弹出，获得前面的地址值。
即push到最后，全pop出来。
⑹ 链表结点的逆序存放怎么写
typedef struct node
{
node() { next=NULL;}
int data;
node* next;
} node , * pnode;
pnode reverse(pnode L)
{
if (L==NULL || L->next==NULL)
{
return L;
}
else
{
pnode p=L->next;
pnode newhead=L;
pnode q=L;
newhead->next=NULL;
while (p!=NULL)
{
q=p;
p=p->next;
q->next=newhead;
newhead=q;
}
return newhead;
}
}
⑺ 用链表的形式存储一个字符串 按正序和逆序输出字符串(数据结构考试)
这个字符串的输出，考虑到有正序和逆序，采用链表，可以考虑用双链表。这样输出效率会比较高。
建议用循环双链表（带头结点），方便程序处理，简化操作流程，步骤明晰，便于调试。
关键函数可分为：
1，结构的定义
2，初始化链表
3，输出（正序，逆序）
4，释放链表
5，主函数
以下C语言代码在VC6.0中编译通过：
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<malloc.h>
#include<string.h>
/*定义*/
typedefstructnode
{
charc;
structnode*llink,*rlink;
}stud;
/*建立链表*/
stud*creat(void)
{
stud*p,*h,*s;
chara;
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==' ')
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);
}
/*正序*/
voidprint1(stud*h)
{
stud*p;
p=h->rlink;
printf("字符串(正序)：");
while(p!=h)
{
printf("%c",p->c);
p=p->rlink;
}
printf(" ");
}
/*逆序*/
voidprint2(stud*h)
{
stud*p;
p=h->llink;
printf("字符串(逆序)：");
while(p!=h)
{
printf("%c",p->c);
p=p->llink;
}
printf(" ");
}
/*释放*/
voidfree_stud(stud*h)
{
stud*p,*q;
p=h->llink;
while(p!=h)
{
q=p;
p=p->llink;
free(q);
}
free(h);
}
/*主函数*/
intmain()
{
stud*head=NULL;
head=creat();
print1(head);
print2(head);
free_stud(head);
return0;
}
⑻ 有一个逆序排列的序列，用带头结点的单链表存储，头结点地址在h中，设计算法，正序输出该序列
设有一个带头结点的单链表，写一个程序将链表颠倒过来
⑼ 数据结构链表储存删除按逆输出
遍历一遍，找出最大值和最小值，并将链表反向，然后遍历链表，删除最大值和最小值节点
⑽ 求助：单链表逆序排列问题，编程高手进！！
给你个图易理解些(图做的不好)。
称已完成逆置的链表为链表x
L:链表x的表头
L->next:链表x的第一个节点
p:待插入到链表x的节点
每次将p插入到L与L->next之间即可完成逆置
(原链表为空时该算法也能保证正确，这个你自己看看吧，不解释了)