王道考研第二章编程代码，不是答案

最新推荐文章于 2024-04-27 18:02:39 发布

瞳冷千本花

最新推荐文章于 2024-04-27 18:02:39 发布

阅读量92

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/wang_cliwei/article/details/118874073

版权

线性表

顺序表

基本代码

#include <stdio.h>
#include <stdlib.h>

#define InitSize 50
#define true 1
#define   false 0
typedef struct
{
    int *data;
    int MaxSize,length;
}SeqList;

_Bool ListInsert(SeqList * L,int i,int  e)
{
    if(i<1||i>L->length+1)
        return false;
    if(L->length>=L->MaxSize)
        return  false;
    for(int j=L->length;j>=i;j--)
    {
        L->data[j]=L->data[j-1];
    }
    L->data[i-1]=e;
    L->length++;
    return true;

}
_Bool ListDelete(SeqList *L,int  i,int * e)
{
    if(i<1||i>L->length)
        return false;
    *e=L->data[i-1];
    for(int j=i;j<L->length;j++)
    {
        L->data[j-1]=L->data[j];
    }
    L->length--;
    return true;

}
int LocateElem(SeqList *L,int e)
{
    int i;
    for(i=0;i<L->length;i++)
    {
        if(L->data[i]==e)
        {
            return i+1;
        }
    }
    return -1;
}
_Bool IsEmpty(SeqList * L)
{
    if(L->length==0)
    {
        return true;
    }
    return  false;
}
void ListPrint(SeqList *L)
{
    for(int i=0;i<L->length;i++)
    {
        printf("%d ",L->data[i]);
    }
}

int  SearchMin(SeqList * L,int *temp)
{
    int min = L->data[0];
    int  k=0;
    for(int i=1;i<L->length;i++)
    {
        if(min>L->data[i])
          {
            min=L->data[i];
            k=i+1;
          }
    }
    *temp=min;
    return k;
}

P2
要求：空间复杂度为O(1)

_Bool Reverse(SeqList *L)
{
    int i=0;
    int temp;
    for(i=0;i<L->length/2;i++)
    {
        temp=L->data[i];
        L->data[i]=L->data[L->length-1-i];
        L->data[L->length-1-i]=temp;
    }
    return true;
}

P3
要求时间复杂度O(n),空间复杂度O(1)

_Bool DeleteAllX(SeqList *L,int x)
{
    int i=0,j=0;
    for(i=0;i<L->length;i++)
    {
        if(L->data[i]!=x)
        {
            L->data[j]=L->data[i];
            j++;

        }
    }
    L->length=j;
}

P4，P5

_Bool DeleteTtoS(SeqList * L,int t,int s)
{
    if(t>=s)
        return false;
    int i=0,j=0;
    for(i=0;i<L->length;i++)
    {
        if(L->data[i]<t||L->data[i]>s)
        {
            L->data[j]=L->data[i];
            j++;
        }
    }
    L->length=j;
    return true;

}

_Bool DeleteRepeat(SeqList *L)
{
    int i=0,j=0;
    L->data[j]=L->data[i];
    for(i=1;i<L->length;i++)
    {

       if(L->data[j]!=L->data[i])
       {
           j++;
           L->data[j]=L->data[i];

       }
    }
    L->length=j+1;
    return true;
}

SeqList MergeList(SeqList *L1,SeqList *L2)
{
    int ML=L1->length+L2->length;
    SeqList MList;
    MList.data = (int*) malloc(sizeof(int)*ML);
    MList.length=ML;
    int i=0,j=0;
    for(i=0;i<L1->length;i++)
    {
        MList.data[i]=L1->data[i];
    }
    for(j=0;j<L2->length;j++)
    {
        MList.data[j+i]=L2->data[j];
        //printf("%d  ",j);
    }
    return MList;


}

_Bool  ReverseList(SeqList *L,int m,int  n)
{
    int i=0;
    int j=0;
    int a[m];
    int  b[n];
    for(i=0;i<m;i++)
    {
        a[i]=L->data[i];
        //printf("%d",a[i]);
    }
    for(j=0;j<n;j++)
    {
        b[j]=L->data[j+i];
    }
    int k=0,t=0;
    for(k=0;k<n;k++)
    {
        L->data[k]=b[k];
    }
    for(t=0;t<m;t++)
    {
        L->data[k+t]=a[t];
    }
    return true;

}

