线性表——顺序表的定义和基本操作

静态分配的顺序表实现代码

#include<stdio.h>
#include<iostream>
#define Maxsize 20
using namespace std;
typedef struct{              //静态分配的顺序表 
	int data[Maxsize];   
	int length;            //顺序表的当前长度 
}Sqlist;    //顺序表的类型定义（结构体） 
//对数据的基本操作，创建，销毁，增删改查 ，其他便捷操作如求表长，判空等 
void InitList(Sqlist &L)    
{
	for(int i=0;i<Maxsize;i++)
	  L.data[i]=0;
	L.length=0;	
}
void Destroy(Sqlist &L)
{
	
}
bool ListInsert(Sqlist &L,int i,int e) //平均时间复杂度O(n)    最好O(1) 最坏O(n) 
{
	if(i<1||i>L.length+1)   //允许向空表中插，i为次序，不对应数组下标
	   return false;
	if(L.length>=Maxsize)
	   return false; 
	
	for(int j=L.length;j>=i;j--)
	   L.data[j]=L.data[j-1];
	L.data[i-1]=e; 
	L.length++;
	return true;
}
bool ListDelete(Sqlist &L,int i,int &e)//平均时间复杂度O(n)    最好O(1) 最坏O(n)
{
	if(i<1||i>L.length+1)  
	   return false;
	e=L.data[i-1];      //将被删除的元素赋值给e 
	for(int j=i;j<L.length;j++)
	   L.data[j-1]=L.data[j]; 
	L.length--;
	return true;
	
}
int LocateElem(Sqlist L,int e)  //按值查找    //平均时间复杂度O(n)    最好O(1) 最坏O(n)
{
	for(int i=0;i<L.length;i++)
    	if(L.data[i]==e)
    	   return i+1;
    return 0;
	
}
int GetElem(Sqlist L,int i)     //按位查找       时间复杂度O(1) 
{
	if(i<1||i>L.length+1)  
	   return false; 
	
	return L.data[i-1]; //注意区分 位序和数组下标 
}
void Show(Sqlist L)
{
	for(int i=0;i<L.length;i++)
	{
		printf("%d ",L.data[i]); 
	} 
	printf("\nLength: %d\n",L.length); 
}
int main()
{
	Sqlist L;   //声明一个线性表 
	InitList(L);   //初始化顺序表 
	ListInsert(L,1,2);   //插入时i的值很可能不合法 
	ListInsert(L,2,3);
	ListInsert(L,3,5);
	ListInsert(L,1,7);
	Show(L);
	int e=-1;
	if(ListDelete(L,1,e))
	   printf("已删除第1个元素，删除元素值为 %d\n",e);
	else
	  printf("删除位序不合法，删除失败\n"); 
	Show(L);
	printf("\n数字5在顺序表L中的位置为 %d\n",LocateElem(L,5));
	printf("顺序表L中位置为2的元素为 %d\n",GetElem(L,2));
	return 0; 
} 

动态分配的顺序表实现代码

#include<stdio.h>
#include<cstdlib>
#include<iostream>
#define InitSize 10
using namespace std; 
//对数据的基本操作，创建，销毁，增删改查 ，其他便捷操作如求表长，判空等 
typedef struct{
	int *data;
	int Maxsize;   //顺序表的最大容量 
	int length; //顺序表的当前长度 
}SeqList; //动态分配方式
 
void InitList(SeqList &L)
{
	//用malloc函数申请一片连续的存储空间
	L.data=(int *)malloc(InitSize*sizeof(int)); //malloc函数返回的存储空间地址需要转换为与数据元素类型相对应的指针 
	L.length=0;
	L.Maxsize=InitSize; 
 } 

bool ListInsert(SeqList &L,int i,int e) //平均时间复杂度O(n)    最好O(1) 最坏O(n) 
{
	if(i<1||i>L.length+1)   //允许向空表中插，i为次序，不对应数组下标
	   return false;
	if(L.length>=InitSize)
	   return false; 
	
	for(int j=L.length;j>=i;j--)
	   L.data[j]=L.data[j-1];
	L.data[i-1]=e; 
	L.length++;
	return true;
}
bool ListDelete(SeqList &L,int i,int &e)//平均时间复杂度O(n)    最好O(1) 最坏O(n)
{
	if(i<1||i>L.length+1)  
	   return false;
	e=L.data[i-1];      //将被删除的元素赋值给e 
	for(int j=i;j<L.length;j++)
	   L.data[j-1]=L.data[j]; 
	L.length--;
	return true;
	
}
int LocateElem(SeqList L,int e)  //按值查找    //平均时间复杂度O(n)    最好O(1) 最坏O(n)
{
	for(int i=0;i<L.length;i++)
    	if(L.data[i]==e)
    	   return i+1;
    return 0;
	
}
int GetElem(SeqList L,int i)     //按位查找       时间复杂度O(1) 
{
	if(i<1||i>L.length+1)  
	   return false; 
	
	return L.data[i-1]; //注意区分 位序和数组下标 
}
void Show(SeqList L)
{
	for(int i=0;i<L.length;i++)
	{
		printf("%d ",L.data[i]); 
	} 
	printf("\nLength: %d\n",L.length); 
}
int main()
{
	SeqList L;   //声明一个线性表 
	InitList(L);   //初始化顺序表 
	ListInsert(L,1,2);   //插入时i的值很可能不合法 
	ListInsert(L,2,3);
	ListInsert(L,3,5);
	ListInsert(L,1,7);
	Show(L);
	int e=-1;
	if(ListDelete(L,1,e))
	   printf("已删除第1个元素，删除元素值为 %d\n",e);
	else
	  printf("删除位序不合法，删除失败\n"); 
	Show(L);
	printf("\n数字5在顺序表L中的位置为 %d\n",LocateElem(L,5));
	printf("顺序表L中位置为2的元素为 %d\n",GetElem(L,2));
	return 0;
} 

代码运行结果