王道数据结构考研之顺序表练习题

1、设计一个高效算法，将顺序表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-i-1];
			L.data[L.length-i-1]=temp;
		}
	}

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

	算法思想：用k记录顺序表L中等于x的元素个数，边扫描L边统计k,并将不等于x
的元素前移k个位置，最后修改L的长度
	void del_x(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];//元素前移k个位置
			}
			i++;
		}
		L.length=L.length-k;//L长度减短k
	}

3、从顺序表中删除值在s和t之间的所有元素，如果s和t不合理，显示错误信息并退出。

	算法思想：从前向后扫描顺序表L,用k记录下元素值在s和t之间的个数，不在s
和t之间的，则前移k个位置
	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];//当前元素前移k个位置	
		}
		L.length -= k;
		return true;
	}

4、从有序的顺序表中删除所有的重复的元素，使得顺序表的元素不重复

	算法思想： 使用类似于直接排序的思想，初始时将第一个元素视为非重复的有
序表，之后依次判断与前面的最后一个元素是否相同。
	bool del_same(SqList &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;
	}

5、将两个有序表合并成一个有序表

	算法思想：按顺序不断取下两个顺序表的较小的元素放入新的顺序表中，然后
看哪个表有剩余，将剩余部分加到新的顺序表后面。
	bool Merge(SqList A, SqList B, SqList &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;
		return true;
	}

6、已知在一维数组A[m+n]中依次存放两个线性表（a1,a2…,am）和（b1,b2…,bn），编写算法将两个线性表位置对换成（b1,b2,…bn,a1,a2,…am）

	算法思想：先把整个数组反转逆置成[bn,...b2,b1,am,...a2,a1],再对前n个
和后m个原地逆置。
	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){
		Reverse(A,0,m+n-1,srraySize);
		Reverse(A,0,n-1,arraySize);
		Reverse(A,n,m+n-1,arraySize);
	}