课本19页源程序

1.shunxu.h

#include<stdio.h>

#define FALSE 0
#define OK    1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量 
#define LISTINCREMENT 10 //线性表存储空间的分配增量 

typedef int Status;
typedef int ElemType;
typedef struct{
	ElemType *elem; //存储空间基址 
	int  length;    //当前长度 
	int  listsize;  //当前分配的存储容量 
}SqList; 


Status InitList_Sq(SqList &L);
//操作结果：构造一个空的线性表L
Status DestroyList(SqList &L);
//初始条件：线性表L已存在
//操作结果：销毁线性表L 
Status ClearList(SqList &L);
//初始条件：线性表L已存在
//操作结果：将L重置为空表 
Status ListEmpty(SqList L); 
//初始条件：线性表L已存在
//操作结果：若L为空表，则返回TRUE,否则返回FALSE
Status ListLength(SqList L);
//初始条件：线性表L已存在 
//操作结果：返回L中数据元素个数
Status GetElem(SqList L,int i,ElemType &e);
//初始条件：线性表L已存在，1<=i<=ListLength(L) 
//操作结果：用e返回L中第i个数据元素的值
Status compare(ElemType a,ElemType b);
Status LocateElem_Sq(SqList L,ElemType e,Status(*compare)(ElemType,ElemType));
//初始条件：线性表L已经存在，compare()是数据元素判定函数 
//操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
//若这样的数据元素不存在，则返回值为0。
Status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e);
//初始条件：线性表L已存在 
//操作结果：若cur_e是L的数据元素，且不是第一个，
//则用pre_e返回它的前驱，否则操作失败，pre_e无定义
Status NextElem(SqList L,ElemType cur_e,ElemType &next_e);
//初始条件：线性表L已存在 
//操作结果：若cur_e是L的数据元素，且不是最后一个，
//则用next_e返回它的后继，否则操作失败，next_e无定义
Status ListInsert_Sq(SqList &L,int i,ElemType e);
//初始条件：线性表L已存在，1<=i<=ListLength(L)+1 
//操作结果：在L中第i个位置之前插入新的数据元素e,L的长度加1
Status ListDelete_Sq(SqList &L,int i,ElemType &e);
//初始条件：线性表L已存在且非空，1<=i<=ListLength(L) 
//操作结果：删除L的第i个元素，并用e返回其值，L的长度减1
Status visit(ElemType *a,int i);
Status ListTraverse(SqList L,Status (*visit)(ElemType*,int));
//初始条件：线性表L已存在 
//操作结果：依次对L的每个数据元素调用函数visit()。
//一旦visit()失败，则操作失败 

2.shunxu.cpp

#include "shunxu.h"
#include<stdlib.h>

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

Status DestroyList(SqList &L){
	if(L.elem) free (L.elem); 
	return OK;
}

Status ClearList(SqList &L){
	L.length=0;
	return OK;
}

Status ListEmpty(SqList L){
	if(L.length==0)
	   return OK;
	else
	   return ERROR;
}

Status 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 e;
}

Status compare(ElemType a,ElemType b){
	if(a==b) return OK;
	else return ERROR;
}

Status 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;
}

Status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e){
	int flag=0;
	for(int i=1;i<L.length;i++){
		if(cur_e==L.elem[i]){
		flag=i;
		break;}
	}
	if(flag) {
		pre_e=L.elem[flag-1];
		return pre_e;
	} 
	else return ERROR;
}

Status NextElem(SqList L,ElemType cur_e,ElemType &next_e){
	int flag=0;
	for(int i=0;i<L.length-1;i++){
		if(cur_e==L.elem[i]){
		flag=i;
		break;}
	}
	if(flag) {
		next_e=L.elem[flag+1];
		return next_e;
	} 
	else return ERROR;
}

Status ListInsert_Sq(SqList &L,int i,ElemType e){
	if(i<1||i>L.length+1) return ERROR;
	if(L.length>=L.listsize){
	  ElemType  *newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
	if(!newbase) exit(OVERFLOW);
	L.elem=newbase;
	L.listsize+=LISTINCREMENT;
	}
	ElemType *q=&(L.elem[i-1]);
	for(ElemType *p=&(L.elem[L.length-1]);p>=q;--p)
	    *(p+1)=*p;//插入位置及之后的元素右移
	*q=e;
	++L.length;
	return OK; 
}

Status ListDelete_Sq(SqList &L,int i,ElemType &e){
	if(i<1||(i>L.length)) return ERROR;
	ElemType *p=&(L.elem[i-1]);
	e=*p;
	ElemType *q=L.elem+L.length-1;
	for(++p;p<=q;++p)
	   *(p-1)=*p;//被删除元素之后的元素左移
	--L.length;
	return OK; 
}

Status visit(ElemType *a,int i){
	return a[i];
}

Status ListTraverse(SqList L,Status (*visit)(ElemType*,int)){
	if(L.length){
		for(int j=0;j<L.length;j++){
			printf("第%d位元素%d已经访问\n",j+1,visit(L.elem,j)); 
		}
		return OK;
	}
	else return ERROR;
}

3.main.cpp

#include "shunxu.h"

int main()
{
	SqList L;
	printf("%d (如果初始化成功则输出1，否则输出0)\n",InitList_Sq(L));
	printf("%d (如果线性表为空则输出1，否则输出0)\n",ListEmpty(L));
	for(int j=0;j<LIST_INIT_SIZE;j++){
		L.elem[j]=j;L.length++;
	} //将线性表置满
	printf("线性表的长度为：%d\n",ListLength(L));
	int xu,d;
	printf("请输入你想获得哪一位元素：");
	scanf("%d",&xu); 
	printf( "第%d位的元素是%d\n",xu,GetElem(L,xu,d));
	printf("请输入你想查找哪个元素的位置：");
	scanf("%d",&d); 
	printf("%d元素的位置是%d\n",d,LocateElem_Sq(L,d,(*compare)));
	printf("请输入你想查找哪个元素的前驱：");
	scanf("%d",&d);
	int mark;
	printf("%d元素的前驱是%d\n",d,PriorElem(L,d,mark));
	printf("请输入你想查找哪个元素的后继：");
	scanf("%d",&d);
	printf("%d元素的后继是%d\n",d,NextElem(L,d,mark));	
	printf("请输入你想插入元素的位置和插入的元素：");
	scanf("%d %d",&xu,&d);
	printf("%d (如果为1表示插入成功，否则插入不成功)\n",ListInsert_Sq(L,xu,d));
	printf("插入后线性表的长度为：%d\n",ListLength(L));
	printf( "插入后第%d位的元素是%d\n",xu,GetElem(L,xu,mark));
	printf("请输入你想删除元素的位置：");
	scanf("%d",&xu);
	printf("%d (如果为1表示删除成功，否则删除不成功)\n",ListDelete_Sq(L,xu,d));
	printf("删除后线性表的长度为：%d\n",ListLength(L));
	printf("删除后第%d位的元素是%d\n",xu,GetElem(L,xu,mark));
	printf("%d (如果为1表示线性表已清空，否则未清空)\n",ClearList(L));
	printf("清空后线性表的长度为：%d\n",ListLength(L));
	for(int j=0;j<3;j++){
		L.elem[j]=j;L.length++;
	} 
	printf("重置后遍历线性表的结果如下：\n");
	printf("%d (如果为1表示遍历线性表成功，否则不成功)\n",
	ListTraverse(L,(*visit)));
	printf("%d (如果为1表示线性表已销毁，否则未销毁)\n",DestroyList(L));
	return 0;
}

运行截图