考研数据结构 第二章 线性表 之 顺序表的定义和实现

【考纲内容】

（一）线性表的定义和基本操作
（二）线性表的实现： 顺序存储，链式存储
（三）线性表的应用

【知识框架】

顺序存储的为：顺序表
链式存储的有：单链表，双链表，循环链表，静态链表（借助数组实现）

注意:线性表是一种逻辑结构,顺序表和链表是存储结构.

线性表的基本操作

InitList(&L); //初始化表
Length(L); //表长
LocateElem(L,e); //按值查找
GetElem(L,i); //按位查找
ListInsert(&L,i,e); //插入操作
ListDelete(&L,i,&e); //删除操作,用e返回
PrintList(L); //输出操作
Empty(L); //判空操作
DestoryList(&L); //销毁操作

线性表的顺序表示:顺序表

逻辑上相邻,物理上也相邻。
第一个元素的地址设为LOC(A),则第n个为 LOC(A）＋（ｎ－１)*sizeof(ElemType)
元素的位序从1开始,数组下标从0开始。
定义如下（静态分配空间），指定了表的空间大小

#define MaxSize 100
typedef struct{
	ElemType data[MaxSize]; //顺序表的元素
	int length;  //顺序表的当前长度
}SqList;

动态分配空间，可以动态增加表的空间

#define InitSize 100
typedef struct{
	ElemType *data; //指示动态分配内存的指针
	int MaxSize,length; //数组的最大容量和当前个数
}SeqList;

初始化语句

L.data = (ElemType *)malloc(sizeof(ElemType)*InitSize); //C 分配空间,用malloc函数
L.data = new ElemType[InitSize]; //C++分配空间，用new

顺序表总结：
1.随机访问，通过下标可以直接访问到对应的数据元素。
2.存储密度高，每个节点只存储数据元素。相较于链表表示，每个节点不仅存储数据元素还要存储指针。
3.逻辑相邻，物理相邻，插入和删除需要大量移动，这是顺序表的缺点。

顺序表基本操作实现

//插入元素，平均时间复杂度为O(n)
bool ListInsert(SqList &L,int index,ElemType e)
{
	if(index<1||index>L.length+1) //判断位序是否合法
		return false;
	if(L.length>=MaxSize) //判断空间是否足够
		return false;
	//从最后一个元素开始往后移动
	for(int j = L.length;j>=index;j--)
		L.data[j]=L.data[j-1];
	L.data[index-1] = e; //index位置放入元素
	L.length++; //表长加一
	return true;
 } 
 //注意index是位序，表示第index个元素，从1开始
 
 //删除元素,平均时间复杂度O(n)
 bool ListDelete(SqList &L, int index, ElemType &e)
 {
 	if(index<1||index>L.length) //判断位序是否合法
 		return false;
 	e = L.data[index-1]; 
 	for(int j=index;j<L.length;j++)
 		L.data[j-1] = L.data[j];
 	L.length--;
 	return true;
  } 
  
//按值查找,平均时间复杂度O(n)
int LocateElem(SqList L,ElemType e)
{
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1; //位序 
	return 0;
}

习题

1. 从顺序表中删除具有最小值的元素，并由函数返回被删除元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错误信息并退出运行。

bool Delete_min(SqList &L,ElemType &value)
{
	if(L.length == 0)
		return false;
	value = L.data[0];
	int pos = 0; //用来记录最小元素的下标
	for(int i=1;i<L.length;i++)
		if(L.data[i]<value)
		{
			value = L.data[i];
			pos = i;
		}
	L.data[pos] = L.data[L.lenth-1]; //用最后一个元素填补
	L.length--;
	return true;	
 } 

2. 设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)

void Reverse(SqList &L)
{
	ElemType temp;
	for(int i=0;i<L.length/2;i++) //不论length为奇数还是偶数都可以 
	{
		//交换元素
		temp = L.data[i];
		L.data[i] = L.data[L.length-i-1];
		L.data[L.length-i-1] = temp; 
	}
}

