408数据结构-【线性表】-考研复习第一天-个人笔记

1.线性表的定义

线性表的顺序存储又称为顺序表（特点：逻辑顺序与物理顺序相同）
存取方式是指读写方式。顺序表是一种支持随机存储的存储结构。

---

顺序表最主要的特点是随机访问，即通过首地址和元素序号可在时间O（1）内找到指定元素。
顺序表的存储密度高，每个节点只存储数据元素。
顺序表逻辑上相邻的元素物理上也相邻，插入与删除时需要大量移动元素。
顺序表不像链表那样要结点中存放指针域，因此存储密度较大

---

线性表主要操作

初始化表：InitList(&L)	求表长：Length(L)
按值查找：LocateElem(L,e)	按位查找：GetElem(L,i)
插入操作：ListInsert(&L,i,e)	删除操作：ListDelete(&L,i,&e)

• 线性表的元素类型【ElemType】

#define MaxSize 50    //用来定义线性表的最大长度
typedef struct {
	ElemType data[MaxSize]; //顺序表的元素
	int length;				//顺序表当前长度
	}SqList;        		//类型定义

• 数组

#define InitSize 100
typedef struct{
	ElemType *data;          //定义一个动态分配数组的指针
	int MaxSize,length;		//最大容量与当前个数
	}SeqList				//动态分配数组顺序表的定义类型

C的初始化动态分配语句：
L.data=(ElemType)malloc(sizeof(ElemType)InitSize);
C++动态分配语句：
L.data=new ElemType[InitSize];
(注：动态分配不为链式存储，它属于顺序存储结构)

插入操作：

插入个新元素如果不合法则返回false，插入成功所有元素向右移一个位置，顺序表长度+1

bool ListInsert(SqList &L,int i,ElemType e){
	if(i<1||i>L.length+1/*有可能插入最后一位所以要加1*/)      //判断范围是否有效
		return false;
	if(L.length>=MaxSize)
		return false;
	for(int j=L.length;j>=i;j--)
		L.data[j]=L.data[j-1];								//在插入元素之后的元素全部向后移
	L.data[i-1]=e;
	L.length++;
	return true;
	}
		

最好情况：在表尾插入（i=n+1），元素后移语句不执行，时间复杂度O（1）。
最坏情况：在表头插入(i=1)，元素向后移语句执行n次，时间复杂度O(n)。
平均情况：假设pi(pi=1/(n+1))是在第i个位置上插入一个结点的概率，则在长度为n的线性表中插入一个结点时，需要移动的平均次数位n/2 时间复杂度位O(n)

删除操作

bool ListDelete(SqList &L,int i,Elemtype &e){
	if(i<1||i>L.length)
		return false;
	e=L.data[i-1];
	for(int j=i;j<L.length;j++)
		L.data[j-1]=L.data[j];
	L.length--;
	return true;
	}

最好情况：删除表尾元素（i=n），无需移动元素，时间复杂度O（1）。
最坏情况：删除表头元素(i=1)，元素向前移，时间复杂度O(n)。
平均情况：假设pi(pi=1/(n))是在第i个位置上删除一个结点的概率，则在长度为n的线性表中删除一个结点时，需要移动的平均次数位（n-1）/2 时间复杂度位O(n)

按值查找（顺序查找）

