王道上几道顺序表的小题（上）

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

bool delMinValue(Sqlist &L, ElemType &data){
    if(L.length == 0){
        return false;
    }
    value = data[0];
    int pos = 0;
    for(int i = 0, length = L.length; i < L; ++i){
        if(L.data[i] < value){
            value = L.data[i];
            pos = i;
        }
    } 
    L.data[pos] = L.data[L.length - 1];
    L.length--;
    return true;
}

• 设计一个高效算法，将顺序表的所有元素逆置，要求算法的空间复杂度为O(1)

void Reverse(Sqlist &L){
    ElemType temp;// 临时变量
    for(int i = 0, length = L.length / 2; i < length; ++i){
        temp = L.data[i];
        L.data[i] = L.data[length - i - 1];
        L.data[length - i - 1] = temp;
    }
}

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

void del_x(Sqlist &L, ElemType x){
    // 从前向后遍历，记录不等于x的数量，遇到x时，使用后面一个元素替换x，长度减1
    int k = 0;
    for(int i = 0, length = L.length; i < length; ++i){
        if(L.data != x){
            L.data[k] = L.data[i];
            k++;
        }
    }
    L.length--;
}

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

bool del_s_t(Sqlist &L, ElemType s, ElemType t){
    // 找到大于s小于t的这段元素，并将其删除
    if(s >= t || L.length == 0){
        return false;
    }
    int i, j;
    for(i = 0; i < L.length && L.data[i] < s; ++i);
    if(i >= L.length){
        return false;
    }
    for(j = i; j < L.length && L.data[i] <= t; ++j);
    if(j >= L.length){
        return false;
    }
    for(;j < L.length; i++, j++){
        L.data[i] = L.data[j];
    }
    L.length = i + 1;
    return true;
}

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

bool del_s_t(Sqlist &L, ElemType s, ElemType t){
    // 记录大于等于s且小于等于t的元素长度为k，并将其后面的元素前移k个位置
    if(L.length > 0 || s>=t){
        return false;
    }
    int i, k = 0;
    for(i = 0, length = L.length; i < length; ++i){
        if(L.data[i] >= s || L.data[i] <= t){
            k++;
        }else{
            data[i - k] = L.data[i];
        }
    }
    L.length -= k;
    return true;
}

这个算法相比上个算法效率要高，只用了一次遍历就完成

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

bool delete_same(Sqlist &L){
    // 类似于插入排序，把不同的元素插入到前面的无重复元素的序列中
    if(L.length == 0){
        return false;
    }
    for(int i = 0, j = 1, length = L.length; j < length; ++j){
        if(L.data[i] != L.data[j]){
            L.data[++i] = L.data[j];
        }
    }
    L.length = i + 1;
    return true;
}

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

bool Merge(Seqlist A, Seqlist B, Seqlist &C){
    if(A.length + B.length > C.maxSize){
        return false;
    }
    int i = j = 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 + 1;
    return true;
}