线性表的顺序储存及运算实现

 

//线性表的顺序储存及运算实现-------------顺序表

#include <iostream>
//#include <stdlib>

using namespace std;

#define MAXSIZE 100
#define N 30
#define M 40

//若是其他的数据类型，直接修改这里就可以了
typedef int DataType ;

/
//顺序表的定义
typedef struct node
{
DataType data[MAXSIZE];
int length; //顺序表最后一个单元，表示数据长度
} SeqList ;

//定义指针，实现信息的回送
typedef SeqList* PSeqList;

/
//顺序表基本运算的实现
//--------------------------------------------------------------------------------
//顺序表的初始化
PSeqList Init_SeqList()
{
//返回一个指向顺序表的指针，指针为NULL表示分配空间失败
PSeqList SeqListPoint=new SeqList;
//若分配成功，设置空表，否则返回NULL
if(SeqListPoint)
{
SeqListPoint->length=0;
return SeqListPoint;
}
else 
{
cout<<"分配空间失败！"<<endl;
return NULL;
}
}

PSeqList Init_SeqList(DataType dataArray[],int dataArraySize)
{
//返回一个指向顺序表的指针，指针为NULL表示分配空间失败
PSeqList SeqListPoint=new SeqList;
//若分配成功，设置空表，否则返回NULL
if(SeqListPoint)
{
if(dataArraySize>MAXSIZE)
{
cout<<"填充顺序表数据大于最大存放数据，无法完成填充！"<<endl;
return NULL;
}
for(int i=0;i<dataArraySize;i++)
{
SeqListPoint->data[i]=dataArray[i];
}
SeqListPoint->length=dataArraySize;
return SeqListPoint;
}
else 
{
cout<<"分配空间失败！"<<endl;
return NULL;
}
}

//顺序表的销毁
bool Destory_SeqList(PSeqList* SeqListPoint)
{
//要销毁顺序表指针的地址，无返回值
if(*SeqListPoint)
{
delete(*SeqListPoint);
//*SeqListPoint=NULL;
return true;
}
else
return false;
}

//求顺序表的长度
int Length_SeqList(PSeqList SeqListPoint)
{
//入口参数：顺序表指针，返回表长，-1表示表不存在
if(SeqListPoint)
{
return (SeqListPoint->length);
}
else 
{
cout<<"表不存在！"<<endl;
return -1;
}

}


//输出顺序表数据元素
void PrintData_SeqList(PSeqList SeqListPoint)
{
//入口参数：顺序表指针
if(!SeqListPoint)
{
cout<<"表不存在!"<<endl;
return ;
}
if(SeqListPoint->length==0)
{
cout<<"表中无元素！"<<endl;
return ;
}
for(int i=0;i<SeqListPoint->length;i++)
{
cout<<SeqListPoint->data[i]<<" ";
}
cout<<endl;
return ;
}




//顺序表的检索(查找)操作
int Location_SeqList(PSeqList SeqListPoint ,DataType dataX)
{
//入口参数：要查找的顺序表指针，检索的数据，返回值：-1（表不存在），0（失败）
int i;
if(!SeqListPoint)
{
cout<<"表不存在！"<<endl;
return -1;
}
else
{
for(i=0;i<SeqListPoint->length;i++)
{
if(SeqListPoint->data[i]==dataX)
{
return (i+1);
}
}
if(i==SeqListPoint->length)
{
cout<<"查找失败！"<<endl;

}
return 0;
}

}

//顺序表的插入操作
int InsertData_SeqList(PSeqList SeqListPoint,int i , DataType dataX)
{
//入口参数：顺序表指针，插入位置，插入的元素。返回标志1成功，0插入位置不合法，-1溢出，-2表示表不存在
if(!SeqListPoint)
{
cout<<"表不存在"<<endl;
return -2;
}
if( i<=0 || i >MAXSIZE)
{
cout<<"插入位置不合法！"<<endl;
return 0;
}

for(int j=SeqListPoint->length-1;j>=i-1;j--)
{
SeqListPoint->data[j+1]=SeqListPoint->data[j]; // 注意：一定不能是j++，而必须是j+1
}
SeqListPoint->data[i-1]=dataX;
SeqListPoint->length++;

if(SeqListPoint->length>MAXSIZE)
{
cout<<"表满,溢出！"<<endl;
return -1;
}
return 1;
}

