动态顺序表_WD课后习题2_2_1、2、3

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

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

#define InitSize 100
typedef int ElemType;

typedef struct
{
    ElemType *data;
    int MaxSize, length;
} SeqList;

// 初始化顺序表
void InitList(SeqList &L)
{
    L.data = (ElenType *)malloc(InitSize * sizeof(int));
    L.MaxSize = InitSize;
    L.length = 0;
}

// 给顺序表存值
void stodValue(SeqList &L, int length)
{
    printf("Please Input:\n");
    for (int i = 0; i < length; i++)
    {
        scanf("%d", L.data + i);
    }
    L.length = length;
}

// 输出展示顺序表
void showList(SeqList &L)
{
    for (int i = 0; i < L.length; i++)
    {
        printf("%d  ", L.data[i]);
    }
    printf("\n");
}

// 删除具有最小值的元素,空出的位置由最后一个元素填补
bool deleteList(SeqList &L, int &ele)
{
    if (L.length == 0)
        return false;
    int min = L.data[0];
    int flag = 0;
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] < min)
        {
            min = L.data[i];
            flag = i;
        }
    }
    ele = L.data[flag];
    L.data[flag] = L.data[L.length - 1];

    return true;
}

int main()
{
    int k = 0;
    SeqList L;

    InitList(L);
    stodValue(L, 6);
    showList(L);
    printf("原来顺序表为：\n");
    deleteList(L, k);
    printf("最小值:k=%d\n", k);
    showList(L);
    printf("删除完填补后为：\n");

    return 0;
}

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

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

#define InitSize 100
typedef int ElemType;
typedef struct
{
    /* data */
    ElemType *data;
    int length, MaxSize;
} SeqList;

// 初始化顺序表
void InitList(SeqList &L)
{
    L.data = (ElemType *)malloc((InitSize) * sizeof(int));
    L.MaxSize = InitSize;
    L.length = 0;
}

// 给顺序表存值
void stodValue(SeqList &L, int length)
{
    printf("Please Input:\n");
    for (int i = 0; i < length; i++)
    {
        scanf("%d", L.data + i);
    }
    L.length = length;
}

// 输出展示顺序表
void showList(SeqList L)
{
    for (int i = 0; i < L.length; i++)
    {
        printf("%d  ", L.data[i]);
    }
    printf("\n");
}

// 方法一：直接逆置
/*void inversion(SeqList &L)
{
    int temp;
    for (int i = 0, j = L.length - 1; i < j; i++, j--)
    {
        temp = L.data[i];
        L.data[i] = L.data[j];
        L.data[j] = temp;
    }
} */

// 方法二：折半逆置
void inversion(SeqList &L)
{
    int temp;
    for (int i = 0; i < L.length / 2; i++)
    {
        temp = L.data[i];
        L.data[i] = L.data[L.length - i - 1]; // 注意这里的i，非常重要
        L.data[L.length - i - 1] = temp;
    }
}

int main()
{
    SeqList L;

    InitList(L);
    stodValue(L, 6);
    printf("逆置之前为：\n");
    showList(L);
    inversion(L);
    printf("逆置之后为：\n");
    showList(L);

    return 0;
}

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

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

#define InitSize 100
typedef int ElemType;
typedef struct
{
    /* data */
    ElemType *data;
    int length, MaxSize;
} SeqList;

// 初始化顺序表
void InitList(SeqList &L)
{
    L.data = (ElemType *)malloc((InitSize) * sizeof(int));
    L.MaxSize = InitSize;
    L.length = 0;
}

// 给顺序表存值
void stodValue(SeqList &L, int length)
{
    printf("Please Input:\n");
    for (int i = 0; i < length; i++)
    {
        scanf("%d", L.data + i);
    }
    L.length = length;
}

// 输出展示顺序表
void showList(SeqList L)
{
    for (int i = 0; i < L.length; i++)
    {
        printf("%d  ", L.data[i]);
    }
    printf("\n");
}

// 删除值为x的值
// 方法一：用顺序表最后一个元素替补，重新判断
/* void delete_x(SeqList &L, int x)
{
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] == x)
        {
            L.data[i] = L.data[L.length - 1];
            L.length--;
            i--; // 重新判断
        }
    }
} */

// 方法二：用k记录不为x的数据元素
/* void delete_x(SeqList &L, int x)
{
    int k = 0; // k：不为x的数据元素
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] != x)
        {
            L.data[k] = L.data[i];
            k++;
        }
    }
    L.length = k;
} */

// 方法三：用k记录为x的数据元素
void delete_x(SeqList &L, int x)
{
    int k = 0;
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] == x)
            k++;
        else
            L.data[i - k] = L.data[i];
        }
    L.length = L.length - k;
}

int main()
{
    SeqList L;

    InitList(L);
    stodValue(L, 6);
    showList(L);

    delete_x(L, 2);
    showList(L);

    return 0;
}