数据结构算法

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

bool Del_Min(SqLsit &L,ElemType &value){
    if(L.length==0)
        return false;    //表空，终止操作
    value=L.data[0];
    int pos=0;            //假定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)

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

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

#法一
void del_x_l(Sqlist &L,Elemtype x){
    int k=0,i;
    for(i=0;i<L.length;i++)
        if(L.data[i]!=x){
            L.data[k]=L.data[i];
            k++;
}
     L.length=k;
}
#法二
void del_x_l(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];
        i++;
    }
    L.length=L.length-k;
}

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

bool del_part(Sqlist &L,Elemtype s,Elemtype t;){
    if(L.length==0||s>=t)
        return false;
    for(int i=0;i<L.length&&data[i]<s;i++); //寻找值大于等于s的第一个元素
    if(i>L.length)
        return false;
    for(int j=i;j<L.length&&data[j]<=t;j++);
    for(;j<L.length;i++;j++)
        L.data[i]=L.data[j];
    L.length=i;
    return true;   
}
}

顺序存储结构的特点：存储密度大

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

bool del_part(Sqlist &L,Elemtype s,Elemtype t){
    int i,k=0;
    if(L.length==0||s>=t)
        return false;
    for(int i=0;i<L.length;i++){
        if(data[i]>=s&&data[i]<=t){
            k++;
        else
            L.data[i-k]=L.data[i];
        
        }
}
    L.length-=k;

    return true;   
}
}

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

bool Del_Same(SeqList &L){
    if(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;
}
}

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

bool Merge(SeqList A,SeqList B,SeqList &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;
}