线性表练习

#include <stdio.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int ElemType;
typedef int Status;
typedef struct {
    ElemType *elem;

    int length;

    int listsize;

} SqList;
void InitList_Sq(SqList *pL);
Status ListInsert_Sq(SqList *pL, int i, ElemType e);
Status ListDelete_Sq(SqList *pL, int i, ElemType *pe);
Status GetElem_Sq(SqList L, int i, ElemType *pe);
void Converse_Sq(SqList *L);
void PrintAll(SqList L);
void DestroyList_Sq(SqList L);

int main(void) 
{
    int rc, i;
    char ch;
    ElemType e;
    SqList L;
    InitList_Sq(&L);
    while (1) {
        i = e = 0;
        printf("\n=======SqList=========");
        printf("\n 1--Insert an Element.");
        printf("\n 2--Delete an Element.");
        printf("\n 3--Get an Element.");
        printf("\n 4--Print All. ");
        printf("\n 5--Converse. ");
        printf("\n 6--Exit. ");
        printf("\n\nPlease Choose:");
        scanf(" %c", &ch);
        switch (ch) {
            case '1':
                printf("\n**Insert**");
                printf("\n输入元素插入位置i:");
                scanf("%d", &i);
                fflush(stdin);
                printf("输入待插入的元素e:");
                scanf("%d", &e);
                fflush(stdin); // 清空输入缓冲区
                rc = ListInsert_Sq(&L, i, e);
                if (rc != OK)
                    printf("\ni invalid");
                else
                    printf("\ni=%d,e=%d Inserted\n", i, e);
                break;
            case '2':
                printf("\n**Delete**");
                printf("\n输入待删除元素的位置i:");
                scanf("%d", &i);
                fflush(stdin);
                rc = ListDelete_Sq(&L, i, &e);
                if (rc != OK)
                    printf("\ni invalid");
                else
                    printf("\ni=%d,e=%d Deleted\n", i, e);
                break;
            case '3':
                printf("\n**Get**");
                printf("\n输入待获取元素位置i:");
                scanf("%d", &i);
                fflush(stdin);
                rc = GetElem_Sq(L, i, &e);
                if (rc != OK)
                    printf("\ni invalid");
                else
                    printf("\ni=%d,e=%d\n", i, e);
                break;
            case '4':
                printf("\n**PrintAll**");
                PrintAll(L);
                break;
            case '5':
                Converse_Sq(&L);
                break;
            case '6':
                DestroyList_Sq(L);
                exit(0);
            default:
                printf("\nInvalid Choice");
        }
    }
}

// 初始化顺序表
void InitList_Sq(SqList *pL) {
    pL->elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if (!pL->elem)
        exit(1); // 存储分配失败
    pL->length = 0; // 空表长度为0
    pL->listsize = LIST_INIT_SIZE; // 初始存储容量
}

 

// 在顺序表第i个位置插入元素e
Status ListInsert_Sq(SqList *pL, int i, ElemType e) {
    ElemType *p, *q, *newbase;
    if (i < 1 || i > pL->length + 1) // i值不合法
        return ERROR;
    if (pL->length >= pL->listsize) { // 当前存储空间已满，增加分配
        newbase = (ElemType *)realloc(pL->elem, (pL->listsize + LISTINCREMENT) * sizeof(ElemType));
        if (!newbase)
            exit(1); // 存储分配失败
        pL->elem = newbase;
        pL->listsize += LISTINCREMENT;
    }
    q = &(pL->elem[i - 1]); // q为插入位置
    for (p = &(pL->elem[pL->length - 1]); p >= q; --p)
        *(p + 1) = *p; // 插入位置及之后的元素右移
    *q = e; // 插入e
    ++pL->length; // 表长增1
    return OK;
}

// 删除顺序表第i个元素，并用pe返回
Status ListDelete_Sq(SqList *pL, int i, ElemType *pe) {
    ElemType *p, *q;
    if (i < 1 || i > pL->length) // i值不合法
        return ERROR;
    p = &(pL->elem[i - 1]); // p为被删除元素的位置
    *pe = *p; // 被删除元素的值赋给*pe
    q = pL->elem + pL->length - 1; // 表尾元素的位置
    for (++p; p <= q; ++p)
        *(p - 1) = *p; // 被删除元素之后的元素左移
    --pL->length; // 表长减1
    return OK;
}

 

// 获取顺序表第i个元素，并用pe返回
Status GetElem_Sq(SqList L, int i, ElemType *pe) {
    if (i < 1 || i > L.length) // i值不合法
        return ERROR;
    *pe = L.elem[i - 1];
    return OK;
}

 

// 实现顺序表的就地逆置，仍利用原表的存储空间。
void Converse_Sq(SqList *L) {
    int i;
    ElemType temp;
    for (i = 0; i < L->length / 2; ++i) {
        temp = L->elem[i];
        L->elem[i] = L->elem[L->length - 1 - i];
        L->elem[L->length - 1 - i] = temp;
    }
}

 

// 打印输出顺序表所有元素

void PrintAll(SqList L) {
    int i;
    for (i = 0; i < L.length; ++i) {
        printf("%d ", L.elem[i]);
    }
    printf("\n");
}

 

// 销毁顺序表
void DestroyList_Sq(SqList L) {
    if (L.elem)
        free(L.elem);
    L.elem = NULL;
    L.length = 0;
    L.listsize = 0;
}

编写一个程序依次实现如下功能：

（1）在第i个元素之前插入一个元素e

（2）删除位序为i的元素，并将删除的节点的值由变量e返回；

（3）由变量e获取位序为i的元素的值；

（4）输出此表；

（5）退出程序时销毁此表。