线性表概念及顺序表的实现

---

前言

  T_T此专栏用于记录数据结构及算法的（痛苦）学习历程，便于日后复习（这种事情不要啊）。所用教材为《数据结构 C语言版 第2版》严蔚敏。有关线性结构和抽象数据类型的概念，见数据结构与算法的基本概念

---

一、线性表

1.定义

  线性表：由0个或多个具有相同属性的数据元素组成的有限序列，常用（A0,A1…An）形式表示。例如26个英文字母（A,B,C…Z）就是一个线性表。

2.特点

  1.线性表是一个序列，也就是说数据元素存在先来后到的关系。好比一个数列，a0总是第一个出现。
  2.满足线性结构要求。
  3.线性表中元素的个数n (n>=0)定义为线性表的长度，n=0时称为空表。如果表中无元素，则为空表，n=0。
  我们常用的一维数组就是一个线性表。

3.一般线性表的抽象数据类型定义

  线性表作为一个相当灵活的数据结构，其长度可根据需要增长或缩短，即对线性表的数据元素不仅可以进行访问，而且可以进行插入和删除等操作。下面给出一般线性表的抽象数据类型定义：

ADT List{
数据对象： D={ai | ai∈ElemSet, i=l, 2, …,n, n>=Q}
数据关系： R=(<ai-1,ai>| ai-1,ai∈D, i=2, …, n}
基本操作：
InitList (&L)
操作结果：构造一个空的线性表L。
DestroyList(&L)
初始条件：线性表L已存在。
操作结果：销毁线性表L。
ClearList (&L)
初始条件：线性表L已存在。
操作结果：将L重置为空表。
ListEmpty(L)
初始条件：线性表L已存在。
操作结果：若L为空表，则返回true, 否则返回false。
ListLength(L)
初始条件：线性表L已存在。
操作结果：返回L中数据元素个数。
GetElem(L,i,&e)
初始条件：线性表L已存在，且1<=i<=ListLength(L)。
操作结果：用e返回L中第i个数据元素的值。
LocateElem(L,e)
初始条件：线性表L已存在。
操作结果：返回L中第1个值与e相同的元素在L中的位置。若这样的数据元素不存在，则返回值为0。
PriorElem(L,cur_e,&pre_e)
初始条件：线性表L已存在。
操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回其前驱，否则操作失败，pre_e无定义。
NextElem(L,cur_e,&next_e)
初始条件：线性表L已存在。
操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回其后继，否则操作失败，next_e无定义。
ListInsert(&L,i,e)
初始条件：线性表L已存在，且1<=i<=ListLength(L)+1。
操作结果：在 L中第i个位置之前插入新的数据元素 e, L的长度加1。
ListDelete(&L,i)
初始条件：线性表L已存在且非空，且1<=i<=ListLength(L)。
操作结果：删除L的第i个数据元素，L的长度减1。
ListTraverse(&L,visited())
初始条件：线性表L已经存在
操作结果：对线性表L进行遍历，在遍历过程中对线性表中每个元素调用visited()
}ADT List

注：
(1)抽象数据类型仅是一个模型的定义，并不涉及模型的具体实现，因此这里描述中所涉及的参数不必考虑具体数据类型。在实际应用中，数据元素可能有多种类型，到时可根据具体需要选择使用不同的数据类型。
(2) 上述抽象数据类型中给出的操作只是基本操作，由这些基本操作可以构成其他较复杂的操作。
(3)对于不同的应用， 基本操作的接口可能不同。
(4)由抽象数据类型定义的线性表， 可以根据实际所采用的存储结构形式， 进行具体的表示和实现。

二、线性表的顺序存储（顺序表）