3. 对长度为n的顺序表L，编写一个时间复杂度为O(n),空间复杂度为O(1)的算法，该算法删除线性表中所有的值为x的数据元素。
   思路：如果一个一个的删除，时间复杂度为O(n^2),可不可以找到所有x的位置，然后一次性删除呢？
   假如有k个x，那么第一个x后到第二个x之间的元素往前移动1次，
   第二个x到第三个x之间的元素往前移动2次，以此类推

void Delete_all_x(SqList &L,ElemType x)
{
	int k = 0; //记录x的个数
	int i = 0; //记录下标
	while(i<L.length)
	{
		if(L.data[i]==x)
			k++;
		else
			L.data[i-k] = L.data[i]; //当前元素向前移动k个位置 
		i++;
	}
	L.lenth = L.lenth - k; //顺序表的长度递减，总共有k个x 
 } 

4. 从有序顺序表中删除其值在给定值s和t之间（要求s<t)的所有元素，如果s或t不合理或者顺序表为空,则显示出错信息并退出运行。
   分析：删除的是连续的元素，只需要找到头和尾，然后将尾后面的全部前移即可。

bool Delete_S_between_T(SqList &L, ElemType s, ElemType t)
{
	if(s>=t||L.length==0)
		return false;
	for(int i=0;i<L.length && L.data[i]<s;i++);//寻找大于等于s的第一个元素 
	if(i>=L.length)  //所有元素均小于s，返回 
		return false;
	for(int j=i;j<L.length && L.data[j]<=t;j++); //寻找值大于t的第一个元素 
	for(;j<L.length;i++,j++) //前移，填补被删除元素位置 
		L.data[i]=L.data[j];
	L.length = i;
	return true;	 
}

5. 从顺序表中删除其值在给定值s和t之间（要求s<t)的所有元素，如果s或t不合理或者顺序表为空,则显示出错信息并退出运行
   思路：从前往后扫描，遇到满足条件的数，k++（k记录满足条件的个数，同时也是移动的距离），否则移动K个位置，和删除相同的x是一个意思

bool Delete_S_between_T2(SqList &L,ElemType s,ElemType t)
{
	if(s>=t||L.length==0)
		return false;
	int i = k = 0;
	while(i<L.length)
	{
		if(L.data[i]>=s && L.data[i]<=t)
			k++;
		else
			L.data[i-k] = L.data[i];
		i++;
	}
	L.length = L.length - k;
	return true;
 } 

6. 从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不相同
   注意是有序顺序表，相同的值一定是连在一起的。
   思路：采用类似于直接插入法的方法，第一个元素视为非重复的有序列表，遍历表中元素，和非重复的最后一个元素比较,如果不同就插入到有序列表之后，否则跳过。

void Delete_Same(SqList &L)
{
	if(L.length==0)
		return false;
	int i,j; //i是有序列表的末尾指针，j是工作指针
	for(i=0,j=1;j<L.length;j++)
	{
		if(L.data[i]!=L.data[j])
			L.data[++i]=L.data[j]; //不用移动，直接复制
	}
	L.length = i+1; //加上L.data[0] 
	return true;
}

7. 将两个有序表合并为一个新的有序表，并由函数返回结果顺序表

bool Merge(SqList A, SqList B, SqList &C)
{
	if(A.length + B.length < C.length)
		return false; //空间不够
	int i,j,k;
	while(i<A.lenght && j<B.length)
	{
		if(A.data[i]>B.data[j])
			C.data[k++] = B.data[j++];
		else
			C.data[k++] = A.data[i++];
	 } 
	 //只可能执行一个，将剩下的接到C后面去
	while(i<A.length)
	 	C.data[k++] = A.data[i++];
	while(j<B.length)
		C.data[k++] = B.data[j++];
	C.length = k;
	return true; 
 }