1.顺序表L
#define InitSize 100
typedef struct{
ElemType *data;
int MaxSize,Length;
}SeqList;
2、 在顺序表L中第i个位置插入一个元素e
思路：第i个位置之后的元素后移，并将每一个元素都往后挪一个位置，在将e放入第i个位置，注意第i个位置的数组下标是i-1
bool ListInsert(SqList &L,int i,ElemType e ){
if(i<1||i>L.length+1)
return false;
if(L.length>=Maxsize)
return false;
for(int j=L.Length;j>=i;j--) //注意J的范围
L.data[j]=L.data[j-1];
L.data[i-1]=e;
L.Length++;
return true;
}
3、在顺序表L中删除第i个位置的元素
思路：将第i个位置的值赋给一个变量e，后续所有元素前移一个位置。
bool ListDelete(SqList &L,int i,ElemType e){
if(i<1||i>L.length+1) //i代表的是位置，最往前在第一个位置，最往后在所有元素的后面
return false;
e=L.data[i-1];
for(int j=i-1;j<L.length-1;j++){ //j代表的是数组下标，大于等于i-1，小于等于length-2（length-1是最后一个数组下标，最后应该是倒数第一个数组的值赋给倒数第二个数组，所以j最后应该是等于length-2）
L.data[j]=L.data[j+1];
}
L.Length--;
return true;
}
4、在顺序表中查找值为e的元素，返回位序
int ListSearch(SqList &L,ElemType e){
int i;
for(i=0;i<L.length;i++){
if(L.data[i]==e){
return i+1;
}
return 0;
}
}
5、从顺序表中删除具有最小值的元素（假设唯一），并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。
思想：搜索整个顺序表，查找最小的元素，然后再次搜寻顺序表，寻找这个最小元素的位置，将最后一个元素赋值到这个位置然后跳出循环。（此方法多用了一次循环，浪费了资源，最好在一次循环中定两个参数去记录当前最小元素的值与位置，等循环完毕后就得到了最小元素的值以及位置便可进行后续。）
int ListDeleteMin(SqList &L){
if(L.Length==0){
printf("顺序表为空");
return 0;
}
int value=L.data[0];
for(int i=0;i<L.length;i++){
if(L.data[i]<value)
value=L.data[i];
}
for(int j=0;j<L.length;j++){
if(L.data[i]=value){
L.data[i]=L.data[L.length-1];
break;
}
}
L.length--;
return value;
}
6、将顺序表中的元素逆置，要求算法的空间复杂度为O（1）
思想：将数据表分割成两部分，前一部分的元素逐一与后半部分的元素做交换。(0<=i<=Length-i-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;
}
}
7.删除线性表中所有值为x的值
思想：用K记录顺序表L中等于x的元素个数，边扫描边统计k,并将不等于x的元素向前移k个位置，最后修改L的长度。
void(SqList &L,ElemType x){
int i=0,k=0;
while(i<L.length){
if(L.data[i]==x)
k++;
else
L.data[i-k]=L.data[i]; //当前元素前移K个位置
i++;
}
L.length-=K;
}
8、从有序顺序表中删除在给定值之间的所有元素
思想：设置一个参数k，记录处于s与t之间的元素个数，最后将后续的元素前移k
bool DeleteValue(SqList &L,int s,int t){
if(s>=t||L.length==0){
return false;
}
int k=0;
for(int 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;
}
9、从有序数据表中删除所有值重复的元素，使表中的值各不相同
思想：初试时将第一个元素视作非重复的有序表，之后陆续判断后面重复有序表的元素是否与前面非重复有序表的最后一个元素是否相同，（因为是有序表，所以相同的元素一定在一起）a、如果相同则检测重复有序表的下一个元素与非重复有序表的最后一个元素是否相同，b、如果不同则将此元素插入到非重复有序表的下一个位置（++i）
bool Delete_Same(SqList &L){
if(L.length==0){
return false;
}
int i,j;
for(i=0,j=1;j<L.length;j++){
if(L.data[j]!=L.data[i])
L.data[++i]=L.data[j]
}
L.Length=i+1;
return true;
}
10、两个有序顺序表合成一个新的有序顺序表，并由函数返回结果顺序表
思想：首先，按顺序不断取两个有序表中较小的节点存在新的数据表中。然后，看哪个表还有剩余，将剩下的部分加到新的顺序表后面，
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;
}
11、在一维数组中的两个顺序表互换位置
思想：先将数组A所有的元素逆置，再将前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;
}
}
Reverse(A,0,m+n-1,arraySize);
Reverse(A,0,n,arraySize);
Reverse(A,n,m+n-1,arraySize);
12、查找顺序表中的某个值,找到后与后一个值交换
思想：折半查找
void SearchExchange(ElemType A[],ElemType x){
int low=0,high=n-1,mid;
while(low<high){
mid=(low+high)/2;
if(x==A[mid])break;
else if(A[mid]<x)
low=mid+1;
else
high=mid-1;
}
if(A[mid]=x&&mid!=n-1){
int t=A[mid];
A[mid]=A[mid+1];
A[mid+1]=t;
}
if(low>high){
for(int i=n-1;i>high;i--)
A[i+1]=A[i];
A[i+1]=x'
}
}