1.基本概念

  线性表的顺序表示（又称顺序表）指的是用一组地址连续的存储单元依次存储线性表的数据元素， 这种表示也称作线性表的顺序存储结构或顺序映像。通常，称这种存储结构的线性表为顺序表(Sequential List)。其特点是，逻辑上相邻的数据元素， 其物理次序也是相邻的。
  假设线性表的每个元素需占用m个存储单元，并以所占的第一个单元的存储地址LOC(q)作为数据元素的存储起始位置。则线性表中第i+1个数据元素的存储位置LOC(ai+1)和第i个数据元素的存储位置LOC(ai)之间满足下列关系：
       LOC(ai+1)=LOC(ai)+m
  从而线性表第i个元素存储位置：
       LOC(ai)=LOC(q)+(i-1)*m.

2.数组实现顺序表

  在高级语言中，通常都用数组来描述数据结构中的顺序存储结构。由于线性表的长度可变，且所需最大存储空间随问题不同而不同，则在C语言中可用动态分配的一维数组表示线性表。
  下面给出一般实现过程：

#define MAXSIZE 100   //顺序表可能达到的最大长度
typedef struct 
｛
	ElemType *elem;   //起始地址，即第一个元素存储地址;ElemType为某一数据类型或用户自定义的数据类型
	int length;       //当前顺序表长度
}SqList;
SqList L;

//在c语言中，用malloc实现数组内存动态分配，需要头文件<stdlib.h>
L.data=(ElemType *)malloc(sizeof(ElemType)*MAXSIZE); 
//malloc(n)用于创建一个可以存放n个字节的空间，并返回其首地址
//(ElemType *)用于指针类型强制，此处用于告诉编译器是如何分配的空间。
//以（int *）malloc(sizeof(int)*100)为例
//表示开辟了一个4*100=400字节的空间，其中空间分配为每4字节为一个数据元素，而不是每2字节。
free(p):释放指针p所指变量的存储空间，即彻底删除一个变量

//在c++中，用new来实现数组内存动态分配
new 类型名T (初值列表):用于申请存放T类型对象的内存空间，并以初值列表赋初值，若成功则返回T类型指针，指向分配的内存，若失败则返回0(NULL)
例: int *p=new int(10); //成功执行后，p中存放新分配的内存地址，且该地址空间存放值为10
delete 指针p:释放指针p指向的内存，p必须是new操作的返回值
例: delete p;

  考虑多项式：x³+0.5x+1的存储，从而既要存储其指数项，也要存储其对应的系数项：

#define MAXSIZE 100   //多项式可能达到的最大长度
typedef struct 
{
float coef;    //系数
int expn;      //指数
) Polynomial; 
typedef struct 
｛ 
Polynomial *elem; 
int length; 
}SqList;
SqList L;
L.data=(Polynomial *)malloc(sizeof(Polynomial)*MAXSIZE); 

  将L定义为SqList类型的变量，便可以利用L.elem[i-1]访间表中位置序号为i的元素

3.顺序表中基本操作的具体实现

  下面给出一个实现案例：

#include <iostream>
#include <string.h>
using namespace std;

#define maxsize 10  //顺序表最大长度
#define ok 1
#define fail 0
#define true 1
#define false 0
#define Not_Exist -1
#define overflow -2

typedef int Status;
typedef int book;
typedef struct {
	book* start;
	int length;
}Sqlist;