//顺序表的删除运算
int Del_SeqList(PSeqList SeqListPoint,int i)
{
//入口参数：顺序表指针，删除元素的位置。返回参数：1成功，0删除位置不合法，-1表不存在
if(!SeqListPoint)
{
cout<<"表不存在！"<<endl;
return -1;
}
if(i<0||i>SeqListPoint->length)
{
cout<<"删除位置不合法！"<<endl;
return 0;
}
for(int j=i-1;j<=SeqListPoint->length-1;j++)
{
SeqListPoint->data[j]=SeqListPoint->data[j+1]; // 注意：一定不能是j++，而必须是j+1
}
SeqListPoint->length--;
return 1;
}

//对顺序表数据元素降序排列
int SortDec_SeqList(PSeqList SeqListPoint)
{
//入口参数：顺序表指针，成功返回1，表不存在返回-1。
if(!SeqListPoint)
{
cout<<"表不存在！"<<endl;
return -1;
}

//用选择法排序
for(int i=0;i<SeqListPoint->length-1;i++)
{
DataType Temp;
DataType MAX=SeqListPoint->data[i];
int iMAX=i;

for(int j=i+1;j<SeqListPoint->length;j++)
{
if(SeqListPoint->data[j]>MAX)
{
MAX=SeqListPoint->data[j];
iMAX=j;
}
}
Temp=SeqListPoint->data[iMAX];
SeqListPoint->data[iMAX]=SeqListPoint->data[i];
SeqListPoint->data[i]=Temp;
}
return 1;
}

//对顺序表数据元素升序排列
int SortInc_SeqList(PSeqList SeqListPoint)
{
//入口参数：顺序表指针，成功返回1，表不存在返回-1。
if(!SeqListPoint)
{
cout<<"表不存在！"<<endl;
return -1;
}

//用选择法排序
for(int i=0;i<SeqListPoint->length-1;i++)
{
DataType Temp;
DataType MIN=SeqListPoint->data[i];
int iMIN=i;

for(int j=i+1;j<SeqListPoint->length;j++)
{
if(SeqListPoint->data[j]<MIN)
{
MIN=SeqListPoint->data[j];
iMIN=j;
}
}
Temp=SeqListPoint->data[iMIN];
SeqListPoint->data[iMIN]=SeqListPoint->data[i];
SeqListPoint->data[i]=Temp;
}
return 1;
}


/
//顺序表应用举例
//-------------------------------------------------------------------------------------------

// 1、 将一线性表逆置,有一线性表的顺序表示（a1,a2,a3,.....an),设计一算法将该线性表逆置为逆线性表（an,an-1,....a3,a2,a1),要求用
// 最小辅助空间
int Reverse_SeqList(PSeqList SeqListPoint)
{
//入口参数：一顺序表指针。返回值：1成功，-1表不存在，0为空表
if(!SeqListPoint)
{
cout<<"表不存在!"<<endl;
return -1;
}
if(SeqListPoint->length==0)
{
cout<<"为空表！"<<endl;
return 0;
}
for(int i=0;i<=(SeqListPoint->length/2);i++) //注意不是length+1/2;
{
DataType Temp;
Temp=SeqListPoint->data[i];
SeqListPoint->data[i]=SeqListPoint->data[SeqListPoint->length-1-i]; //注意是length-1-i
SeqListPoint->data[SeqListPoint->length-i-1]=Temp;
}
return 1;
}

// 2. 有顺序表A和B，其元素均按从小到大升序排列，编写一算法将他们合并成一个表C，要求C的元素也是从小到大排列
int Merge_SeqList(PSeqList SeqListPointA,PSeqList SeqListPointB,PSeqList SeqListPointC)
{
//入口参数：顺序表A，B,C指针。返回值，-1A或B表不存在，-2C溢出，1成功
//算法思想：依次扫描AB，并比较它们的大小，将他们较小值赋值给C
if(!SeqListPointA || !SeqListPointB)
{
cout<<"A或B表不存在！"<<endl;
return -1;
}
if(SeqListPointA->length+SeqListPointB->length>MAXSIZE)
{
cout<<"溢出！"<<endl;
return -2;
}
SortInc_SeqList(SeqListPointA);
SortInc_SeqList(SeqListPointB); //应想对他们进行升序排列
int i=0,j=0,k=0;
//循环比较
while(i<=SeqListPointA->length-1&&j<=SeqListPointB->length-1)
{
if(SeqListPointA->data[i] < SeqListPointB->data[j])
{
SeqListPointC->data[k++]=SeqListPointA->data[i++];
}
else
{
SeqListPointC->data[k++]=SeqListPointB->data[j++];
}
}
//将余下的部分直接赋值给表C
while(i<SeqListPointA->length)
{
SeqListPointC->data[k++]=SeqListPointA->data[i++];
}
while(j<SeqListPointB->length)
{
SeqListPointC->data[k++]=SeqListPointB->data[j++];
}
//k的值即为表长
SeqListPointC->length=k;
return 1;
}