数据结构二：线性表的顺序结构实现

此程序根据高一凡大神的源程序修改而成。

/*************************************************************
FileName：c2-1.h
Function：定义线性表的动态分配顺序存储结构(动态分配的一维数组)
*************************************************************/

#pragma	once

#ifndef __C2_1_H__
#define __C2_1_H__

#define LIST_INIT_SIZE	10		// 线性表存储空间的初始分配量
#define LIST_INCREMENT	2		// 线性表存储空间的分配增量

typedef int ElemType;	//定义抽象数据类型ElemType在本程序中为整型

struct SqList
{
	ElemType * elem;	// 存储空间基址
	int length;			// 当前长度
	int listsize;		// 当前分配的存储容量（以sizeof（ElemType）为单位）
};

#endif

/*************************************************************
FileName：bo2-1.h
Function：顺序表示的线性表的基本操作(12个),包括算法2.3,2.4,2.5,2.6
*************************************************************/

#pragma	once

#ifndef _BO2_1_H__
#define _BO2_1_H__

#include "c1.h"
#include "c2-1.h"

// 构造一个空的顺序线性表
void InitList_Sq(SqList &L);

// 销毁顺序线性表L
void DestroyList_Sq(SqList &L);

// 将顺序线性表L重置为空表
void ClearList_Sq(SqList &L);

// 操作结果：若 L为空表，则返回 TRUE；否则返回 FALSE
Status ListEmpty_Sq(SqList L);

// 返回顺序顺序线性表中数据元素的个数
int ListLength_Sq(SqList L);

// 用e返回L中第i个数据元素的值
Status GetElem_Sq(SqList L, int i, ElemType &e);

// 返回L中第一个与e满足关系compare（）的数据元素的位序
int LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType, ElemType));

// 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱
Status PriorElem_Sq(SqList L, ElemType cur_e, ElemType &pre_e);

// 若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继
Status NextElem_Sq(SqList L, ElemType cur_e, ElemType &next_e);

// 在L中第i个位置之前插入新的数据元素e，L的长度加1
Status ListInsert_Sq(SqList &L, int i, ElemType e);

// 删除L的第i个数据元素，并用e返回其值，L的长度减1
Status ListDelete_Sq(SqList &L, int i, ElemType &e);

// 依次对L的每个数据元素调用函数vi（）
void ListTraverse_Sq(SqList L, void (*vi)(ElemType &));

#endif

/*******************************************************************
FileName：bo2-1.cpp
Function：实现顺序表示的线性表的基本操作(12个),包括算法2.3,2.4,2.5,2.6
*******************************************************************/

#include "c2-1.h"
#include "bo2-1.h"
#include "c1.h"

// 构造一个空的顺序线性表
void 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;	// 初始存储容量
}

// 销毁顺序线性表L
void DestroyList_Sq(SqList &L)
{
	free(L.elem);
	L.elem = NULL;
	L.length = 0;
	L.listsize = 0;
}

// 将顺序线性表L重置为空表
void ClearList_Sq(SqList &L)
{
	L.length = 0;
}

// 操作结果：若 L为空表，则返回 TRUE；否则返回 FALSE
Status ListEmpty_Sq(SqList L)
{
	if( L.length == 0 )
		return TRUE;
	else
		return FALSE;
}

// 返回顺序顺序线性表中数据元素的个数
int ListLength_Sq(SqList L)
{
	return L.length;
}

// 用e返回L中第i个数据元素的值
Status GetElem_Sq(SqList L, int i, ElemType &e)
{
	if( i < 1 || i > L.length )
		return ERROR;
	e = *(L.elem + i - 1);
	return OK;
}

// 返回L中第一个与e满足关系compare（）的数据元素的位序
int LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType, ElemType))
{
	ElemType * p;
	int i = 1;				// i的初值为第1个元素的位序
	p = L.elem;				// p的初值为第1个元素的存储位置
	while( i <= L.length && !compare(*p++, e) )
		i ++;
	if( i <= L.length )
		return i;
	else
		return 0;			// 表示未找到与e匹配的数据元素
}

// 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱
Status PriorElem_Sq(SqList L, ElemType cur_e, ElemType &pre_e)
{
	int i = 2;
	ElemType * p = L.elem + 1;
	while( i <= L.length && *p != cur_e ){
		p ++;
		i ++;
	}
	if( i > L.length )
		return INFEASIBLE;	// 操作失败
	else{
		pre_e = *(--p);
		return OK;
	}
}

// 若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继
Status NextElem_Sq(SqList L, ElemType cur_e, ElemType &next_e)
{
	int i = 1;
	ElemType *p = L.elem;
	while( i < L.length && *p != cur_e ){
		i ++;
		p ++;
	}
	if( i == L.length )
		return INFEASIBLE;	// 操作失败
	else{
		next_e = *(++p);
		return OK;
	}
}

