关于顺序表的算法设计（待更新）

1. 顺序表的合并
   要求：如果有重复元素则合并
   分析：取两个表长m和n，循环n次判断L1中是否存在e==L2.data[2]；

   void MergeList(List &L1, List &L2) {
   int m = L1.length;
   int n = L2.length;
   for(int i=0; i<n; i++) {
   	if(LocateElem(L1, L2.data[i]) < 0)
   		InsertList(L1, ++m, e); 
   }
   }
   

   该算法的时间复杂度为O(mn)

2. 有序顺序表的合并
   要求：如果有重复元素不用合并
   分析：创建一个新表，利用两个指针依次移位，判断后填入新表元素

   void MergeList(List L1, List L2, List &3) {
   	L3.length = L1.length + L2.length;
   	L3.data = (ELemType *)malloc(MAXSIZE*sizeof(ElemType);//初始化L3
   	ElemType *p1 = L1[0], *p2 = L2[0];
   	ElemType *p1_last = L1[L1.length-1], *p2_past = L2[L2.length-1];//设置指针指向最后一个元素，便于判断终止条件
   	int i=0;//记录L3的数组下标
   	while(p1<=p1_past&&p2<p2_past) { 
   		if(*p1 <= *p2) L3.data[i++] = *p1++
   		else L3.data[i++] = *p2++;
   	}
   	while(p1<=p1_past) L3.data[i++] = *p1++;//如果L1还有剩余元素，依次填入L3
   	while(p2<=p2_past) L3.data[i++] = *p2++;//如果L2还有剩余元素，依次填入L3
   }
   

3. 从顺序表删除最小值（假定唯一），返回被删除元素的值，空出位置由最后一个元素填补，若顺序表空，退出运行。
   算法思想：“擂台挑战”法记录最小值的位次

bool deleteElem(SqList &L, ElemType &e) {
	if(L.Length == 0) return false;
	int index = 0;//记录最小值位次
	for(int i=0; i<L.Length; i++)
		if(L.data[index]>L.data[i])
			index = i;
	e = L.data[index];//由函数引用返回最小值
	L.data[index] = L.data[--L.Length];
	return true;
}

4. 逆置顺序表，要求时间复杂度为O(1)
   算法思想：在顺序表内首尾向中间值靠近，依次交换

void ReverseList(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;
	}
		
}

5. 从有序顺序表删除给定值在s与t之间的所有元素（包含s和t）
   算法思想：找到大于等于s的第一个元素和大于t的第一个元素，将从大于t的一个元素到表尾元素依次前移覆盖

bool DeleteST(SqList &L, ElemType s, ElemType t) {
	int i=0, j=0;
	for(; L.data[i]<s && i<L.Length; i++);//找大于等于s的第一个元素
	if(i >= L.Length) return false;//没找到s，退出
	for(j=i; L.data[j]<=t&&j<L.Length; j++); //找大于t的第一个元素
	for(; j<L.Length; i++,j++)
		L.data[i] = L.data[j];
	L.Length = i;
	return true;
}

6. 对于长度为n的顺序表，删除所有值为x的元素，要求时间复杂度为O(n)，空间复杂度为O(1)
   算法思想：
   方法一：循环判断值不为x的元素依次填入原顺序表

void DeleteX(SqList &L, ElemType x) {
	int i=0,j=0;
	for(; i<L.Length; i++) 
		if(L.data[i] != x) L.data[j++] = L.data[i];
	L.Length = j; 	
}

方法二：用一个标记mark记录和x值相等的个数，在循环中将每个元素前移mark位

void DeleteX(SqList &L, ElemType x) {
	int mark = 0;
	for(int i=0; i<L.Length; i++) {
		if(L.data[i] == x) 
			mark++;
		else 	
			L.data[i-mark] = L.data[i];
	}
	L.Length -= mark;	
}

7. 从有序顺序表中删除值重复的元素，使表中每个元素都不相同
   算法思想：循环将元素依次放入表中，放入之前判断与前一元素是否相同

void DeleteRepeat(SqList &L) {
	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;
}

8. 从无序顺序表中删除值重复的元素，使表中每个元素都不相同（散列表？
9. 已知在A[m+n]中依次存放两个线性表(a1, a2, a3, …, am)和(b1, b2, …, bn)。将数组中两个顺序表的位置互换，即为(b1, b2, …, bn)(a1, a2, a3, …, am).
   算法思想：交换两个表的位置，即将两个表分别逆置，再总体逆置。需要用到两个函数

void ReverseElem(SqList &L, int a, int b) { //逆置从a到b的元素，需注意a和b代表位次而非数组下标 
	ElemType temp;
	for(int i=a-1; i<(a+b-1)/2; i++){
		temp = L.data[i];
		L.data[i] = L.data[b-i+a-2];//b-1-[i-(a-1)]
		L.data[b-i+a-2] = temp;
	}		
}//该函数的可读性不强，可再改进
void Reverse(SqList &L, int m, int n) {
	ReverseElem(L, 1, m);
	ReverseElem(L, m+1, n);
	ReverseElem(L, 1, m+n);
}

10. (a1, a2, a3, …, am)内元素递增有序，顺序存储。编写写用最少时间在表中查找数值为x的元素，若找到，将其与后继元素位置互换，若找不到，将其插入表中，使表仍递增有序。
    算法思想：元素递增有序，则可用二分查找数值为x的元素。判断相等则互换，low>high则进行插入操作

void LocateX(SqList &L, ElemType x) { 
	int low = 0, high = L.Length-1, mid;
	while(low<=high){//注意是小于等于 
		mid = (low+high)/2;
		if(L.data[mid] == x) break;
		if(L.data[mid] > x) high = mid-1;
		if(L.data[mid] < x) low = mid+1;
	}
	if(L.data[mid] == x && mid != L.Length-1) {//注意若x为最后一个元素则不存在交换操作！
		L.data[mid] = L.data[mid+1];
		L.data[mid+1] = x;
	}
	if(low>high) 
	{
		for(int i=L.Length-1; i>=low; i--)//low所指元素即为第一个大于x大的元素，将其插入到low的位置 
			L.data[i+1] = L.data[i];
		L.data[low] = x;
		L.Length++;
	}
}