_Bool SearchorInsert(SeqList *L,int  x)
{
    int low=0;
    int  high=L->length-1;
    int mid=(low+high)/2;
    _Bool flag =false;
    while(low<=high)
    {
        printf("low :%d  mid :%d  high: %d ",low,mid,high);
        printf("\n");

        if(L->data[mid]==x)
        {
            int  temp=L->data[mid];
            L->data[mid]=L->data[mid+1];
            L->data[mid+1]=temp;
            flag = true;
        }
        else if(L->data[mid]>x)
        {
            high=mid-1;
        }
        else if(L->data[mid]<x)
        {
            low=mid+1;
        }
        mid=(low+high)/2;
    }

    if(flag==false)
    {

        for(int  i=L->length;i>mid;i--)
    {
        L->data[i]=L->data[i-1];
    }
    L->data[mid+1]=x;
    L->length++;

    }
    printf("low :%d  mid :%d  high: %d ",low,mid,high);
        printf("\n");
        printf("%d",flag);

    return flag;


}

P10
注：空间复杂度为O(n),时间复杂度为O(n)。(标准答案空间复杂度为O(1)).

_Bool ConverseList(SeqList *L,int p)
{
    int i=0;
    int  temp[p];

    for(i=0;i<p;i++)
    {
        temp[i]=L->data[i];
        printf("%d\n",temp[i]);
    }
     for(i=0;i<L->length-p;i++)
    {
        L->data[i]=L->data[i+p];
    }
    for(i=0;i<p;i++)
    {
        L->data[L->length-p+i]=temp[i];
    }
}

P11
思路为二路归并排序
注：时间复杂度为O(log2n)，空间复杂度为O(n+m)。

int  MidNum(SeqList *L1,SeqList* L2)
{
    int a[L1->length+L2->length];
    int  LL=L1->length + L2->length;
    int  mid=0;
    int i=0,j=0,k=0;
    for(i=0,j=0,k=0;(j<L2->length)&&(i<L1->length)&&(k<LL);k++)
    {

        if(L1->data[i]<L2->data[j])
        {

            a[k]=L1->data[i];
            i++;

        }
        else  if(L1->data[i]>=L2->data[j])
        {
            a[k]=L1->data[j];
            j++;
        }
        if(k==LL/2)
        {
            mid=a[k];


        }
    }
    return mid;
}

P12
注：空间复杂度O(n)，时间复杂度O(n)。

int  SearchMain(SeqList *L)
{
    int n=L->length;
    int a[n];
     int i=0;
    for(i=0;i<L->length;i++)
    {
        a[i]=0;
    }

    for(i=0;i<L->length;i++)
    {
        a[L->data[i]]++;

    }
    for(i=0;i<L->length;i++)
    {
        printf("%d\n",a[i]);
    }
    int  temp=-1;
    for(i=0;i<n;i++)
    {
        if(a[i]>a[i+1])
            temp=i;
    }
    if(temp<=n/2)
        temp=-1;
    return  temp;
}

int cmp(const void *a, const void *b)
{
     return(*(int *)a-*(int *)b);
}

int  LeastNum(SeqList *L)
{
    qsort(L->data,L->length,sizeof(L->data[0]),cmp);
    int  i=0;
    int t=0;
    int  flag=false;
    int temp=L->data[L->length-1];
    for(int i=0;i<L->length;i++)
    {
        if(L->data[i]<=0);
        else if(L->data[i]>1&&flag==false)
        {
            temp=1;
            return temp;
        }
        else if(L->data[i]>1&&flag==true)
        {
            t++;
            if(t==L->data[i])
            {
                temp=t;
            }
            else if(t!=L->data[i])
              {
                  temp=t;
                return temp;
              }
        }
        else if(L->data[i]==1)
        {
            t++;
            flag=true;

        }
    }
    return L->data[L->length-1]+1;
}