《单链表的逆置（实现了假逆置）》

/*
首先创建并初始化一个带头结点的单链表和一个空栈，依次把单链表中的元素取出压入栈中，在依次输出
栈中的元素，就会和单链表中的元素顺序相反，但实际上这是假逆置，单链表中的数据顺序并没有改变。
*/

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define NULL 0
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
typedef int ElemType;
typedef struct LNode
{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode,*LinkList;

typedef struct
{
ElemType *top;
ElemType *base;
ElemType stacksize;
}SqStack;

//(头插法)逆序输入n个元素的值，创建一个带头结点的单链表L
void CreatList_L(LinkList &L,int n)
{
int i;
LNode *p;
L = (LinkList)malloc(sizeof(LNode));
L->data = 0; //令头结点中的数据域内容为0（即表的长度为0），头结点中的数据域记录了表的长度
L->next = NULL; //建立一个带头结点的单链表L
printf("请逆序输入单链表中的数据: ");
for(i = n;i>0;--i)
{
p = (LinkList)malloc(sizeof(LNode)); //生成新结点
scanf("%d",&p->data);
p->next = L->next;
L->next = p; //新结点插入到表头
L->data++; //增加表长
}
}

//创建一个空栈
//栈的创建
Status CreatStack(SqStack &s)
{
s.base = (ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
if(!s.base) exit(OVERFLOW);
s.top = s.base;
s.stacksize = STACK_INIT_SIZE;
return OK;
}

//------带表头结点的遍历
Status Traverse_L(LinkList L)
{
LNode *p = L->next;
printf("This list contains %d elements ",L->data);
while(p) //不能写成while(p->next)
{
printf("%3d->",p->data);
p = p->next;
}
printf("NULL ");
return OK;
}

//压栈操作
Status Push(SqStack &s,ElemType e)
{
if(s.top - s.base >= s.stacksize)
//栈满，追加空间
{ s.base = (ElemType *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(ElemType));
if(!s.base)
exit(OVERFLOW);
s.top = s.base+s.stacksize;
s.stacksize+=STACKINCREMENT;
}
*s.top = e;
s.top++;
return OK;
}

//------求带表头结点的单链表的表长
int Length_L(LinkList L)
{
int num = 0;
LNode *p = L->next;
while(p)
{
num++;
p = p->next;
}
return num;
}

//得到栈顶的元素
Status GetTop(SqStack s,ElemType &e)
{
if(s.top == s.base)
return ERROR;
e = *(s.top - 1);
return e;
}

//定义StackLength(SqStck &s)
Status StackLength(SqStack &s)
{
return (s.top - s.base);
}

//定义Pop函数
Status Pop(SqStack &s,ElemType &e)
{
if(s.top == s.base) return ERROR;
--s.top;
e = *s.top;
return e;
}

int main()
{
LinkList L;
SqStack s;
int n,i,e;
//创建一个带头结点的单链表
printf("用头插法创建一个单链表,");
printf("请输入初始单链表的长度：");
scanf("%d",&n);
CreatList_L(L,n);
printf("初始表长为%d: ",Length_L(L));
Traverse_L(L);
printf(" ");

//创建一个空栈
CreatStack(s);
//压栈操作
printf("进行压栈操作中... ");
LinkList p;
p = L->next;
while(p)
{
Push(s,p->data);
p = p->next;
}
printf("栈的长度为：%d",StackLength(s));
printf(" ");
//得到栈顶元素
printf("栈顶元素是:%d",GetTop(s,e));
printf(" ");

printf(" 对单链表的逆置如下 ");
for(i=StackLength(s);i>0;i--)
{
printf("%3d->",Pop(s,e));
}
printf("NULL ");
printf("这个程序实现了单链表中元素的假逆置， ");
printf("可以用Traverse_L(LinkList L)函数验证 ");
printf("逆置后单链表中的数据如下... ");
Traverse_L(L);
printf(" ");
return 0;
}