将顺序表进行逆置，线性表的交换，线性表删除最大元素值

这里接着上次发布的进行顺序表除了一些简单的基本操作就是要会解决一些问题了。

1. 将元素进行逆置。

//元素进行逆置
void reverse(Sqlist L)
{
    for(int i =0;i < L.length/2;i++)
    {
        int t = L.data[i];
        L.data[i] = L.data[L.length-i-1];
        L.data[L.length-i-1]=t;        
    }
 } 

2. 删除从i=1开始的k个元素

bool deletek(Sqlist &L,int i,int k)
{
    if(i<0||k<1||i+k>L.length||i+k<1)
    {
        return false;
    }
    for(int j = i+k-1;j<L.length;j++)
    {
        L.data[j-k] = L.data[j];//向前移动 
    }
    L.length = L.length-k;
    return true; 
 } 

3.

有一个非空整数顺序表L，其中元素值可以重复出现，设计一个算法，在最后一个

最大值元素之后插入一个值为x的元素。

void insertelem(Sqlist &L,int x)//在在最后一个最大值的后端插入
{
    int maxelem = L.data[0];
    int m;//为下标 
    for(int i = 0;i < L.length;i++)
    {
        if(L.data[i]>=maxelem)
        {
            maxelem = L.data[i];
            m = i;//最大值的下标 
        }
    }
    for(int j =L.length-1;j>=m;j--)
    {
        L.data[j+1]=L.data[j];
    }
    L.data[m+1] = x;
    L.length++;
 } 

3. 线性表的交换

void swap1(Sqlist &L)
{
    int pivot = L.data[0];//以第一个为标准
    //一个从前往后 一个从后往前
    int i = 1;
    int j = L.length-1;//最后一个元素 
    while(i<j) 
    {
        while(i<j&&L.data[i]<=pivot)//i找大于基准的 
        {
            i++;
        }
        while(i<j&&L.data[j]>pivot)
        {
            j--;
        }
        if(i<j)//进行交换 
        {
            int t = L.data[i];
            L.data[i] = L.data[j];
            L.data[j] = t;
        }
    } 
    
    //将其插入即可
    if(L.data[j]>pivot)
{
    int tmp = L.data[0];
    L.data[0] = L.data[j-1];
    L.data[j-1] = tmp; 
}
else
{
    int tmp = L.data[0];
    L.data[0] = L.data[j];
    L.data[j] = tmp;
}

}

4. 删除最大元素值

void deletemax(Sqlist& L)
{
    //先找到最大值
    int maxelem = L.data[0];
    for(int i = 0;i < L.length;i++)
    {
        if(L.data[i]>=maxelem)
        {
            maxelem = L.data[i];
        }
     } 
     
     //进行删除
     int k = 0;
     for(int i = 0;i < L.length;i++)
     {
         if(L.data[i]!=maxelem)
         {
             L.data[k] = L.data[i];
             k++;
         }
      } 
      L.length = k;
 } 

5. 判断是否递增

//判断是否递增
bool isfun(Sqlist &L)
{
    int flag;
    for(int i =0;i < L.length-1;i++)//这里有坑，因为后面有data[i+1]所以i+1是有范围的 
    {
        flag = 1;
        if(L.data[i]>L.data[i+1])
        {
            flag = 0;
            break;
        }
    }
    if(flag == 1)
    {
        return true;
    }
    else if(flag==0)
    {
        return false;
    }
 } 

6. 两个单调递增的顺序表合并为一个单调递增的表

bool merge(Sqlist& L1,Sqlist &L2,Sqlist &L3)
{
    if(L1.length+L2.length>maxsize)
    {
        return false;
     } 
    int i = 0;
    int j = 0;
    int k = 0;
    while(i<L1.length&&j<L2.length)
    {
        if(L1.data[i]<L2.data[j])
        {
            L3.data[k]=L1.data[i];
            i++;
            k++;
        }
        else
        {
            L3.data[k]=L2.data[j];
            j++;
            k++;
        }
    }
    while(i<L1.length)//有剩余 ,得用循环才能吧所有都放进去 
    {
        L3.data[k]=L1.data[i];
        i++;
        k++;
    }
    while(j<L2.length)
    {
        L3.data[k]=L2.data[j];
        j++;
        k++;
    }
    L3.length=k;
    return true;
} 

顺序表的相关就到这里啦！！