数据结构算法Day01

一、顺序表

#define MaxSize 50
typedef struct{
    ElemType data[MaxSize];
    int length;
}Sqlist;

1、顺序表递增有序，插入元素x，仍然增有序

第一步：找到x的所在插入位置，返回元素插入位置的值

//找到插入位置下标i
int findElem(SqList L,int x)
{
    for(int i=0;i<L.length;i++)
    {
        if(x<L.data[i])
        {
            return i;
        }
    }
    return i;
}

第二步：进行插入操作，主要在于顺序表元素后移操作

void InsertList(SqList &L,int i)
{
    int i;
    i=findElem(L,x);
    for(int j=L.length-1;j>=i;j--)
    {
        L.data[j+1]=L.data[j];
    }
    L.data[j]=x;
    L.length++;
}

2、用顺序表最后一个元素覆盖整个顺序表中最小的元素

第一步：找到最小的元素，并返回下标位置

int getMinElem(SqList L)
{
    int min=L.data[0];
    int mini;     //记录最小下标
    for(int i=0;i<L.length;i++)
    {
        if(L.data[i]<=min)
        {
            min=L.data[i];
            mini=i;
        }
    }
    return mini;
}

第二步：将最后一个元素的值赋给找到的位置

void LastToMin(SqList &L)
{
    int i=getMinElem(L);
    L.data[i]=L.data[L.length-1];
    L.length--;
}

3、将顺序表的元素逆置

void Reverse(SqList &L)
{
    int mid=L.length/2;
    int temp;
    for(int i=0;i<mid;i++)
    {
        temp=L.data[i];
        L.data[i]=L.data[L.length-i-1];
        L.data[L.length-i-1]=temp;
    }
}

4、将(a1,a2......am,b1,b2......bn)转换成(b1,b2......bn,a1,a2.......am)

第一步，将a1,a2......am逆置——>(am.......a2,a1)

第二步，将b1,b2.......bn逆置——>(bn........b2,b1)

第三步，总体逆置——>(b1,b2.......bn,a1,a2.....am)

void Reverse(SqList &L,int low,int high)
{
    int mid=(low+high)/2;
    int temp;
    for(int i=low;i<mid;i++)
    {
        temp=L.data[i];
        L.data[i]=L.data[high-i];
        L.data[high-i]=temp;
    }
}

void swap(SqList &L)
{
    Reverse(L,0,m-1);
    Reverse(L,m,m+n-1);
    Reverse(L,0,m+n-1);
}

5、删除顺序表中所有值为x的元素

法一：

对顺序表进行依次遍历，找到值为x的元素位置，此位置之后的元素依次往前移，并修改线性表长度

void delElemByValue(SqList &L,int x)
{
    for(int i=0;i<L.length;i++)
    {
        if(L.data[i]==x)
        {
        for(int j=i;j<L.length-1-i;j++)
        L.data[j]=L.data[j+1];
        L.length--;
        }
    }
}
            

法二：

对顺序表进行遍历，只要该元素的值不为x，则依次放入顺序表中，利用count记录线性表长度

void delElemByValue(SqList &L,int x)
{
    int count=0;
    for(int i=0;i<L.length;i++)
    {
        if(L.data[i]!=x)
        {
        L.data[count++]=L.data[i];
        }
    L.length=count;
    }
}
     

6、从顺序表中删除给定值在s到t之间（包含s和t）的所有元素

与上题法二思路相同

void delElemByScope(SqList &L,int s,int t)
{
    int count=0;
    for(int i=0;i<L.length;i++)    
    {
        if(L.data[i]>t || L.data[i]<s)
        {
            L.data[count++]=L.data[i];
        }
    L.length=count;
    }
}

7、从有序表中删除所有值重复的元素

因为是有序表，所以重复元素必定是连续存放，第一个元素必为非重复元素，将其看做一个有序表，后来的元素每次与有序表中最后一个元素进行比较，若非重复元素，则加入有序表，若是重复元素，继续比较下一个元素。

void delSameElem(SqList &L)
{
    int count=1;
    for(int i=0;i<L.length-1;i++)
    {
        if(L.data[i+1]!=L.data[i])
        {
           L.data[count++]=L.data[i+1];
        }
    }
    L.length=count;
}

8、两个递增有序表合并成一个递增有序表

void MergeList(SqList lista,SqList listb,SqList listc)
{
    int i=0,j=0,k=0;
    while(i<lista.length && j<listb.length)
    {
        if(lista.data[i] <= listb.data[j])
        {
            listc.data[k]=lista.data[i];
            i++;
            k++;
        }
        else
        {
            listc.data[k]=listb.data[j];
            j++;
            k++;
        }
    }

    //当lista有剩余    
    while(i<lista.length)
    {
        listc.data[k]=lista.data[i];
        k++;
        i++;
    }

    //当listb有剩余
    while(j<listb.length)
    {
        listc.data[k]=listb.data[j];
        k++;
        j++;
    }
    listc.length=k;
}

9、求两个递增序列合并之后的中位数

注：可利用上一题排好的序列直接找到中间位置的值

10、设计一个时间上尽可能高效的算法，找出数组中未出现的最小正整数

1、若数组A中元素都小于1，则直接返回最小正整数1

2、若数组A中元素都大于1，则定义一个数组B，数组B长度为数组A中值最大的元素加1，B初始化元素为0，遍历A中元素，只要值大于0，则直接将B下标为该值的内容修改为1，遍历完成后输出B数组第一个值为0的下标。

int GetValue(SqList lista,int max){  
    int B[max+1];
    int temp;
    //建立数组B，用空间换时间
    for(int i=0;i<max+1;i++)
    {
       B[i]=0;
    }
    
    //情况一
    if(max<1) 
       return 1;
    
    //情况二
    for(int i=0;i<lista.length;i++)
    {
       if(lista.data[i]>0)
        {
             temp=lista.data[i]-1;
             B[temp]=1;
        }
    }
    for(int i=0;i<max+1;i++)
    {
       if(B[i]==0)     
          return i+1;  
    }
}