顺序表的基本操作

#include <iostream>
#include <time.h> 
#include <stdlib.h>
using namespace std;
typedef int dataType;  //定义数据类型

typedef struct List{
	dataType *data;
	int listSize;  //顺序表当前分配空间的元素个数
	int length;  //顺序表当前的元素个数
}SList;
typedef SList *pSList;  //定义一个SList类型指针


//创建一个顺序表，返回一个SList类型指针
pSList CreateSList()
{
	dataType value;
	int i=0,num=0;
	pSList l=(SList*)malloc(sizeof(SList));  //为SList结构体指针申请内存空间
	dataType *newbase;
	l->listSize=5;
	l->data=(dataType*)malloc(sizeof(dataType)*l->listSize);  //初始分配5个数据单位内存空间
	cout<<"please input all num:";
	cin>>num;
	cout<<"please input data(space):";
	while(i<=num-1)
	{
		cin>>value;
		if(i+1>l->listSize)  //如果顺序表内存不够，继续申请内存空间
		{
			newbase=(dataType*)realloc(l->data,sizeof(dataType)*(l->listSize+5)); 
			if (!newbase)
			{
				exit(1);
			}
			l->data=newbase;
			l->listSize+=5;  //更新顺序表的内存空间数据单位
		}
		l->data[i]=value;
		i++;
	}
	l->length=i;  //记录顺序表添加的元素个数
	return l;
}

//创建一个顺序表，返回一个SList类型指针
pSList CreateSList_1_9_random()
{
	int i=0,num=9;
	pSList l=(SList*)malloc(sizeof(SList));  //为SList结构体指针申请内存空间
	dataType *newbase;
	l->listSize=5;
	l->data=(dataType*)malloc(sizeof(dataType)*l->listSize);  //初始分配5个数据单位内存空间
	srand( (unsigned)time( NULL ) );
	while(i<=num-1)
	{
		if(i+1>l->listSize)  //如果顺序表内存不够，继续申请内存空间
		{
			newbase=(dataType*)realloc(l->data,sizeof(dataType)*(l->listSize+5)); 
			if (!newbase)
			{
				exit(1);
			}
			l->data=newbase;
			l->listSize+=5;  //更新顺序表的内存空间数据单位
		}
		l->data[i]=1+rand()%9;
		i++;
	}
	l->length=i;  //记录顺序表添加的元素个数
	return l;
}

//创建一个顺序表，返回一个SList类型指针
pSList CreateSList_1_9_order()
{
	int i=0,num=9;
	pSList l=(SList*)malloc(sizeof(SList));  //为SList结构体指针申请内存空间
	dataType *newbase;
	l->listSize=5;
	l->data=(dataType*)malloc(sizeof(dataType)*l->listSize);  //初始分配5个数据单位内存空间
	while(i<=num-1)
	{
		if(i+1>l->listSize)  //如果顺序表内存不够，继续申请内存空间
		{
			newbase=(dataType*)realloc(l->data,sizeof(dataType)*(l->listSize+5)); 
			if (!newbase)
			{
				exit(1);
			}
			l->data=newbase;
			l->listSize+=5;  //更新顺序表的内存空间数据单位
		}
		l->data[i]=i+1;
		i++;
	}
	l->length=i;  //记录顺序表添加的元素个数
	return l;
}

//输出顺序表
void Output(pSList l)
{
	cout<<"length:"<<l->length<<endl;
	cout<<"SList:";
	for (int i=0;i<l->length;i++)
	{
		cout<<l->data[i]<<" ";
	}
	cout<<endl<<endl;
}

//根据元素值查找这个元素在顺序表中的对应位置（从1开始）
int FindLocByValue(pSList l,dataType value)
{
	for (int i=0;i<=l->length-1;i++)
	{
		if (value==l->data[i])
		{
			return i+1;  //下标值加1
		}
	}
	return 0;
}

//在顺序表的指定位置插入一个元素
int InsertDataByLoc(pSList l,int loc,dataType value)
{
	if (loc<1 || loc>l->length)
	{
		cout<<"loc not exist"<<endl;
		return 0;
	}
	if (l->length==l->listSize)  //如果顺序表的内存空间已满，就再申请内存空间
	{
		dataType *newBase=(dataType*)realloc(l->data,sizeof(dataType)*(l->listSize+5));
		l->data=newBase;
		l->listSize+=5;
	}
	for (int i=l->length-1;i>=loc-1;i--)  //先将loc后面的元素逆序依次向后移动以为
	{
		l->data[i+1]=l->data[i];
	}
	l->data[loc-1]=value;  //在loc位置即下标loc-1插入元素值
	l->length+=1;  //顺序表长度加1
	return 1;
}

