C语言可变长顺序表学习 （一个编程笨蛋写的~估计也没人看嘻嘻）

day1：顺序表的初始化 插入和输出（一点一点消化 搞懂每一行！）

第一块:对基本变量结构的认识

  2行： 重定义 Elemtype（element type）原因：方便顺序表表中元素的数据元素类型可变

  5行：使用指针变量 *slist原因：可变长顺序表便意味着系统给顺序表分配的空间可变，但当我们元素少时可能就分配一小块空间，要增加元素个数后面如果没有空间可分配，系统变会开辟一片新的连续存储空间 。这片空间我们不能给一个明确的名称，但是可以用一个指针变量指向这一块空间第一个元素的基地址

 第二块：顺序表的初始化

一定要有返回值，可以没有输入一定要有输出

只有初始化return 返回 1整个顺序表才可以继续进行操作 （算法的健壮性）

PS 我后续把第六行的 #define ERROR 0换成了 #define ERROR -1望周知

  13行为何参数表用 *L ：C语言本质上只有值传递，但是如果运用指针传递地址便可以做到引用传递的效果，我们对形参L进行了处理便可对实参 Sq顺序表进行初始化

14行动态内存分配的解释：malloc函数中的右（）中的内容是申请空间的字节数 init_size为所需空间，sizeof（）计算每片空间的字节数。malloc前面的（）是强制类型转换，由于顺序表中元素均为Elemtype型且L->slist为指针变量 故强制类型转换为 Elemtype型的指针变量

后续补上 15 ！L->slist   L!=NULL(L)两种表示意思相同

第三块：顺序表的插入

无需初始化一批数据的原因：一开始的插入本质上就是对最开始的数据初始化（后面自己又补充说明了一点点）

 插入算法： 1.判断插入位置是否合理

                    2.判断顺序表元素个数是否已经到达总长，如果是变要为顺序表重新分配空间

                    3.插入算法的执行

                    4.每插入一个新元素元素个数+1

                    5.要有返回值，不然无法判断插入是否成功

   realloc函数理解： realloc（）相比较于malloc（）在于（）内多写了一个L->slist 

                                原因：malloc是对顺序表初始化一片空间，而realloc是对已经初始化的一片空间的大小进行改动，所以函数内要对初始化的空间进行说明

后记对于初始化顺序表函数和插入函数是一个函数的小说明：在我们初始化的时候，InsertSq函数中for语句根本不会执行（自己要用草纸试一试），我们初始化后再插入某个数的时候for语句才会生效！

第四块：顺序表的输出

 一个简单的小循环

day1的完整源码（DEV C++编译成功！）

#include <stdio.h>
#include <stdlib.h>   //调用malloc函数需要引用该编译预处理 
#define INIT_SIZE 5
#define INCREM 3
#define OK  1
#define ERROR -1
typedef int Elemtype;
typedef struct Sqlist{
    Elemtype *slist;  //用于存放顺序表的连续单元 
    int length;       //顺序表表长 
    int listsize;     //顺序表空间大小 
}Sqlist;
 int InitSqlist(Sqlist *L) //初始化顺序表 
 { L->slist=(Elemtype*)malloc(INIT_SIZE*sizeof(Elemtype));
   if(!L->slist) return ERROR;  //初始化失败 返回0 
   L->length=0;                 //初始化成功 表中元素为0 
   L->listsize =INIT_SIZE;      //初始化成功 表长设置为宏定义的初始化数值 
   return OK;
 	
 }
 int InsertSqlist(Sqlist *L,Elemtype e,int i)   //e为插入元素  i为插入位置 
 {  if(i<1||i>L->length+1)                //判断插入位置是否合理 
   {
 	return ERROR;
   }
    if(L->length>L->listsize)       //判断元素个数是否已经超过表长 
	{
    	L->slist=(Elemtype *)realloc(L->slist,(L->listsize+INCREM)*sizeof(Elemtype));
    	if(L->slist=NULL) return ERROR;
    	L->listsize +=INCREM;
	}
	int j;  					   //插入算法的执行 
	for(j=L->length-1;j>=i-1;j--){
		L->slist[j+1]=L->slist[j];
	}
	L->slist[i-1]=e;              
	L->length ++;                //元素个数+1 
	return OK;					//返回值 
 	
 }
 void printSq(Sqlist *L) {
 	int i=0;
 	for(i;i<L->length;i++ )
 	{ 
 	   printf("%d",L->slist[i]);
 	   printf(" ");
	 }
 }
 int main(){
 	Sqlist Sq;
 	Elemtype e;
	int n;
	if(InitSqlist(&Sq))
	{ if(scanf("%d",&n)==1)
		{ int i;
		  for(i=0;i<n;i++)
		  {
		  	scanf("%d",&e);
		  	InsertSqlist(&Sq,e,i+1);
		  }
		  printSq(&Sq);
		}
	}
    return 0;
 }