int LocateElem(SqList L,ElemType e){
	int i;
	for(i=0:i<L.length;i++)
		if(L.data[i]==e)
			return i+1;
	return 0;

完整代码：

#include<stdio.h>
#include<malloc.h>
#define MaxSize 50
typedef char ElemType;
typedef struct
{
	ElemType data[MaxSize];
	int length;
}SqList;
//整体建立线性表
void CreateList(SqList *&L,ElemType a[],int n)
{
	L=(SqList*)malloc(sizeof(SqList));
	for(int i=0;i<n;i++)
		L->data[i]=a[i];
	L->length=n;
}
//初始化线性表
void InitList(SqList *&L)
{
	L=(SqList *)malloc(sizeof(SqList));
	L->length=0;
}
//删除线性表
void DestroyList(SqList *&L)
{
	free(L);
}
//判断线性表是否为空表
bool ListEmpty(SqList *L)
{
	return(L->length==0);
}
//求线性表的长度
bool ListLength(SqList *L)
{
	return(L->length);
}
//输出线性表
void DispList(SqList *L)
{
	for(int i=0;i<L->length;i++)
		printf("%c",L->data[i]);
	printf("\n");
}
//求线性表中第i个元素值
bool GetElem(SqList *L,int i,ElemType &e)
{
	if(i<1||i>L->length)
		return false;
		e=L->data[i-1];
		return true;
}
//查找第一个值域为e的元素序号
int LocateElem(SqList *L,ElemType e)
{
	int i=0;
	while(i<L->length&&L->data[i]!=e)
		i++;
	if(i>=L->length)
		return 0;
	else 
		return i+1;
}
//插入第i个元素
bool ListInsert(SqList *&L,int i,ElemType e)
{
	int j;
	if(i<1||i>L->length+1)
		return false;
	i--;
	for(j=L->length;j>i;j--)
		L->data[j]=L->data[j-1];
		L->data[i]=e;
		L->length++;
		return true;
}
//删除第i个元素
bool ListDelete(SqList *&L,int i,ElemType &e)
{
	int j;
	if(i<1||i>L->length)
		return false;
	i--;
	e=L->data[i];
	for(j=i;j<L->length-1;j++)
		L->data[j]=L->data[j+1];
	L->length--;
	return true;
}
	

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

• 算法思想：搜索整个顺序表，查找最小值元素并记录其位置，搜索结束用最后一个元素填补空出的原最小值元素的位置
• 代码实现如下：

bool Del_Min(SqList &L,ElemType &value/*返回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.length-1];
	L.length--;
	return true;
}

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

• 算法思想：扫描顺序表L的前半部分元素，对于元素L.data[i] (0<=i<L.length/2)将其与后半部分的对应元素L.data[L.length-i-1]进行交换

void Reverse(Sqlist &L){
	Elemtype temp;
	for(i=0;i<L.length/2;i++){
		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的数据元素

• 解法一：用k记录顺序表L中不等于x的元素个数（即需要保存的元素个数），边扫描边统计k，并将不等于x的元素向前移动k个位置，最后修改L的长度。

void del_x(SqList &L,Elemtype x){
	int k=0;
	for(i=0;i<L.length;i++)
		if(L.data[i]!=x){
			L.data[k]=L.data[i];
			k++;
		}
	L.length=k;
}

• 解法二：用k记录顺序表L中等于x的元素个数，边扫描L边统计k，并将不等于x的元素前移k个位置，最后修改L的长度

void del_x_2(SqList &L,Elemtype x)
	int k=0,i=0;
	while(i<L.length){
		if(L.data[i]==x)
			k++；
		else
			L.data[i-k]=L.data[i];
		i++;
		}
	L.length=L.length-k;
}

4.从有序顺序表中删除其值在给定值s与t之间（包含s和t，要求s<t）的所有元素，如果s或t不合理或顺序表为空，则显示错误信息并退出运行

• 算法思想：先寻找值大于等于s的第一个元素，然后寻找值大于t的第一个元素。将这段删除，将后面元素前移。

bool Del_s_t2(SqList &L,ElemType s,Elemtype t)
{
	int i,j;
	if(s>=t||L.length==0)
		return false;
	for(i=0;i<L.length&&L.data[i]<s;i++);
	if(i>=L.length)
		return false;
	for(j=i;j<L.length&&L.data[j]<=t;j++);
	for(;j<L.lengthi++,j++)
		L.data[i]=L.data[j];
	L.length=i;
	return true;

5.从顺序表中删除其值在给定值s与t之间（包含s和t，要求s<t）的所有元素，如果s或t不合理或顺序表为空，则显示错误信息并退出运行

• 算法思想：从前向后扫描顺序表L，用k记录下元素值在s到t之间元素的个数（初始时k=0）.对于当前扫描的元素，若其值不在s到t之间，则前移k个位置；否则执行k++。由于这样每个不在s到t之间的元素仅移动一次，所以算法效率高。

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

6.从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。

• 算法思想：注意是有序顺序表，值相同的元素一定在连续的位置上，用类似直接插入排序的思想，初始时将第一个元素视为非重复的有序表。之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同则继续向后判断，若不相同则插入到前面的非重复有序表的最后，直到判断到表尾为止。

bool Delete_Same(SeqList &L){
	if(L.length==0)  
		return false;
	int 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;
	return true;
}

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

• 算法思路：首先，按顺序不断取下两个顺序表表头较小的结点存入新的顺序表中。然后，看哪个表还有剩余，将剩下的部分加到新的顺序表后面

bool Merge(SeqList A,SeqList B,SeqList &C){
	if(A.length+B.length>C.maxSize)
		return false;
	int i=0,j=0,k=0;
	while(i<A.length&&j<B.length){
		if(A.data[i]<=B.data[j])
			C.data[k++]=A.data[i++];
		else
			C.data[k++]=B.data[j++];
	}
	while(i<A.length)
		C.data[k++]=A.data[i++];
	while(l<B.length)
		C.data[k++]=B.data[j++];
	C.length=k;
	return true;
}
		

8.已知在一维数组A[m+n]中依次存放两个线性表(a1,a2,a3,…,am)和(b1,b2,b3,…,bn)。试编写一个函数，将数组中两个顺序表的位置互换，即将(b1,b2,b3,…,bn)放在(a1,a2,a3,…,am)的前面。

• 算法思路：先将A[m+n]中的全部元素(a1,a2,a3,…,am,b1,b2,b3,…,bn)原地逆置为（bn,bn-1,bn-2,…b1,am,am-1,am-2,…a1）,再对前n个元素和后m个元素分别使用逆置算法，即可得到(b1,b2,b3,…bn,a1,a2,a3,…,am)，从而实现顺序表的位置互换

typedef int DataType;
void Reverse(DataType A[],int left.int right,int arraySize){
	if(left>=right||right>=arraySize)
		return;
	int mid=(left+right)/2;
	for(int i=0;i<mid-left;i++){
		Datatype temp=A[left+i];
		A[left+i]=A[right-i];
		A[right-i]=temp;
		}
 	}
void Exchange(DataType A[],int m,int n,int arraySize){
	Reserse(A,0,m+n-1,arraySize);
	Reserse(A,0,n-1,arraySize);
	Reserse(A,n,m+n-1,arraySize);
	}

9.线性表（a1,a2,a3,…,an）中的元素递增有序且按顺序存储于计算机内。要求设计一算法，完成用最少时间在表中查找数据值为x的元素，若找到规则将其与后继元素位置相交换，若找不到则将其插入表中并使表中元素仍递增有序。

• 算法思路：顺序存储的线性表递增有序，可以顺序查找，也可以折半查找。题目要求“用最少的时间在表中查找数值为x的元素”，这里应使用折半查找法。

void SearchExchangeInsert(ElemType A[],ElemType x){
	int low=0,high=n-1,mid;
	while(low<=high){
		mid=(low+high)/2;
		if(A[mid]==x) break;
		else if(A[mid]<x) low=mid+1;
		else high=mid-1;
	}
	if(A[mid]==x&&mid!=n-1){
		t=A[mid];A[mid]=A[mid+1];A[mid+1]=t;
	}
	if(low>high){
		for(i=n-1;i>high;i--) A[i+1]=A[i];
		A[i+1]=x;
		}
	}
		

10.【2010】设将n（n>1）个整数存放到一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p(0<p<n)个位置，即将R中的数据由(X0,X1,…Xn-1)变换为(Xp,Xp+1,…,Xn-1,X0,X1,…Xp-1)。要求：

1. 给出算法的基本设计思想。
2. 算法
3. 说明时间复杂度和空间复杂度

算法思想：可将这个问题视为把数组ab转换成数组ba(a代表数组的前p个元素,b代表数组中余下的n-p个元素)，先将逆置得到a-1b再将b逆置得到a-1b-1，最后将整个a-1b-1逆置得到（a-1b-1）-1=ba。设Reverse函数执行数组元素逆置的操作，对abcdefgh向左循环移动3(p=3)个位置的过程如下：
Reverse(0,p-1)得到cbadefgh;
Reverse(p,n-1)得到cbahgfed;
Reverse(0,n-1)得到defghabc;

void Reverse(int R[],int from,int to){
	int i,temp;
	for(i=0;i<(to-from+1)/2;i++)
	{
		temp=R[from+i];
		R[from+1]=R[to-i];
		R[to-i]=temp;
	}
void Converse(int R[],int n,int p){
	Reserse(R,o,p-1);
	Reserse(R,p,n-1);
	Reserse(R,0,n-1);	
}

11这题可以多看看.【2011】一个长度为L(L>=1)的升序序列S，处在第[L/2]个位置的数称为S的中位数。例如，若序列S1=(11,13,15,17,19),则S1的中位数是15，两个序列的中位数是含他们所有元素的升序序列的中位数。例如，若S2=(2,4,6,8,20),则S1和S2的中位数是11，现在有两个等长升序序列A和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A和B的中位数。

• 算法思路：分别求两个升序序列A、B的中位数，设为a和b，求序列A、B的中位数过程如下：

   1.若a=b，则a或b即为所求中位数，算法结束。
    	2.若a<b,则舍弃序列A中较小的一半，同时舍弃序列B中较大的一半，要求两次舍弃的长度相等。
    	3.若a>b，则舍弃序列A中较大的一半，同时舍弃序列B中较小的一半，要求两次舍弃的长度相等。
  

  在保留的两个升序序列中，重复1，2，3，直到两个序列中均只含一个元素时为止，较小者即为所求的中位数。

	int M_Search(int A[],int B[],int n){
		int s1=0,d1=n-1,m1,s2=0,d2=n-1,m2;
		while(s1!=d1||s2!=d2){
			m1=(s1+d1)/2;
			m2=(s2+d2)/2;
			if(A[m1]==B[m2])
				return A[m1];
			if(A[m1]<B[m2]){
				if((s1+d1)%2==0){
					s1=m1;
					d2=m2;
				}
				else{
					s1=m1+1;
					d2=m2;
				}
			}
			else{
				if((s2+d2)%2==0){
					d1=m1;
					s2=m2;
				}
				else{
				 	d1=m1;
				 	s2=m2+1;
				 }
				}
			}
			return A[s1]<B[s2]?A[s1]:B[s2];
		}

• 算法的时间复杂度为O(log^2 n)，空间复杂度为O(1)。

---

12.已知一个整数序列A=(a0,a1,…,an-1),其中0<=ai<n(0<=i<n)。若存在ap1=ap2=…=apm=x且m>n/2(0<=pk<n,1<k<=m),则称x为A的主元素。例如A=（0,5,5,3,5,7,5,5）,则5为主元素；又如A=(0,5,5,3,5,1,5,7),则A中没有主元素。假设A中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出A的主元素。若存在主元素，则输出该元素；否则输出-1。

• 算法思想：算法的策略是从前向后扫描数组元素，标记出一个可能成为主元素的元素Num。然后重新计数，确认Num是否是主元素。
  1.选取候选的主元素。依次扫描所给数组中的每个整数，将第一个遇到的整数Num保存到c中，记录Num的出现次数为1；若遇到下一个整数仍等于Num,则计数加1，否则计数减1；当计数减到0时，将遇到的下一个整数保存到c中，计数重新记为1，开始新一轮计数，即从当前位置开始重复上述过程，直到扫描完全部数组元素。
  2.判断c中元素是否是真正的主元素。再次扫描该数组，统计c中元素出现的次数，若大于n/2，则为主元素；否则，序列中不存在主元素。

int Majority(int A[],int n)
{
	int i,c,count=1;
	c=A[0];
	for(i=1;i<n;i++)
		if(A[i]==c)
			count++;
		else
			if(count>0)
				count--;
			else{
				c=A[i];
				count=1;
			}
		if(count>0)
			for(i=count=0;i<n;i++)
				if(A[i]==c)
					count++;
		if(count>n/2)	return c;
		else return -1;
	}

• 实现的程序时间复杂度为O(n),空间复杂度为O(1)。

13.【2018】给定一个含n(n>=1)个整数的数组，请设计一个在时间上尽可能高效的找出算法，找出数组中未出现的最小正整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5,3,2,3}中未出现的最小整数是1；数组{1,2,3}中未出现的最小正数是4。

• 算法思想：因为需要高效因此采用空间换时间的方法。分配一个用于标记的数组B[n]，用来记录A中是否出现了1~n中的正整数，B[0]对应正整数1，B[n-1]对应正整数n，初始化B中全部为0。由于A中含有n个整数,因此可能返回的值是1 ~n+1，当A中n恰好为1 ~n时返回n+1。当数组A中出现了小于等于0或大于n的值可以不采取任何操作。

int findMissMin(int A[],int n)
{
	int i,*B;
	B=(int *)malloc(sizeof(int)*n);
	memset(B,0,sizeof(int)*n); 	//赋值为0
	for(i=0;i<n;i++)
		if(A[i]>0&&A[i]<=n)
			B[A[i]-1]=1;
	for(i=0;i<n;i++)
		if(B[i]==0) break;
	return i+1;
}

时间复杂度：遍历A一次，遍历B一次，两次循环内操作步骤为O（1）量级，因此时间复杂度为O（n）。空间复杂度：额外分配B[n]，空间复杂度为O(n)。

参考书为王道408与数据结构上机教程