题目：从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除元素的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。
答案：算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置。代码如下：
bool Del_Min(sqList &L,ElemType &value){
//删除顺序表L中最小值元素节点，并通过引用型参数value返回其值
//若删除成功，则返回true；否则返回false
if(L.length==0)
return false; //表空，中止操作返回
value=L.data[0];
int pos=0; //假定0号元素的值最小
for(int i=1;i //让value记忆当前具有最小值的元素
value=L.data[i];
pos=i;
}
L.data[pos]=L.data[L.length-1]; //空出的位置由最后一个元素填补
L.length--;
return true;
}
题目：从有序顺序表中删除其值在给定值s与t之间（要求s
bool Del_s_t(SqList &L,ElemType s,ElemType t){
//删除有序顺序表L中值在给定值s与t之间的所有元素
int i,j;
if(s>=t||L.length==0)
return false;
for(i=0;i=L.length)
return false; //所有元素值均小于s，返回
for(j=i;j
题目：将两个有序顺序表合并成一个新的有序顺序表，并由函数返回结果顺序表
答案：首先，按顺序不断取下两个顺序表表头较小的节点存入新的顺序表。然后，看哪个表还有剩余，将剩下的部分加到新的顺序表后面。代码如下：
bool Merge(SeqList A,SeqList B,SeqList &C){
//将有序顺序表A与B合并为一个新的有序顺序表C
if(A.length+B.length>C.maxSize) //大于顺序表的最大长度
return false;
int i=0,j=0,k=0;
while(i //循环，两两比较，小者存入结果表
if(A.data[i]<=B.data[j])
C.data[k++]=A.data[i++];
else
C.data[k++]=B.data[j++];
}
while(i
题目：设将
n
(
n
>
1
)
n(n>1)
n(n>1)个整数存放到一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移
p
(
0
<
p
<
n
)
p(0
（1）算法思想：
可将这个问题视为把数组
a
b
ab
ab 转换成数组
b
a
ba
ba（a代表数组的前
p
p
p 个元素，
b
b
b 代表数组中余下的
n
−
p
n-p
n−p 个元素），先将
a
a
a 逆置得到
a
−
1
b
a^{-1}b
a−1b，再将
b
b
b 逆置得到
a
−
1
b
−
1
a^{-1}b^{-1}
a−1b−1，最后将整个
a
−
1
b
−
1
a^{-1}b^{-1}
a−1b−1 逆置得到
(
a
−
1
b
−
1
)
−
1
=
b
a
(a^{-1}b^{-1})^{-1}=ba
(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;
（2）代码如下：
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+i]=R[to-i];
R[to-i]=temp;
}
}
void Converse(int R[],int n,int p){
Reverse(R,0,p-1);
Reverse(R,p,n-1);
Reverse(R,0,n-1);
}
（3）复杂度分析：
上述算法中三个Reverse函数的时间复杂度分别为O(p/2),O((n-p)/2)和O(n/2)，故所设计的算法的时间复杂度为O(n)，空间复杂度为O(1)。