// 在L中第i个位置之前插入新的数据元素e，L的长度加1
Status ListInsert_Sq(SqList &L, int i, ElemType e)
{
	ElemType * newbase, *q, *p;
	if( (i < 1) || (i > L.length + 1) )		// i值不合法
		return ERROR;
	if( L.length >= L.listsize ){			// 当前存储空间已满，增加分配
		if( !(newbase = (ElemType *)realloc(L.elem, (L.listsize + LIST_INCREMENT) * sizeof(ElemType))) )
			exit(OVERFLOW);					// 内存分配失败
		L.elem = newbase;					// 新基址
		L.listsize += LIST_INCREMENT;		// 增加存储容量
	}
	q = L.elem + i - 1;						// q为插入位置
	// 插入位置及其之后的元素右移
	for( p = L.elem + L.length - 1; p >= q; p -- )
		*(p+1) = *p;
	*q = e;				// 插入e
	L.length ++;		// 表长增加1
	return OK;
}

// 删除L的第i个数据元素，并用e返回其值，L的长度减1
Status ListDelete_Sq(SqList &L, int i, ElemType &e)
{
	ElemType *p, *q;
	if( (i < 1) || (i > L.length) )
		return ERROR;
	p = L.elem + i - 1;				// p为被删除的元素的位置
	e = *p;							// 被删除的元素的值赋给e
	q = L.elem + L.length - 1;		// 表尾的元素
	for( ++ p; p <= q; ++ p)		// 被删除元素之后的元素左移
		*(--p) = *p;
	L.length --;					// 表长减1
	return OK;
}

// 依次对L的每个数据元素调用函数vi（）
void ListTraverse_Sq(SqList L, void (*vi)(ElemType &))
{
	ElemType *p;
	int i;
	p = L.elem;
	for( i = 1; i <= L.length; i ++ )
		vi(*p++);
}

/**************************************************
FileName：func2-3.h
Function: 测试顺序线性表中使用的几个常用的函数
**************************************************/

#pragma once

#ifndef	__FUNC2_3__
#define __FUNC2_3__

#include "c1.h"
#include "c2-1.h"

// 判断是否相等的函数
Status equal(ElemType c1,ElemType c2);

// 根据 a<、 =或 >b，分别返回 -1、 0或 1
int comp(ElemType a,ElemType b);

void print(ElemType c);

void print2(ElemType c);

void print1(ElemType &c);


#endif

/**************************************************
FileName：func2-3.cpp
Function: 实现测试顺序线性表中使用的几个常用的函数
**************************************************/

#include "func2-3.h"
#include "c2-1.h"
#include <stdio.h>

// 判断是否相等的函数
Status equal(ElemType c1, ElemType c2)
{ 
	if(c1==c2)
		return TRUE;
	else
		return FALSE;
}

// 根据 a<、 =或 >b，分别返回 -1、 0或 1
int comp(ElemType a, ElemType b)
{ 
	if(a==b)
		return 0;
	else
		return (a-b) / abs(a-b);
}
void print(ElemType c)
{
	printf("%d ", c);
}
void print2(ElemType c)
{
	printf("%c ", c);
}
void print1(ElemType &c)
{
	printf("%d ", c);
}

/**********************************************
Function: 定义结果状态值（OK...）
		  包含常用头文件

Description: 包含的头文件很多，实际使用的时候
			 自行修改
**********************************************/
#pragma once

#ifndef __C1_H__
#define __C1_H__

#include<string.h>
#include<ctype.h>
#include<malloc.h>	// malloc()等
#include<limits.h>	// INT_MAX等
#include<stdio.h>	// EOF(=^Z或F6),NULL
#include<stdlib.h>	// atoi()
#include<io.h>		// eof()
#include<math.h>	// floor(),ceil(),abs()
#include<process.h> // exit()
#include<iostream>	// cout cin

//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
// #define OVERFLOW -2因为在math.h中已定义OVERFLOW的值为3,故去掉此行

typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean;// Boolean是布尔类型,其值是TRUE或FALSE


#endif

/********************************************************
FileName: main2-1.cpp
Function: 测试顺序线性表的12种操作函数
********************************************************/

#include "c1.h"
#include "c2-1.h"
#include "bo2-1.h"
#include "func2-3.h"

// 数据元素判定函数 (平方关系 ) ， LocateElem() 调用的函数
Status sq(ElemType c1, ElemType c2);


// ListTraverse() 调用的另一函数 (元素值加倍 )
void dbl(ElemType &c);

