数组1 2 3 4 5 6 1(输入－1结束)，奇数位的数逆序，偶数位数不变

 数组1 2 3 4 5 6 -1(输入－1结束)，结果为：奇数位的数逆序，偶数位数不变，用链栈作为缓冲

源代码：

//采用链栈，对数组1 2 3 4 5 6 -1(输入－1结束)，结果为：奇数位的数逆序，偶数位数不变，即：5 2 3 4 1 6
typedef int datatype;
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define NULL 0
#define maxsize 4 //设栈的最大元素数为100
//定义单链表结点的结构
typedef struct node
{
　　datatype data;
　　struct node *next;
}linklist;
linklist *head; //定义单链表的头指针
//定义链栈
typedef struct stack
{
　　datatype data;
　　struct stack *next;
}linkstack;

linklist *creatlist() //建立单链表
{

　　linklist *p,*q;
　　//int n=0;
　　p=q=(struct node *)malloc(sizeof(linklist));
　　head=p;
　　p->next=NULL; //头结点的数据域不存放任何东西
　　p=(struct node *)malloc(sizeof(linklist));
　　scanf("%d",&p->data);
　　while(p->data!=-1) //输入-1表示链表结束
　　{
　　　　q->next=p;
　　　　q=p;
　　　　p=(struct node *)malloc(sizeof(linklist));
　　　　scanf("%d",&p->data);
　　}
　　q->next=NULL;
　　return head;
}

//输出单链表
void print(linklist *head)
{
　　linklist *p;
　　p=head->next;
　　if (p==NULL)
　　printf("This is an empty list.\n");
　　else
　　{
　　　　do
　　　　{
　　　　　　printf("%6d",p->data);
　　　　　　p=p->next;
　　　　}while(p!=NULL);
　　printf("\n");
　　}
}

linkstack *InitStack() //构造一个空栈s
{
　　linkstack *t=(linkstack *)malloc(sizeof(linkstack));
　　t->next=NULL;
　　return t;
}

void push(linkstack *s,datatype x) //入栈
{
　　struct stack *temp=(linkstack *)malloc(sizeof(linkstack));
　　temp->data=x;
　　temp->next=s->next;
　　s->next=temp;
}

int EmptyStack(linkstack *s)
{
　　if(s->next==NULL)
　　　　return 1; //栈为空时返回1（真）
　　else
　　　　return 0; //栈非空时返回0（假）
}

void pop(linkstack *s) //出栈
{
　　if(!EmptyStack(s))
　　{
　　　　struct stack *p=s->next;
　　　　s->next=p->next;
　　　　free(p);
　　}
　　else
　　{
　　　　printf("\n栈为空，无法出栈！\n");
　　}
}

//得到栈顶元素
int GetTop(linkstack *s)
{
　　if(!EmptyStack(s))
　　　　return s->next->data;
　　else
　　　　return printf("\n元素不存在\n");
}

linklist *back_linklist(linklist *head)//利用栈s逆置单链表
{
　　linklist *p;
　　linkstack *ss=InitStack();
　　p=head->next; //p指向首元结点

　　while(p)
　　{
　　　　push(ss, p->data); //链表结点中的数据入栈
　　　　p=p->next; //p指针后移
　　}
　　p=head->next; //p再指向首元结点
　　while(!EmptyStack(ss)) //当栈S非空时循环
　　{
　　　　p->data =GetTop(ss); //数据出栈,并存入p所指结点的数据域
　　　　pop(ss);
　　　　p=p->next; //p指针后移
　　}
　　return head;
}

//按奇数位逆序算法
linklist *reverse_linklist(linklist *head) //利用栈s逆置单链表
{
　　linklist *p;
　　linkstack *ss=InitStack();
　　p=head->next; //p指向首元结点
　　while(p)
　　{
　　　　push(ss, p->data); //链表结点中的数据入栈
　　　　if(p->next==NULL)
　　　　　　p=p->next;
　　　　else
　　　　　　p=p->next->next;
　　}
　　p=head->next;
　　while(!EmptyStack(ss))
　　{
　　　　p->data=GetTop(ss);
　　　　pop(ss);
　　　　if(p->next==NULL)
　　　　　　p=p->next;
　　　　else
　　　　　　p=p->next->next;
　　}
　　return head;
}

void main()
{

　　 linklist *head;
　　head=creatlist();
　　print(head);
　　//以下两行是逆序打印
　　head= back_linklist(head);
　　print(head);
　　//以下两行是奇数位逆序打印
　　head= reverse_linklist(head);
　　print(head);
　　system("pause");
}

显示结果：