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

【考纲内容】

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

【知识框架】

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

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

线性表的基本操作

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

1. 设计一个高效算法，将顺序表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;
}
}

1. 对长度为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
}

1. 从有序顺序表中删除其值在给定值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;
}

1. 从顺序表中删除其值在给定值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;
}

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

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

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

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