数据结构上机第一次_2就地逆置（顺序表/单链表）

数据结构上机第一次_2就地逆置（顺序表/单链表）

题目

2．设元素值为整型的线性表L，分别采用顺序结构和链式结构存储，编写函数，实现线性表的就地逆置（书P31 4）。

代码

（1）顺序结构

//设元素值为整型的线性表L，分别采用顺序结构和链式结构存储，编写函数，实现线性表的就地逆置
//顺序结构 
#include<iostream>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define PARA_ERROR 0
//#define OVERFLOW -2
#define LISTINITSIZE 256    //初次分配空间大小
#define LISTINCREMENT 128    //空间分配增量大小 
typedef int ElemType;
typedef int Status;
typedef struct Seqlist 
{
	ElemType *pdata;	   //动态存储空间的基地址 
	int length;    //存储数据元素的个数
	int size;	//当前已分配的存储空间大小 
}Seqlist;

Status InitList(Seqlist &L)
{
	//初始化顺序表 
    L.pdata=(ElemType*) malloc (LISTINITSIZE*sizeof(ElemType));	//申请存储空间 
    if(L.pdata==NULL)
    	exit (OVERFLOW);    //存储空间申请失败
	L.size=LISTINITSIZE;
	L.length=0;
	//cout<<"初始化成功！"<<endl; 
	return OK; 
}

Status CreateList(Seqlist &L)
{
	//创建顺序表
	cout<<"请输入顺序表长度：";
	cin>>L.length;
	cout<<"请输入顺序表元素：";
	for(int i=0;i<L.length;i++)
	{
		cin>>L.pdata[i];
	}
	cout<<"顺序表建立成功！"<<endl;
	return OK;	 
}

Status ListTraverse(Seqlist L)
{
	//遍历顺序表并依次输出其数据元素
	for(int i=0; i<L.length; i++)
	{
		cout<<L.pdata[i]<<" ";
	}
	cout<<endl;
	return 0;
} 

void ReverseList(Seqlist &L)
{
	int t;
	if(L.length%2==0)    //顺序表元素个数为偶数 
	{
		for(int i=0;i<L.length/2;i++)
		{
			t=L.pdata[i];
			L.pdata[i]=L.pdata[L.length-i-1];
			L.pdata[L.length-i-1]=t;
		}
	}
	else if(L.length%2==1)    //顺序表元素个数为奇数
	{
		for(int i=0;i<(L.length-1)/2;i++)
		{
			t=L.pdata[i];
			L.pdata[i]=L.pdata[L.length-i-1];
			L.pdata[L.length-i-1]=t;
		}
	} 
}

int main()
{
	Seqlist L;
	InitList(L);    //初始化 
	CreateList(L);    //建立 
	cout<<"顺序表元素为："<<endl;
	ListTraverse(L);    //原序输出 
	ReverseList(L);    //逆置 
	cout<<"逆置后的顺序表元素为："<<endl;
	ListTraverse(L);    //逆置输出
	return 0; 
}

（2）链式结构

//设元素值为整型的线性表L，分别采用顺序结构和链式结构存储，编写函数，实现线性表的就地逆置
//单链表：头插法 
#include<iostream>
#include<stdlib.h>
#include<malloc.h>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define PARA_ERROR 0
#define OVERFLOW -2
typedef int ElemType;
typedef int Status;
typedef struct LNode
{
	ElemType data;    //数据域
	struct LNode *next;    //指针域
}LNode, *LinkList; 

Status InitList(LinkList &L)
{
	//1初始化单链表
    L=(LNode*) malloc (sizeof(LNode));    //申请头结点存储空间 
    if(L==NULL) exit(OVERFLOW);    //存储空间申请失败
	L->next=NULL;
	//cout<<"初始化成功！"<<endl;
	return OK;	 
}

Status ListLength(LinkList L)
{
	//6单链表长度
	int n=0;
	LNode *p;
	p=L->next;
	while (p)
	{
		n++;
		p=p->next;
	}
	return(n);
}

Status InsertElem(LinkList &L, int i, ElemType e)
{
	//13在第i个位置插入e
	LNode *s=(LNode*)malloc(sizeof(LNode));    //申请新的节点s
	if(s==NULL) exit(OVERFLOW);    //申请节点失败 
	s->data=e;
	LNode *p;
	p=L->next;
	if(i==1)
	{
		s->next=p;
		L->next=s;
	}
	else if(i>1&&i<=ListLength(L))
	{
		for(int j=0;j<i-2;j++)
		{
			p=p->next;
		}
		s->next=p->next;
		p->next=s;
	}
	else if(i==ListLength(L)+1)
	{
		for(int j=0;j<i-2;j++)
		{
			p=p->next;
		}
		p->next=s;
		s->next=NULL;
	}
	else
	{
		cout<<"表中没有该位置！"<<endl;
	}
	return OK;
}

Status CreateList(LinkList &L)
{
	//2建立单链表
	int i,len=0;
	ElemType e;
	cout<<"请输入单链表长度:";
	cin>>len;
	cout<<"请输入单链表元素数据:";
	for(i=1;i<len+1;i++)
	{
		cin>>e;
		InsertElem(L,i,e);
	}
	return OK;
}

Status ListTraverse(LinkList L)
{
	//11遍历单链表
	LNode *p;
	p=L->next;
	while(p)
	{
		cout<<p->data<<" ";
		p=p->next;
	}
	cout<<endl;
	return OK;
}

LinkList ReverseList(LinkList &L)
{
	//头插法实现就地逆置
	LNode *p, *q;    //p为工作指针，q为p的后继
	p=L->next;
	L->next=NULL;    //先把头结点分离出来(?) 
	while(p)
	{
		q=p->next;
		p->next=L->next;
		L->next=p;    //把p插在头结点之后 
		p=q;    //循环操作，依次把每个节点插在头结点之后，实现逆置 
	}
	return L;
}

int main()
{
	LinkList L;
	InitList(L);
	CreateList(L);
	cout<<"单链表原序为："<<endl;
	ListTraverse(L);
	ReverseList(L);
	cout<<"单链表逆置后为："<<endl;
	ListTraverse(L);
	return 0; 
}

思想

单链表就地逆置运用头插法