//初始化，创建顺序表
Status Creatlist(Sqlist &l)
{
	l.start = new book[maxsize];
	if (!l.start)return fail;
	l.length = 0;

	for (int i = 0; i < maxsize; i++)
	{
		cin >> l.start[i];
		l.length++;
	}
	return ok;
}
//销毁顺序表
Status destoryList(Sqlist &l)
{
	if (!l.start)return Not_Exist;  //判断线性表是否存在
	delete[]l.start;
	l.start=NULL; //销毁后，指针仍然存在，指向随机，销毁的只是原来存储的值，计算机内存空间地址是无法销毁的,因此需要在delete后给指针赋NULL
	return ok;
}
//清空顺序表
Status clearList(Sqlist& l)
{
	if (!l.start)return Not_Exist;
	l.length = 0;
	return ok;
}
//检测顺序表是否空
Status Listempty(Sqlist l)
{
	if (!l.start)return Not_Exist;
	if (l.length == 0)
		return true;
	return	false;
}
//返回顺序表长度
Status Listlength(Sqlist l)
{
	if (!l.start)return Not_Exist;
	return l.length;
}
//得到顺序表中某个值
Status Getelem(Sqlist l, int i, book& e)
{
	if (!l.start)return Not_Exist;
	if (i<1 && i>l.length)return fail;
	e = l.start[i - 1];
	return ok;
}
//检查顺序表中是否存在某个值及其位置
Status Locateelem(Sqlist l,book e)
{
	if (!l.start)return Not_Exist;
	for (int i = 1; i <= l.length; i++)
		if (e == l.start[i-1])
			return i;
	return 0;
}
//返回顺序表中某个值的前序
book Priorelem(Sqlist l, book cur_e,book &pre_e)
{
	int i = Locateelem(l, cur_e);
	if (i == 1)
		return Not_Exist;
	pre_e=l.start[i - 2];
	return ok;
}
//返回顺序表中某个值的后序
book Nextelem(Sqlist l, book cur_e, book& next_e)
{
	int i = Locateelem(l, cur_e);
	if (i == l.length)
		return Not_Exist;
	next_e = l.start[i];
	return ok;
}
//插入一个数据元素
Status Listinsert(Sqlist &l, int pos, book e)
{
	if (!l.start)return Not_Exist;
	if (l.length == maxsize)return overflow;
	if (pos < 1 || pos > l.length + 1)return fail;
	for (int i=l.length-1; i >=pos-1; i--)
		l.start[i + 1] = l.start[i];
	l.start[pos - 1] = e;
	l.length++;
	return ok;
}
//删除一个数据元素
Status Listdelete(Sqlist& l, int pos)
{
	if (!l.start)return Not_Exist;
	if (l.length == 0)return overflow;
	if (pos < 1 || pos > l.length + 1)return fail;
	for (int i = pos - 1; i < l.length-1; i++)
		l.start[i] = l.start[i+1];
	l.length--;
	return ok;
}
//遍历顺序表
Status Traverselist(Sqlist &l)
{
	if (!l.start)return Not_Exist;
	for (int i = 0; i < l.length; i++)
		cout << l.start[i] << "  ";  //这里可以是任何合法操作

	return ok;
}

Sqlist l;
book e1;
book e2 = 7;
book pre_e;
book next_e;
int main()
{
	//测试
	Creatlist(l);
	cout << "输入测试用例：" << endl;//这里以1-10作为测试用例
	cout << l.start << endl << l.length << endl;
	Traverselist(l); cout << endl;
	cout << Listlength(l) << endl;
	cout << Getelem(l, 5, e1) << " " << e1 << endl;
	cout << Priorelem(l, 5, pre_e) << " " << pre_e << endl;
	cout << Nextelem(l, 5, next_e) << " " << next_e << endl;
	cout << Locateelem(l, e2) << " " << e2 << endl;
	Listdelete(l, 1);
	cout << l.start[0] << endl;
	destoryList(l);
	cout << l.start << endl; 
	return 0;
}

测试结果：

4.顺序表总结

  对于线性表的顺序存储，可以采用静态数组或动态数组实现，为了便于数据扩充，常采用动态数组的方式。
  顺序表可以随机存取表中任一元素（随机存取），其存储位置可用一个简单、直观的公式来表示。然而从另一方面来看，这个特点也造成了这种存储结构的缺点：在做插入或删除操作时，需移动大量元素。另外由于数组有长度相对固定的静态特性，当表中数据元素个数较多且变化较大时，操作过程相对复杂，必然导致存储空间的浪费。所有这些问题，都可以通过线性表的另一种表示方法——链式存储结构来解决。线性表的链式存储

---

总结

  路漫漫其修远兮，吾将上下而开摆。
  有任何疑问和补充，欢迎交流。（但我显然不会）