顺 序 表

• 静态（结构体 . ）
• 静态（指针->）
• 动态(结构体 . )

//###############################################################################################
//###########################################静态（结构体  . ）################################################
//###############################################################################################
//###############################################################################################
#include
#include 
#define maxsize 100
typedef struct
{
	char data[maxsize];
	int length;
}sqlist;
//============================================初始化==========================================
void Initlist(sqlist &L)
{
	for(int i=0;iL.length+1)return false;
	if(L.length>=maxsize)return false;
	for(int i=L.length;i>=point;i--)
	{
		L.data[i]=L.data[i-1];
	}
	L.data[point-1]=x;
	L.length++;
}
//=======================================正常删除链表================================ 
bool deletlist(sqlist &L,int point,char &e)
{
	if(point<1||point>L.length)return false;
	e=L.data[point-1];
	for(int i=point;i<=L.length-1;i++)
	{
		L.data[i]=L.data[i+1];
	}
	L.length--;
}
//==========================================按位查找====================================== 
void getelem(sqlist L,int point,char &e)
{
	e=L.data[point-1];
}
//==========================================按值查找====================================== 
int getpoint(sqlist L,char x)
{
	for(int i=0;i 
静态（指针->） 
//###############################################################################################
//###########################################静态（指针->）################################################
//###############################################################################################
//###############################################################################################
#include
#include
#define maxsize 100
typedef struct
{
	char data[maxsize];
	int length;
}node,*list;

//============================================初始化========================================== 
void Initlist(list &L)
{
	L=(node*)malloc(sizeof(node));
	L->length=0;
}
//=============================================销毁================================================= 
void DestroyList(list L)		
{
	free(L);
}
//=======================================正常插入链表=============================== 
bool insertlist(list &L,int point,char x)
{
	if(point<0||point>L->length+1)return false;
	if(L->length >=maxsize)return false;
	
	for(int i=L->length;i>=point;i-- )
	L->data[i]=L->data[i-1];
	
	L->data [point-1]=x;
	L->length++;
}
//=======================================正常删除链表================================ 
bool deletlist(list &L,int point,char &e)
{
	if(point<1||point>L->length)return false;
	e=L->data[point-1];	
	for(int i=point;ilength;i++)
	{
		L->data[i-1]=L->data[i];
	}
	L->length--;
	return true;
} 
//=========================================按位查找============================== 
void getelem(list L,int point,char &e)
{
	e=L->data[point-1];
}
//========================================按值查找================================ 
int getpoint(list L,char x)
{
	for(int i=0;ilength;i++)
	{
		if(L->data[i]==x)return i+1;
	}
	return -1;
}
//=========================================长度================================================ 
int getlength(list L)
{
	return L->length;
}
//=========================================是否空============================================= 
bool empty(list L)
{
	if(L->length==0)return true;
	return false;
}

//============================================尾插=============================================
void insert(list &L,char x)
{
	L->data[L->length++]=x;
	
}
//===========================================打印链表 ======================================
void printlist(list &L)
{
	for(int i=0;ilength;i++)
	{
		printf("%c ",L->data[i]);
	}
	printf("n");
}
int main()
{
	list L;
	Initlist(L);
	printf("=================================依次采用尾插法插入 a、b、c、d、e 元素==================================================n");
	insert(L,'a');
	insert(L,'b');
	insert(L,'c');
	insert(L,'d');
	insert(L,'e');
	printlist(L);
	printf("=================================输出顺序表 L 的长度=====================================================n");
	printf("%dn",getlength(L));
	printf("==================================判断顺序表 L 是否为空==================================================n");
	if(empty(L))printf("空n"); 
	else printf("不空n"); 
	printf("==================================输出顺序表 L 的第 3 个元素==============================================n");
	char e;
	getelem(L,3,e);
	printf("%cn",e);
	printf("==================================输出元素 a 的位置========================================================n");
	if(getpoint(L,'a')==-1)printf("不存在该元素n");
	else printf("%dn",getpoint(L,'a'));
	printf("===================================在第 4 个元素位置上插入 f 元素==========================================n");
	insertlist(L,4,'f');
	printlist(L);
	printf("===================================删除 L 的第 3 个元素====================================================n");
	deletlist(L,3,e);
	printlist(L);
	printf("====================================操作free()========================================n");
	DestroyList(L);
}


 
动态(结构体 . ) 
//###############################################################################################
//###########################################动态(结构体  . )################################################
//###############################################################################################
#include
#include 
#define IncreaseSize 10   //增加长度 
#define InitSize 100      //默认最大长度
typedef struct
{
	char* data;      //指向第一个元素的地址 
	int MaxSize;    //顺序表最大长度 
	int length;     //顺序表当前长度	
}SeqList;  
//==========================================初始化============================================= 
bool InitList(SeqList &L)
{
	//使用malloc函数申请一片连续的空间
	L.data = (char* )malloc(InitSize*sizeof(char));
	if(L.data==NULL)return false;
	L.length=0;
	L.MaxSize=InitSize;
	return true;
}
//=======================================结构体没有free======================================== 
void DestroyList(SeqList L)		
{
	
}
//=======================================正常插入链表=======================================
bool ListInsert(SeqList &L,int i,char e) 
{
	if(i<1||i>L.length+1)return false;		//i属于[1~length+1]
	
	if(L.length >= L.MaxSize) 
	{
		char* newbase=(char*)realloc(L.data,(L.length+IncreaseSize)*sizeof(char));
		if(newbase==NULL)return false;
		L.data=newbase;
		L.MaxSize+=IncreaseSize;
	}
										
	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,char &e) 
{
	if(i<1||i>L.length)return false;		//删除[1~length]中的 
	e=L.data[i-1];                          //删除元素赋值给e  
	for(int j=i ;j