day2：顺序表的查找与删除（源代码主函数相较于day1有一些改动）

1.顺序表的查找（输入查找的关键字值 输出其位序）

 较为简单的一个遍历查找（想不出来写什么啦~）

主函数的一些小变动

2.顺序表的删除（输入位序，删除元素）

 删除算法： 1.判断删除位置是否合理

                    2.删除算法的执行

                    3.每删除一个元素，元素个数--

                    5.输出返回值，判断是否删除成功

 完整源代码

#include <stdio.h>
#include <stdlib.h>   //调用malloc函数需要引用该编译预处理 
#define INIT_SIZE 5
#define INCREM 3
#define OK  1         //宏定义 OK ERROR 原因：使得代码更具可读性 
#define ERROR -1
typedef int Elemtype;
typedef struct Sqlist{
    Elemtype *slist;  //用于存放顺序表的连续单元 
    int length;       //顺序表表长 
    int listsize;     //顺序表空间大小 
}Sqlist;
 int InitSqlist(Sqlist *L);                     //顺序表初始化函数 
 int InsertSqlist(Sqlist *L,Elemtype e,int i);  //顺序表插入函数 （含初始化一批数据）
 int SearchSqlist(Sqlist *L,Elemtype e); 		//顺序表查找函数 （输入数值 输入位序）
 int DeleteSqlist(Sqlist *L,Elemtype e);        //顺序表删除函数 （输入位序删除相应元素值）
 void printSq(Sqlist *L);						//顺序表输出函数  
 
 int InitSqlist(Sqlist *L) //初始化顺序表 
 { L->slist=(Elemtype*)malloc(INIT_SIZE*sizeof(Elemtype));
   if(!L->slist) return ERROR;  //初始化失败 返回0 
   L->length=0;                 //初始化成功 表中元素为0 
   L->listsize =INIT_SIZE;      //初始化成功 表长设置为宏定义的初始化数值 
   return OK;
}

 int InsertSqlist(Sqlist *L,Elemtype e,int i)   //e为插入元素  i为插入位置 
 {  if(i<1||i>L->length+1)                //判断插入位置是否合理 
   {
 	return ERROR;
   }
    if(L->length>L->listsize)       //判断元素个数是否已经超过表长 
	{
    	L->slist=(Elemtype *)realloc(L->slist,(L->listsize+INCREM)*sizeof(Elemtype));
    	if(L->slist=NULL) return ERROR;
    	L->listsize +=INCREM;
	}
	int j;  					   //插入算法的执行 
	for(j=L->length-1;j>=i-1;j--){
		L->slist[j+1]=L->slist[j];
	}
	L->slist[i-1]=e;              
	L->length ++;                //元素个数+1 
	return OK;					//返回值 
 	
 }
 
 int SearchSqlist(Sqlist *L,Elemtype e)
 {  
   int i=0;
   for(i;i<L->length;i++)
   {
   	if(L->slist[i]==e)
   	   {  
		printf("%d\n",i+1);
		return OK; 
	   }
   } 
    printf("not exist!\n");
    return 0;
 }
 int DeleteSqlist(Sqlist *L,int i)  //i为要删除元素的位序 
 {
     if(i<1||i>L->length)
	 { return ERROR;}
	 int j;   //执行删除算法 
     for(j=i;j<L->length;j++)
     { L->slist[j-1]=L->slist[j];
	 }
	 L->length--;
	 
	 return OK;
} 
 
 void printSq(Sqlist *L) 
 {
 	int i=0;
 	for(i;i<L->length;i++ )
 	{ 
 	   printf("%d",L->slist[i]);
 	   printf(" ");
	 }
 }
 int main(){
 	Sqlist Sq;
 	Elemtype e;
	int n,m;   //n为输入顺序表元素个数 m为要查找多少个元素 
	//初始化顺序表并初始化一批输入 （插入新元素再调用即可） 
	if(InitSqlist(&Sq))
	{ if(scanf("%d %d",&n,&m)==2)
		{ int i;
		  int t;
		  for(i=0;i<n;i++)
		  {
		  	scanf("%d",&e);
		  	InsertSqlist(&Sq,e,i+1);
		  }
//		  printSq(&Sq);
		  //查找关键字值为e的位序 
//		 for(i=0;i<m;i++)
//			{
//       	     scanf("%d",&e);
//       	     SearchSqlist(&Sq,e);
//	   		}
     //删除位序为t的元素
	        for(i=0;i<m;i++)
			{ 
			  scanf("%d",&t);
			  DeleteSqlist(&Sq,t);
			 } 
			  printSq(&Sq);
			
		}
	}
	
    return 0;
 }