数据结构（C语言版）第二章 线性表-整理-顺序表

2.2 线性表的顺序表示和实现

线性结构的特点：

• 存在唯一的“第一个”和“最后一个”的数据元素
• 除了第一个（最后一个）之外，集合中的每个数据元素均只有一个前驱（后继）

线性表简而言之是n个数据元素的有限序列
在稍复杂的线性表中，一个数据元素可以由若干个数据项组成。此时，把数据元素称为记录，含大量记录的线性表称为文件

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define ListSize 30
typedef int ElemType;
typedef int Status; 
//---------线性表的动态分配顺序存储结构 
#define ListSize 30 //线性表存储空间的初始分配量 
#define ListIncrement 10 //线性表存储空间的分配增量 
typedef struct{
	ElemType *elem;	//存储空间基址 数组指针elem指示线性表的基地址 
	int length; //当前长度 
	int size; //当前分配的存储容量（以sizeof(ElemType)为单位） 
}SqList;

//初始化线性表 
Status InitList_Sq(SqList &L){
	L.elem=(ElemType*)malloc(ListSize*sizeof(ElemType));
	if(!L.elem){
		return OVERFLOW;	//存储分配失败 
	}
	L.length=0;	//空表长度为0 
	L.size=ListSize; //初始存储容量 
	return OK;
}

int ListLength(SqList L){
	return L.length;
} 

Status GetElem(SqList L,int i,ElemType &e){
	if(i<1||i>L.length)
	{
		return ERROR;  
	}
	e=L.elem[i-1];
	return OK;
} 

int LocateElem(SqList L,ElemType e){
	for(int i=0;i<L.length;i++){
		if(L.elem[i]==e){
			return -1;
			break;
		}
	}
}

int n=1;
int compare(ElemType a,ElemType b){
	if(a==b){
		return n;
	}
	n++;
}

//算法2.5
//在顺序线性表L中查找第1个值与e满足compare()元素的位序 
int LocateElem_Sq(SqList L,ElemType e,Status (*compare)(ElemType,ElemType)){
	int i=1;
	ElemType *p=L.elem;
	while(i<=L.length&&!(*compare)(*p++,e)){
		++i;
	}
	if(i<=L.length){
		return i;
	}else{
		return 0;
	}
}

//算法2.3 
//在顺序表中第i个位置前插入新元素e 
Status ListInsert_Sq(SqList &L,int i,ElemType e){
	ElemType *p,*q,*newbase;
	if(i<1||i>L.length+1){
		return ERROR;	//i值不合法 
	} 
	if(L.length>=ListSize){
		ElemType *newbase=(ElemType*)malloc(ListIncrement*sizeof(ElemType));
		if(!newbase){
			return OVERFLOW;
		}
		L.elem=newbase;
		L.size+=ListIncrement;
	} 
	q=&(L.elem[i-1]);
	for(p=&(L.elem[L.length-1]);p>=q;--p){
		*(p+1)=*p;
	} 
	*q=e;
//	for(int j=L.length-1;j>=i-1;j--){
//		L.elem[j+1]=L.elem[j];  
//	} 
//	L.elem[i-1]=e;
	L.length++;
	return OK;
}

//算法2.4
//在顺序线性表L中删除第i个元素，并用e返回其值 
Status ListDelete(SqList &L,int i,ElemType &e){
	ElemType *p,*q;
//	if(i<1||i>L.length) return ERROR; //i值不合法
//	e=L.elem[i-1];
//	for(int j=i;j<=L.length-1;j++){
//		L.elem[j-1]=L.elem[j]; //被删除元素之后的元素前移 
//	} 
	p=&(L.elem[i-1]);
	e=*p;
	q=L.elem+L.length-1;//表尾元素的位置
	for(++p;p<=q;++p){
		*(p-1)=*p;
	} 
	L.length--; //表长减一 
	return OK; 
}
 
//例2-1 合并线性表LA、LB
//时间复杂度为O(ListLength(LA)XListLength(LB)) 
void Listunion(SqList &La,SqList Lb){
	ElemType e;
	int La_len=ListLength(La);
	int Lb_len=ListLength(Lb);
	for(int i=1;i<=Lb_len;i++){
		GetElem(Lb,i,e);
		if(LocateElem_Sq(La,e,compare)!=0){
			ListInsert_Sq(La,++La_len,e);
		}
	}
} 

//算法2.6 
//将数据元素按值非递减有序排列的LA、LB归并为新的数据元素按值非递减有序排列的线性表LC
Status MergeList_Sq(SqList La,SqList Lb,SqList &Lc){
	ElemType *pa,*pb,*pc,*pa_last,*pb_last;
	pa=La.elem;
	pb=Lb.elem;
	Lc.size=Lc.length=La.length+Lb.length;
	pc=Lc.elem=(ElemType*)malloc(Lc.size*sizeof(ElemType));
	if(!Lc.elem){
		return OVERFLOW;
	}
	pa_last=La.elem+La.length-1;
	pb_last=Lb.elem+Lb.length-1;
	while(pa<=pa_last&&pb<=pb_last){
		if(*pa<=*pb){
			*pc++=*pa++;
		}else{
			*pc++=*pb++;
		}
	}
	while(pa<=pa_last){
		*pc++=*pa++;
	}
	while(pb<=pb_last){
		*pc++=*pb++;
	}
}

int main(){
	SqList La,Lb,Lc;
	InitList_Sq(La);
	InitList_Sq(Lb);
	int a[4]={3,5,8,11};
	int b[7]={2,6,8,9,11,15,20};
	printf("La:");
	for(int i=0;i<sizeof(a)/sizeof(a[0]);i++){
		La.elem[i]=a[i];
		La.length++;
		printf("%d ",La.elem[i]);
	}
	printf("\nLb:");
	for(int i=0;i<sizeof(b)/sizeof(b[0]);i++){
		Lb.elem[i]=b[i];
		Lb.length++;
		printf("%d ",Lb.elem[i]);
	}
	MergeList_Sq(La,Lb,Lc);
	printf("\nMergeList_Sq(La,Lb,Lc):");
	for(int i=0;i<Lc.length;i++){
		printf("%d ",Lc.elem[i]);
	}
	Listunion(La,Lb);
	printf("\nListunion(La,Lb):");
	for(int i=0;i<La.length;i++){
		printf("%d ",La.elem[i]);
	}
	return 0;
}

运行结果：
La:3 5 8 11
Lb:2 6 8 9 11 15 20
MergeList_Sq(La,Lb,Lc):2 3 5 6 8 8 9 11 11 15 20
Listunion(La,Lb):3 5 8 11 2 6 8 9 11 15 20

线性表的顺序表示指的时用一组地址连续的存储单元依次存储线性表的数据元素。
假设线性表的每个元素需占用l个存储单元。数据元素中的存储位置：
LOC(a_i+1)=LOC(a_i)+l
一般来讲，线性表的第i个数据元素a_i的存储位置为
LOC（a_i)=LOC(a₁)+(i-1)Xl
LOC(a₁)时线性表的第一个数据元素a₁的存储位置，通常称作线性表的起始位置或基地址。