关于线性表的几个小题

最新推荐文章于 2022-11-08 20:19:28 发布

YaWenSg

最新推荐文章于 2022-11-08 20:19:28 发布

阅读量331

点赞数

本文链接：https://blog.csdn.net/YaWenSg/article/details/119007293

版权

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

bool Del_Min(SeqList &L ,ElemType &value){
    if(L.length == 0)
          return false;     //表空，中止操作
    value=L.data[0];        //将表中的首个元素定为 初始的最小值
    int pos=0;
    for(int i=1;i<L.length;i++){    
        if(L.data[i]<value)       
            value=L.data[i];   //让value记忆当前具有最小值的元素
            pos = i;
        }
    L.data[pos]=L.data[L.length-1];  //填补
    length--;    //长度减少
    return true;
}

2.设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O（1）。

void Reverse(SeqList &L){
    ElmeType temp;
    for(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;
    }
}

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

解法二：

顺序表 x=3

删除3 k=2

前移 2 ，表长-k

解法一：用k记录顺序表L中不等于x的元素个数，边扫描L边统计k，
并将不等于x的元素向前移动k个位置，最后修改L的长度。
void del_x_1(SeqList &L,ElemType x){
    int k=0;
    for(i=0;i<L.length;i++)
        if(L.data[i]!=x){
            L.data[k]=L.data[i];
            k++;
        }
    L.length=k;
}


解法二：用k巨鹿顺表L中等于x的元素个数，边扫描L边统计k，
并将不等于x的元素向前移k个位置，最后修改L的长度

void del_x_2(SeqList &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_s_t2(SeqList &L,ElemType s,ElemType t){
    int i,j;
    if(s>=t||L.length==0)
        return false;
    for(i=0;i<L.length &&L.data[i]<s;i++);//寻找值大于等于s的第一个元素
    if(i>=L.length)
        return false;                     //所有元素值均小于s，返回
    for(j=i;j<L.length&&L.data[j]<=t;j++);//寻找值大于t的第一个元素
    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_s_t(SeqList &L,ElemType s,ElemType t){
    int i,k=0;
    if(L.length == 0||s>=t)    
        return false;          //线性表为空或s、t不合法，返回
    for(i=0;i<L.length;i++){
        if(L.data[i]>=s&&L.data[i]<=t)
            k++;
        else
        L.data[i-k]=L.data[i]; //当前元素前移k个位置
    }
    L.length-=k;   //长度减少
    return true;
}

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

bool Delete_Same(SeqList &L){
    if(L.length == 0)
        return false;
    int i,j;                     //存储第一个不相同的元素，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;
}


这里给一个我自己写的算法
 bool Delete_Same(SeqList &L){
    if(L.length == 0)
        return false;
    int i,k=0;
    for(i=0;i<L.length;i++)
        if(L.data[i+1]=L.data[i])    
            k++;
        else
            L.data[i-k]=L.data[i+1];
    L.length-=k;
    return true;
}

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

bool Merge(SeqList A,SeqList B,SeqList &C){
    if(A.length+B.length>C.length)  //大于顺序表的最大长度
        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;
}

8.已知在一维数组A[m+n]中依次存放俩个俩个线性表（a1，a2，a3，a4....am）和（b1，b2，b3....bn）。试编写一个函数，将数组中俩个顺序表的位置互换，即将b1，b2，b3....bn）放在（a1，a2，a3，a4....am）前面。

算法思想：先将数组A[m+n]中的全部元素（a1,a2,a3,...,am,b1,b2,b3,..,bn）原地逆置为（bn，bn-1，...b1，am,am-1,..,a1），再对前n个元素和后m个元素分别使用逆置算法，从而实现顺序表的位置互换。

typedef int DataType;  //对于以后不同的类型，只需要修改 int就行。
void Reverse(DataType A[],int left,int right,int arraySize){
//逆转(aleft,aleft+1,...,aright)为(aright,aright-1,...,aleft)
    if（left>=right||right>=arraySize)
        return false;
    int mid=(left+right)/2;n
    for(int i=0;i<mid-left;i++){
        Datatype temp=A[letf+i];
        A[left+i]=A[right-i];
        A[right-i]=temp;
    }
}
    
void Exchange(DataType A[],int m,int n,int arraySize){
    Reverse(A,0,m+n-1,arraySize);
    Reverse(A,0,n-1,arraySize);
    Reverse(A,n,m+n-1,arraySize);
}

9.线性表（a1，a2，a3，a4....an）中的元素递增有序且按顺序存储于计算机内。要求设计一个算法完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置交换，若找不到，则将其插入表中并使表中元素仍递增有序。

算法思想，顺序存储的线性表递增有序，可以顺序查找，也可以折半查找。这里要求最少时间因此使用折半查找法。
    
void SearchExchangeInsert(ElemType A[],ElemType x){
    int low=0,high=n-1,mid;
    while(low<=high){
        mid=(low+high)/2;
        if(A[mid]==x) break;
        else if(A[mid]<x)  low=mid+1;
        else high=mid-1;
       }    
        if(A[mid]==x&&mid!=n-1){

            t=A[mid];
            A[mid]=A[mid+1];
            A[mid+1]=t;
       }
        if(low>high){
                for(i=n-1;i>high;i--)
                    A[i+1]=A[i];
                A[i+1]=x;
        }
   }