王道数据结构算法题《第二章》

2.2线性表的顺序表示

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

/* 
//顺序表的结构体定义（静态）
#define MaxSize 50
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList;
*/
bool Del_Min(SqList &L,ElemType &value){    //bool返回出错信息，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）。

void Reverse(SqList &L){
    ElemType temp;    //辅助变量
    for(int i=0;i<=L.length/2;i++){
        temp=L.data[i];
        L.data[i]=L.data[L.length-1-i];
        L.data[L.length-1-i]=temp;
    }

3.对长度为n的顺序表L，编写一个时间复杂度为O(n)、空间复杂度为O(1)的算法，该算法删除线性表中所有值为x的数据元素。
 

//解法1：
void del_x_1(SqList &L,ElemType x){
	int k=0;	//记录值不等于x的元素个数
	for(int 1=0;i<L.length;i++)
		if(L.data[i]!=x){
			L.data[k]=L.data[i];
			k++;	//不等于x的元素个数增1
		}
		L.length=k;	//顺序表L的长度等于x
}

//解法2:
void del_x_2(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.length=L.length-k;	//顺序表L的长度递减
}

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

//类比第3题
//解法一：
bool Del_s_t1(SqList &L,ElemType s，ElemType t){  
    if(L.length==0||s>=t){
        return false;
    }
	int k=0;	//记录值不在s与t之间的元素个数（即需要保留的元素个数）
	for(int i=0;i<L.length;i++)
		if(L.data[i]<s||L.data[i]>t){
			L.data[k]=L.data[i];
			k++;	//不在s与t之间的元素个数增1
		}
		L.length=k;	//顺序表L的长度为k
    return true;
}
//解法二：
bool Del_s_t2(SqList &L,ElemType s，ElemType t){    
    if(L.length==0||s>=t){
        return false;
    }
	int k=0;	//记录在s与t之间的元素个数
	for(int 1=0;i<L.length;i++)
		if(L.data[i]>=s&&L.data[i]<=t){
			k++;		//在s与t之间的元素个数增1
		else
			L.data[i-k]=L.data[i];		//当前元素前移k个位置
			
		}
		L.length-=k;	//顺序表L的长度递减
    return true;
}

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

bool Del_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的长度别忘记加1
    return true;
}

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

bool Merge(SeqList A,SeqList B,SeqList &C){	//A、B前不加&，需用C返回结果，所以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(j<B.length)
		C.data[k++]=B.data[j++];
	C.length=k;    //上一步中k++已经自增，此处顺序表长度不需要再加1
	return true;
}

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

/*8.已知在一维数组A[m+n]中依次存放两个线性表(a1,a2,a3,...,am)和(b1,b2,b3,...,bn)。
试着编写一个函数，将数组中两个顺序表的位置互换。即将(b1,b2,b3,...,bn)放在(a1,a2,a3,...,am)的前面。*/
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++){	
		int t=A[left+i];
		A[left+i]=A[rirht-i];
		A[right-i]=t;
	}
}
void Exchange(Data A[],int m,int n,int arraySize){
	Reverse(A,0,m+n-1,arraySize);
	Reverse(A,0,n-1,arraySize);
	Reverse(A,n,n+m-1,arraySize);
}

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

/* 9.线性表(a1,a2,a3,...,an)中的元素递增有序且按顺序存储于计算机内。要求设计一个算法，完成用最少时间在表中查找数值为x 的元素，
若找到，则与其后继元素位置相交换，若找不到，则将其插入表中并使表中元素仍递增有序。 */
void SearchExchangeInsert(ElemType A,ElemType x){
	int left=0,right=n-1,mid;
	while(left<=right){
		mid=(left+right)/2;
		if(A[mid]==x)
			break;
		else if(A[mid]<x)
			left=mid+1;
		else
			right=mid-1;
	}
	//下面两个if只会执行一个（交换或插入）
	if(a[mid]==x&&mid=!n-1){	//只有x不是最后一个元素时，才需要交换
		int t=A[mid];
		A[mid]=A[mid+1]；
		A[mid+1]=t;
	}
	if(left>right){
		for(i=n-1;i>right;i--){
			A[i+1]=A[i];
		}
		A[i+1]=x;	//插入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）根据设计思想，采用C或C++语言描述算法，关键之处给出注释。
3）说明你设计算法的时间复杂度和空间复杂度。

/*(1)基本设计思想：可将这个问题视作把数组ab转换成数组ba(a代表数组的前p个元素，
b代表数组中余下的n-p个元素)，先将a逆置，再将b逆置，最后再整体逆置得到ba。
设Reverse函数执行将数组元素逆置的操作，Reverse中两个参数分别表示数组中待转换元素的始末位置。
(2)三个Reverse函数的时间复杂度分别为O(p/2)、O((n-p)/2)和O(n/2),
故所设计的算法的时间复杂度为O(n)，空间复杂度为O(1)。 */
void Reverse (int R[],int st,int sp){
	 for(int i=0;i<(sp-st)/2;i++){
		 int t=R[st+i];
		 R[st+i]=R[sp-i];
		 R[sp-i]=t;
	 }
 }
 void Converse(int R[],int n,int p){
	 Reverse(R,0,p-1);
	 Reverse(R,p,n-1);
	 Reverse(R,0,n-1);
 }