//删除指定位置的元素
int DeleteByLoc(pSList l,int loc)
{
	if (loc<1 || loc>l->length)
	{
		cout<<"loc not exist"<<endl;
		return 0;
	}
	for (int i=loc;i<=l->length-1;i++)  //先将loc位置后面的元素顺序向前移动一位
	{
		l->data[i-1]=l->data[i];
	}
	l->length-=1;  //顺序表长度减1
	return 1;
}

//删除顺序表中的最小值
void DeleteMinValue(pSList l)
{
	int min_data=l->data[0];  //存储最小数据值
	int min_index=0;  //存储最小数据值元素的小标
	for(int i=1;i<=l->length-1;i++)
	{
		if (l->data[i]<min_data)
		{
			min_data=l->data[i];
			min_index=i+1;
		}
	}
	DeleteByLoc(l,min_index+1);  
}

//逆置顺序表
void ReverseSList(pSList l)
{
	dataType temp;
	for (int i=0;i<=(l->length-1)/2;i++)  //依次将对称位置元素值交换
	{
		temp=l->data[i];
		l->data[i]=l->data[l->length-1-i];
		l->data[l->length-1-i]=temp;
	}
}

//删除顺序表中所有值为value的元素
void DeleteAllValue(pSList l,dataType value)
{
	for (int i=0;i<=l->length-1;i++)  //依次遍历，遇到一个删除一个
	{
		if (l->data[i]==value)
		{
			DeleteByLoc(l,i+1);
		}
	}
}

//删除顺序表中所有值为value的元素
void DeleteAllValue2(pSList l,dataType value)
{
	int loc=0;  //可以看做是重新构造顺序表插入的位置，也可以看做是满足条件的元素个数
	for (int i=0;i<=l->length-1;i++)
	{
		if (l->data[i]!=value)  //如果不是要删除的元素，就插入到loc位置，并将loc向下移动一个位置
		{
			l->data[loc]=l->data[i];
			loc+=1;
		}
	}
	l->length=loc;  //更新顺序表的长度
}

//从顺序表中删除值在s和t（不包括s和t）之间的元素
void DeleteST(pSList l,dataType s,dataType t)
{
	int loc=0; //可以看做是重新构造顺序表插入的位置，也可以看做是满足条件的元素个数
	for (int i=0;i<=l->length-1;i++)
	{
		if (l->data[i]<=s || l->data[i]>=t)  //如果不是要删除的元素，就插入到loc位置，并将loc向下移动一个位置
		{
			l->data[loc]=l->data[i];
			loc+=1;
		}
	}
	l->length=loc;
}

//从有序顺序表中删除值在s和t（不包括s和t）之间的元素
void DeleteST_Order(pSList l,dataType s,dataType t)
{
	int i,j;
	for (i=0;i<=l->length-1;i++)
	{
		if (l->data[i]>s)
		{
			break;
		}
	}
	for (j=i;i<=l->length-1;j++)
	{
		if (l->data[j]>=t)
		{
			break;
		}
	}
	for (;j<=l->length-1;i++,j++)
	{
		l->data[i]=l->data[j];
	}
	l->length=i;  //更新顺序表长度
}

int main()
{
	pSList l=CreateSList_1_9_random();
	Output(l);

	//int loc;
	//if((loc=FindLocByValue(l,7))!=0)
	//{
	//	cout<<loc<<endl;
	//}
	//else{
	//	cout<<"not exist"<<endl;
	//}

	//InsertDataByLoc(l,3,111);
	//Output(l);

	//DeleteByLoc(l,3);
	//Output(l);

	//DeleteMinValue(l);
	//Output(l);

	//ReverseSList(l);
	//Output(l);

	//DeleteAllValue2(l,5);
	//Output(l);

	//DeleteST(l,3,6);
	//Output(l);

	//DeleteST_Order(l,2,6);
	//Output(l);

	system("pause");
	return 1;
}