数据结构c语言版严蔚敏 顺序表_数据结构c语言版严蔚敏顺序表删除

说来惭愧由于贪玩，数据结构挂科了，现在重新学一遍数据结构，用博客督促一下自己，希望各位同学引以为戒，贪玩一时爽，痛苦永留存。

本文主要以严老师的数据结构书为主。

结构类型

listsize代表这个顺序表的最大容量  可以随时扩容

length代表表中元素个数   应小于listsize

1.初始化

Status list_init(SqList &L)
{
	L.elem=(Elemtype *)malloc(MAXSIZE*sizeof(Elemtype));//开辟空间
	if(!L.elem)
    exit(OVERFLOW);
	L.length=0;	//初始化数据有效数据为0
	L.listsize=MAXSIZE;	//初始化数组长度为MAXSIZE
}

ps：exit函数其头文件为stdlib.h

退出程序返回OVERFLOW   OVERFLOW需要你自己宏定义   -2

在main.h中其被定义为3  不定义也可

2.顺序表的创建

Status CreateList(SqList &L)
{
    printf("请您输入想要创建的顺序表的元素的个数:\n");
    scanf("%d",&L.length);
    printf("请输入你想要创建的顺序表:\n");
    for(int i=0;i<L.length;i++)
        scanf("%d",&L.elem[i]);
}
 

3.顺序表的取值

 
Status GetElem(SqList L,int i,ElemType &e)
{
    if(i<1 || i>L.length) //判断i值是否合理，如果不合理，返回0
        return 0;
    e = L.elem[i-1]; //elem[i-1]单元存储第i个数据元素
    return 1;
}

4.顺序表的查找

//在顺序表L中查找值为e的数据元素并返回其序号
Status LocateElem(SqList L,ElemType e)
{
    
    for(int i=0;i<L.length;i++)
    {
        if(L.elem[i] == e)
            return i+1; //查找成功，返回序号i+1
    }
    return 0;
}

个人认为这样编写更简洁优雅

下面是按照书上的

首先，先定义一下Compare()这个函数，就假设这个关系是相等关系吧，利用Compare这个函数实现，如果两个指针中的值相等就返回true，不相等就返回false。代码如下：

bool Compare(ElemType* e1,ElemType* e2)    //参数要就都用指针表示，以免函数间相互调用时参数出现不匹配问题
{
    if(*e1==*e2)
        return true;
    else
        return false;
}

根据这个关系，要找出顺序表中的元素，明显的思路就是一个个元素进行对比了，看是否满足Compare()关系。这里需要注意的一点是元素的位置和数组元素的表示，第i个位置的元素是(*L).elem[i-1]。代码如下：

int LocateElem(SqList *L,ElemType *e)
{
    int i=1;       //i为顺序表中的位置
    ElemType *p;   //p指向顺序表中位序为i的元素
    p=(*L).elem;     //取数组首元素地址     不用&
    while(i<=(*L).length&&(!Compare(p,e)))
    {
        i++;
        p++;
    }
    if(i<=(*L).length)
        return i;       //返回满足条件的元素所在位置i
    else
        return 0;
}

ps:我刚开始不太首元素地址为啥不加&  后来才发现是数组没学好，数组名代表首地址，如果想深入了解大家可以看看这个https://blog.csdn.net/jingzi123456789/article/details/66478310

明白bgnim5.顺序表的插入

//不考虑增加分配的简化版
Status ListInsert(SqList &L,int i,ElemType e)
{
    //在顺序表L中第i个位置插入新的元素e,i值的合法范围是1<=i<=L.length+1
    if((i<1) || (i>L.length+1))
        return 0; //i值不合法
    if(L.length == MAXSIZE)
        return 0; //当前的存储空间已经满了
    for(int j=L.length-1;j>=i-1;j--)
        L.elem[j+1] = L.elem[j]; //插入位置及其之后的元素后移
    L.elem[i-1] = e; //将新的元素e放入第i个位置
    L.length++; //表长加1
    return 1;
}

 Status ListInsert(SqList *L,int i,ElemType e) /* 算法2.4 */
 { /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
   /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
   ElemType *newbase,*q,*p;
   if(i<1||i>(*L).length+1) /* i值不合法 */
     return ERROR;
   if((*L).length>=(*L).listsize) /* 当前存储空间已满,增加分配 */
   {
     newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
     if(!newbase)
       exit(OVERFLOW); /* 存储分配失败 */
     (*L).elem=newbase; /* 新基址 */
     (*L).listsize+=LISTINCREMENT; /* 增加存储容量 */
   }
   q=&(*L).elem[i-1]; /* q为插入位置 */
   for(p=&(*L).elem[length];p>=q;--p) /* 插入位置及之后的元素右移 */
     *(p+1)=*p;
   *q=e; /* 插入e */
   ++(*L).length; /* 表长增1 */
   return OK;
 }

ps：如果想严格来说按书上应  Sqlist &L      把（*L）换成L即可         两者是等价的  都可以完成对原表的操作

但切记  不用*L,&L而直接使用L按照函数形参  你是对实际L表的一个复制体进行了插入  对原表无影响

6.顺序表的删除

