顺序表的一些用法

顺序表的结构体定义：

typedef int ElemType;
typedef struct {
  ElemType *elem;//存储空间基地址
  int listsize;//表容量大小
  int length;//元素个数
}SqList;

顺序表的初始化：

InitSqList(SqList &L)
{
    L.elem=(ElemType*)malloc(100*sizeof(ElemType));
    if(!L.elem) return -1;
    L.length=0;
    L.listsize=100;
    return 1;
}

对顺序表L进行遍历并输出每个数据元素的数据值：

void PrintSq(SqList L)
{
    for(int i=0;i<L.length;i++)
    {
        if(i==0)
            cout<<L.elem[i];
        else
            cout<<" "<<L.elem[i];
    }
    cout<<endl;
}

假设有一顺序表L，其存储的所有数据元素均为不重复的正数，查找L中值为e的数据元素，若找到则返回其下标（下标从0开始），若找不到则返回-1；

int Search_e(SqList L,int e)
{
    for(int i=0;i<L.length;i++)
    {
        if(L.elem[i]==e)
            return i;
    }
    return -1;
}

假设有一顺序表L,其存储的所有数据元素均为正数，查找L中第i个数据元素，并返回其值；

int Search_i(SqList L,int i)
{
   if(i>L.length||i<=0)
    return -1;
   else
    return L.elem[i-1];
}

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

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

在顺序表L的第i个位置插入新元素e。若i的输入不合法，则返回false，表示插入失败；否则，将第i个元素及其后的所有元素依次后移一个位置，腾出一个空间位置插入新元素e，顺序表长度加1，插入成功，返回true。

bool Insert_Sq(SqList &L,int i,int e)
{
    if(i>L.length+1||i<1)
        return false;
    if(L.length>=L.listsize)
    {
        L.elem=(ElemType*)realloc(L.elem,(L.listsize+10)*sizeof(ElemType));
        if(!L.elem)
            return false;
        L.listsize+=10;
    }
    for(int j=L.length;j>=i;j--)
    {
        L.elem[j]=L.elem[j-1];
    }
    L.elem[i-1]=e;
    L.length++;
    return true;
}

已知一个顺序表L，其中的元素递增序列排列，设计一个算法，插入一个元素x（x为int型）后保持该顺序表仍递增有序排列，假设插入操作肯定成功，插入成功后返回插入元素所在的位置。

int Insert_Sq(SqList &L,int x)
{
    int i;
    for(i=0; i<L.length; i++)
    {
        if(x<L.elem[i])
            break;
    }
    for(int j=L.length; j>=i+1; j--)
        L.elem[j]=L.elem[j-1];
    L.elem[i]=x;
    L.length++;
    return i;
}

删除顺序表L中第i个元素的位置，若i的输入不合法，则返回false；否则被删元素赋给引用变量e，并将第i+1个元素及其后的所有元素依次往前移动一个位置，返回true。

bool Delete_Sq(SqList &L,int i,int &e)
{
    if(i>L.length||i<1)
        return false;
    e=L.elem[i-1];
    for(int j=i-1;j<L.length;j++)
        L.elem[j]=L.elem[j+1];
        L.length--;
    return true;
}

从顺序表中删除具有最小值的元素并由函数返回被删元素的值，（假设顺序表中数据元素全为正值且最小值为一）。

int Delete_Sq(SqList &L)
{
    int min0=L.elem[0],pos=0;
    for(int i=0;i<L.length;i++)
    {
        if(min0>L.elem[i])
        {
            min0=L.elem[i];
            pos=i;
            break;
        }
    }
    for(int i=pos;i<L.length;i++)
        L.elem[i]=L.elem[i+1];
    L.length--;
    return min0;
}

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

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

void Delete_Sq(SqList &L,int x)
{
    int k=0;
    for(int i=0;i<L.length;i++)
    {
        if(L.elem[i]==x)
            k++;
        else
            L.elem[i-k]=L.elem[i];
    }
    L.length-=k;
}

从顺序表中删除其值在给定值s与t之间（包含s和t，要求s<t）的所有元素，若s或t不合理或顺序表为空，则返回false，若执行成功则返回true。

bool Delete_Sq(SqList &L,int s,int t)
{
   if(L.length==0||s>=t)
    return false;
   int j=0;
   for(int i=0;i<L.length;i++)
   {
       if(L.elem[i]<s||L.elem[i]>t)
       {
           L.elem[j]=L.elem[i];
           j++;
       }
   }
   L.length=j;
   return true;
}

bool Delete_Sq(SqList &L,int s,int t)
{
   if(L.length==0||s>=t)
    return false;
   int k=0;
   for(int i=0;i<L.length;i++)
   {
       if(L.elem[i]>=s&&L.elem[i]<=t)
        k++;
        else
        L.elem[i-k]=L.elem[i];
   }
   L.length-=k;
   return true;
}

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

void Delete_Sq(SqList &L)
{
   int k=1;
   for(int i=1;i<L.length;i++)
   {
       if(L.elem[i]!=L.elem[i-1])
       {
           L.elem[k]=L.elem[i];
           k++;
       }
   }
   L.length=k;
}

从有序顺序表中删除其值在给定值s与t之间（包含s和t，要求s<t）的所有元素，若s或t不合理或顺序表为空，则返回false，执行成功则返回true。

bool Delete_Sq(SqList &L,int s,int t)
{
   if(s>=t||L.length==0)
    return false;
   int i,j;
   for(j=0,i=0;j<L.length&&L.elem[i]<s;i++,j++);
   if(j==L.length)
    return false;
   for(;L.elem[i]<=t;i++);
   for(;i<L.length;i++)
   {
       L.elem[j]=L.elem[i];
       j++;
   }
   L.length=j;
   return true;
}

将两个有序顺序表A和B合并为一个新的有序顺序表C，若合并成功则返回true，合并失败则返回false。

bool Merge(SqList A,SqList B,SqList &C)
{
    int i=0,j=0,k=0;
    while(i<A.length&&j<B.length)
    {
        if(A.elem[i]<B.elem[j])
        {
            C.elem[k]=A.elem[i];
            k++;
            i++;
        }
        else
        {
            C.elem[k]=B.elem[j];
            k++;
            j++;
        }
    }
    while(i<A.length)
    {
        C.elem[k]=A.elem[i];
        k++;
        i++;
    }
    while(j<B.length)
    {
        C.elem[k]=B.elem[j];
        k++;
        j++;
    }
    C.length=k;
    return true;
}