void main()
{
	SqList L;
	ElemType e,e0;
	Status i;
	int j,k;

	// 测试初始化线性表的函数：InitList_Sq（）
	InitList_Sq(L);
	printf("初始化 L后： L.elem=%u L.length=%d L.listsize=%d\n\n",L.elem,L.length,L.listsize);
	
	// 通过在表头前插入元素，测试插入新元素的函数：ListInsert_Sq（）
	for(j=1;j<=5;j++)
		i=ListInsert_Sq(L,1,j);
	printf("在 L的表头依次插入 1～ 5后： *L.elem=");
	for(j=1;j<=5;j++)
		std::cout<<*(L.elem+j-1)<< ' ';
	std::cout<<std::endl;
	printf("L.elem=%u L.length=%d L.listsize=%d\n\n",L.elem,L.length,L.listsize);
	
	// 测试判断线性表是否为空的函数：ListEmpty_Sq（）
	i=ListEmpty_Sq(L);
	printf("L是否空： i=%d(1: 是 0: 否 )\n\n",i);
	
	// 测试清空线性表的函数：ClearList_Sq（）
	ClearList_Sq(L);
	printf("清空 L后： L.elem=%u L.length=%d L.listsize=%d",L.elem,L.length,L.listsize);
	i=ListEmpty_Sq(L);
	printf("L是否空： i=%d(1: 是 0: 否 )\n\n",i);
	
	// 通过在表尾后插入元素，测试插入新元素的函数：ListInsert_Sq（）
	for(j=1;j<=10;j++)
		ListInsert_Sq(L,j,j);
	printf("在 L的表尾依次插入 1～ 10后： *L.elem=");
	for(j=1;j<=10;j++)
		std::cout<<*(L.elem+j-1)<< ' ' ;
	std::cout<<std::endl;
	printf("L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);

	// 测试当插入的数据元素超过初始分配的内存空间的情况
	ListInsert_Sq(L,1,0);
	printf("在 L的表头插入 0后： *L.elem=");
	for(j=1; j<=ListLength_Sq(L); j++)		// ListLength(L) 为元素个数
		std::cout<<*(L.elem+j-1)<< ' ' ;
	std::cout<<std::endl;
	printf("L.elem=%u(有可能改变 ) L.length=%d(改变 ) L.listsize=%d(改变 )\n\n", L.elem, L.length, L.listsize);
	
	// 测试获取线性表元素的函数：GetElem_Sq（）
	GetElem_Sq(L,6,e);
	printf("第 6个元素的值为 %d\n\n",e);

	// 测试返回L中第一个与e满足关系compare（）的数据元素的位序的函数：LocateElem_Sq（）
	for(j=10;j<=11;j++)
	{
		k=LocateElem_Sq(L,j,equal);
		if(k)			// k不为 0，表明有符合条件的元素，且其位序为 k
			printf("第 %d个元素的值为 %d\n",k,j);
		else
			printf("没有值为 %d的元素 \n",j);
	}

	for(j=3;j<=4;j++)
	{
		k=LocateElem_Sq(L,j,sq);
		if(k)			// k不为 0，表明有符合条件的元素，且其位序为 k
			printf("第 %d个元素的值为 %d的平方 \n",k,j);
		else
			printf("没有值为 %d的平方的元素 \n",j);
	}

	// 测试找前驱的函数：PriorElem_Sq（）
	for( j=1; j<=2; j++ )			// 测试头两个数据
	{
		GetElem_Sq(L, j, e0);		// 把第 j个数据赋给 e0
		i=PriorElem_Sq(L, e0, e);	// 求 e0的前驱
		if( i == INFEASIBLE )
			printf("元素 %d无前驱 \n",e0);
		else
			printf("元素 %d的前驱为 %d\n",e0,e);
	}

	// 测试找后继的函数：NextElem_Sq（）
	for( j = ListLength_Sq(L) - 1; j <= ListLength_Sq(L); j ++ )	// 最后两个数据
	{
		GetElem_Sq(L, j, e0);		// 把第 j个数据赋给 e0
		i=NextElem_Sq(L, e0, e);	// 求 e0的后继
		if(i==INFEASIBLE)
			printf("元素 %d无后继 \n",e0);
		else
			printf("元素 %d的后继为 %d\n",e0,e);
	}

	// 测试删除线性表元素的函数：ListDelete_Sq（）
	k=ListLength_Sq(L);				// k为表长
	for( j = k + 1; j >= k; j --)
	{
		i = ListDelete_Sq(L, j, e);		// 删除第 j个数据
		if( i == ERROR )
			printf("\n删除第 %d个元素失败 \n",j);
		else
			printf("删除第 %d个元素成功，其值为 %d\n\n", j, e);
	}

	// 测试遍历线性表的函数：ListTraverse_Sq（）
	printf("依次输出 L的元素： ");
	ListTraverse_Sq(L, print1);		// 依次对元素调用 print1() ，输出元素的值
	printf("\n");

	printf("L的元素值加倍后： ");
	ListTraverse_Sq(L, dbl);		// 依次对元素调用 dbl() ，元素值乘 2
	ListTraverse_Sq(L, print1);
	printf("\n\n");

	// 测试销毁线性表的函数：DestroyList_Sq（）
	DestroyList_Sq(L);
	printf("销毁 L后： L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);
	
	getchar();
}


// 数据元素判定函数 (平方关系 ) ， LocateElem() 调用的函数
Status sq(ElemType c1, ElemType c2)
{ 
	if(c1 == c2*c2)
		return TRUE;
	else
		return FALSE;
}

// ListTraverse() 调用的另一函数 (元素值加倍 )
void dbl(ElemType &c)
{ 
	c *= 2;
}