Status ListDelete(SqList *L,int i,ElemType *e)  
{
    ElemType *p,*q;
    if(i<0||i>=(*L).length)
    {
        return error;
    }
    q=&((*L).elem[i-1]);   //q为被删除元素的位置
    *e=*q;
    p=&((*L).elem[(*L).length-1]);  //p指向顺序表最后一个元素位置的地址
    for(q;q<p;q++)
    {
        *q=*(q+1);
    }
    (*L).length--;
    return ok;
}
//简化不用e返回值时   取巧直接前移覆盖
Status ListDelete(SqList &L,int i)
{
    //在顺序表L中删除第i个元素，i值的合法范围是1<=i<=L.length
    if((i<1) || (i>L.length))
        return 0; //i值不合法
    for(int j=i;j<=L.length-1;j++)
        L.elem[j-1] = L.elem[j]; //被删除元素之后的元素前移
    L.length--; //表长减1
    return 1;
}
 

 

7.其他操作比较简单大家看看代码就行了

 Status DestroyList(SqList *L)
 { /* 初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L */
   free((*L).elem);
   (*L).elem=NULL;
   (*L).length=0;
   (*L).listsize=0;
   return OK;
 }
 
 Status ClearList(SqList *L)
 { /* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
   (*L).length=0;
   return OK;
 }
 
 Status ListEmpty(SqList L)
 { /* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
   if(L.length==0)/*return L.length==0?TURE:FALSE;更简洁的表达*/
     return TRUE;
   else
     return FALSE;
 }
 
 int ListLength(SqList L)
 { /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
   return L.length;
 }
Status ListTraverse_Sq(SqList L, void(Visit)(LElemType_Sq))
{
	int i;
 
	for(i=0; i<L.length; i++)
		Visit(L.elem[i]);
 
	return OK;
}//用visit函数访问表中元素
 算法2.1║ 
╚════*/
void Union(SqList *La, SqList Lb)
{
	int La_len, Lb_len;
	int i;
	LElemType_Sq e;
 
	La_len = ListLength_Sq(*La);			//求顺序表长度 
	Lb_len = ListLength_Sq(Lb);
 
	for(i=1; i<=Lb_len; i++)
	{
		GetElem_Sq(Lb, i, &e);				//取Lb中第i个元素赋给e 
		if(!LocateElem_Sq(*La, e, equal)) 	//若e不在La中则插入
			ListInsert_Sq(La, ++La_len, e);	
	}
}
 
Status equal(LElemType_Sq e1, LElemType_Sq e2)
{
   return e1==e2 ? TRUE : FALSE;
}
 算法2.2║ 
╚════*/
void MergeSqList_1(SqList La, SqList Lb, SqList *Lc)	//调用顺序表函数进行合并 
{
	int La_len, Lb_len; 
	int i, j, k;
	LElemType_Sq ai, bj;
 
	i = j = 1;
	k = 0;
 
	InitList_Sq(Lc);					//初始化Lc	
	La_len = ListLength_Sq(La);			//获取La、Lb长度 
	Lb_len = ListLength_Sq(Lb);	 
 
	while(i<=La_len && j<=Lb_len)		//La及Lb均未扫描完 
	{
		GetElem_Sq(La, i, &ai);
     	GetElem_Sq(Lb, j, &bj);
 
     	if(ai<=bj)
     	{
     		ListInsert_Sq(Lc, ++k, ai);
     		i++;
     	}
     	else
     	{
			ListInsert_Sq(Lc, ++k, bj);
			j++;
		}
	} 
 
	while(i<=La_len)					//表La还未扫描完 
	{
		GetElem_Sq(La, i++, &ai);
		ListInsert_Sq(Lc, ++k, ai);
	}
 
	while(j<=Lb_len)					//表Lb还未扫描完
	{
		GetElem_Sq(Lb, j++, &bj);
		ListInsert_Sq(Lc, ++k, bj);
	}
}
 
/*════╗
║ 算法2.7║ 
╚════*/
void MergeSqList_2(SqList La, SqList Lb, SqList *Lc)
{
	LElemType_Sq *pa, *pb, *pc;
	LElemType_Sq *pa_last, *pb_last;
 
	pa = La.elem;						//指向La第一个元素 
	pb = Lb.elem;						//指向Lb第一个元素
 
										//不用InitList_Sq创建Lc 
	(*Lc).listsize = (*Lc).length = La.length + Lb.length;
	pc = (*Lc).elem = (LElemType_Sq *)malloc((*Lc).listsize*sizeof(LElemType_Sq));
	if(!pc) 
		exit(OVERFLOW);
 
	pa_last = La.elem + La.length - 1;	//指向La最后一个元素
	pb_last = Lb.elem + Lb.length - 1;	//指向Lb最后一个元素
 
	while(pa<=pa_last && pb<=pb_last) 	//La和Lb均未扫描完 
	{
		if(*pa <= *pb)
			*pc++ = *pa++;
		else
			*pc++ = *pb++;
	}
 
	while(pa <= pa_last)				//表La未扫描完 
		*pc++ = *pa++;					//插入La的剩余元素
 
	while(pb <= pb_last)				//表Lb未扫描完
		*pc++ = *pb++;					//插入Lb的剩余元素
}