数据结构 —— 第一个程序 【顺序表】

//操作的开始***********************************
//操作的进行
//操作的结束***********************************
#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAX 1000
#define MAXM 10
#define OK 1
#define OVERFLOW -1
#define ERROR -2
#define ListAdd 10//顺序表扩容
#define ListInitsize 20//顺序表初始化尺寸
using namespace std;
typedef int Status;
typedef int ElemType;
typedef struct
{
    ElemType *elem;
    ElemType length;
    ElemType listsize;
}SqList;
SqList La, Lb, Lc;
void Sort(SqList &L)//冒泡排序
{
    for(int i = 0; i < L.length; i++)
        for(int j = 0; j < i; j++)
            if(L.elem[i] < L.elem[j])
            {
                int t = L.elem[i];
                L.elem[i] = L.elem[j];
                L.elem[j] = t;
            }
}
void Listinput(SqList &L)
{
    printf("*******************************************************************************\n");
    L.elem = (ElemType *)malloc(ListInitsize * sizeof(ElemType));
    if(!L.elem) exit(OVERFLOW);
    L.length = 0;
    L.listsize = ListInitsize;
    printf("\t\t\t\t输入元素个数\n");
    printf("\t\t\t\t");
    int n; scanf("%d", &n);
    printf("\t\t\t\t输入元素\n");
    printf("\t\t\t\t");
    for(int i = 0; i < n; i++)
        scanf("%d", &L.elem[i]);
    L.length = n;
    Sort(L);
    printf("*******************************************************************************\n");
}
void ListClear(SqList &L){
    printf("*******************************************************************************\n");
    L.length = 0;
    printf("*******************************************************************************\n");
}
void ListQuery(SqList &L)
{
    printf("*******************************************************************************\n");
    printf("\t\t\t\t输入要查询元素的位置\n");
    printf("\t\t\t\t");
    int op; scanf("%d", &op);
    if(op < 1 || op > L.length)//判断位置是否合法
    {
        printf("\t\t\t\t查询位置不合法\n");
        printf("*******************************************************************************\n");
    }
    else
    {
        printf("\t\t\t\t%d\n", L.elem[op-1]);
        printf("*******************************************************************************\n");
    }
}
void ListDelete(SqList &L)
{
    printf("*******************************************************************************\n");
    printf("\t\t\t\t输入要删除元素的位置\n");
    printf("\t\t\t\t");
    int op; scanf("%d", &op);
    if(op < 1 || op > L.length)//判断位置是否合法
    {
        printf("\t\t\t\t删除位置不合法\n");
        printf("*******************************************************************************\n");
    }
    int *p, *q;
    q = &(L.elem[L.length-1]);
    p = &(L.elem[op-1]);
    int x = *p;//存储删除的元素
    for(; p <= q; p++)
        *p = *(p+1);
    --L.length;
    printf("*******************************************************************************\n");
}
void ListInsert(SqList &L)
{
    printf("*******************************************************************************\n");
    printf("\t\t\t\t输入要插入元素的位置\n");
    printf("\t\t\t\t");
    int op; scanf("%d", &op);
    if(op < 1 || op > L.length+1)//判断位置是否合法
    {
        printf("\t\t\t\t插入位置不合法\n");
        printf("*******************************************************************************\n");
    }
    //扩容操作
    int *newbase;
    if (L.length >= L.listsize)
    {
        newbase = (ElemType *)realloc(L.elem, (L.listsize+ListAdd)*sizeof(ElemType));
        if(!newbase) exit(OVERFLOW); // 存储分配失败
        L.elem = newbase;         // 新基址
        L.listsize += ListAdd; // 增加存储容量
    }
    printf("\t\t\t\t输入要插入的元素\n");
    printf("\t\t\t\t");
    int x; scanf("%d", &x);
    int *p, *q;
    q = &(L.elem[op-1]);
    for(p = &(L.elem[L.length-1]); p >= q; p--)
        *(p+1) = *p;
    *q = x;
    ++L.length;
    printf("*******************************************************************************\n");
}
void ListMerge(SqList &La, SqList &Lb, SqList &Lc)
{
    printf("*******************************************************************************\n");
    printf("\t\t\t\t要合并的顺序表\n");
    printf("\t\t\t\t顺序表a和顺序表b合并成顺序表c\n");
    int *pa, *pb, *pc;
    pa = La.elem;  pb = Lb.elem;
    Lc.listsize = Lc.length = La.length+Lb.length;  //Lc的长度赋值
    pc = Lc.elem = (ElemType *)malloc(Lc.listsize*sizeof(ElemType));
    if(!Lc.elem)  exit(OVERFLOW); //分配空间
    int *pa_last = La.elem + La.length - 1; //记录La最后元素存放地址
    int *pb_last = Lb.elem + Lb.length - 1; //记录Lb最后元素存放地址
    while(pa <= pa_last && pb <= pb_last)
    {
        if(*pa <= *pb)
            *pc++ = *pa++;
        else
            *pc++ = *pb++;
    }
    while(pa <= pa_last) *pc++ = *pa++;
    while(pb <= pb_last) *pc++ = *pb++;
    printf("*******************************************************************************\n");
}
void ListPrintf(SqList &L)
{
    printf("*******************************************************************************\n");
    printf("\t\t\t\t元素如下:\n");
    if(L.length == 0)
    {
        printf("\t\t\t\t顺序表为空\n");
        printf("*******************************************************************************\n");
    }
    int *p, *q;
    p = &(L.elem[0]);
    q = &(L.elem[L.length-1]);
    printf("\t\t\t\t");
    for(; p <= q; p++)
        printf("%d ", *p);
    printf("\n");
    printf("*******************************************************************************\n");
}
void Read_How_To_Use()
{
	printf("****************************使用前请您阅读——使用指南**************************\n");
	printf("***********************函数Listinput() —— 输入顺序表元素**********************\n");
	printf("***********************函数ListQuery() —— 查询顺序表元素**********************\n");
	printf("***********************函数ListDelete() —— 删除顺序表元素*********************\n");
	printf("***********************函数ListInsert() —— 插入顺序表元素*********************\n");
	printf("***********************函数ListClear() —— 清空顺序表元素**********************\n");
	printf("***********************函数ListPrintf() —— 输出顺序表元素*********************\n");
	printf("***********************函数ListMerge() —— 合并两个顺序表**********************\n");
	printf("*********************************返回上一步请输入0****************************\n");
}
void Chooseoperator(int kind, int op)
{
    int C;
    switch(op)
    {
        case 1:
                printf("\n\n\n");
                printf("\t\t\t\t请选择操作:\n");
                printf("\t\t\t\t1: 使用说明\n");
                printf("\t\t\t\t2: 开始使用\n");
                printf("\t\t\t\t3: 退出系统\n");
                printf("\t\t\t\t您的选择:");
                scanf("%d", &C);
                while(C < 1 || C > 3)
                {
                    printf("\t\t\t\t输入不合法，请重新输入\n");
                    printf("\t\t\t\t");
                    scanf("%d", &C);
                }
                switch(C)
                {
                    case 1: system("cls"); Read_How_To_Use();
                            printf("\t\t\t\t您的选择:");
                            scanf("%d", &C);
                            while(C != 0)
                            {
                                printf("\t\t\t\t");
                                printf("输入不合法，请重新输入\n");
                                printf("\t\t\t\t您的选择:");
                                scanf("%d", &C);
                            }Chooseoperator(1, 1); break;
                    case 2: system("cls"); Chooseoperator(1, 2); break;
                    case 3: printf("\t\t\t\t谢谢使用！\n"); exit(0);
                }
                break;

        case 2:
                printf("\n\n\n");
                printf("\t\t\t\t对链表进行操作，请选择:\n");
                printf("\t\t\t\t1: 顺序表a\n");
                printf("\t\t\t\t2: 顺序表b\n");
                printf("\t\t\t\t3: 顺序表c\n");
                printf("\t\t\t\t4: 把顺序表a和顺序表b合并成顺序表c\n");
                printf("\t\t\t\t5: 回退上一步\n");
                printf("\t\t\t\t您的选择:");
                scanf("%d", &C);
                while(C < 1 || C > 5)
                {
                    printf("\t\t\t\t输入不合法，请重新输入\n");
                    printf("\t\t\t\t您的选择:");
                    scanf("%d", &C);
                }
                if(C == 5)
                {
                    Chooseoperator(1, 1);
                    break;
                }
                system("cls");
                Chooseoperator(C, 3);
                break;

        case 3:
                printf("\n\n\n");
                printf("\t\t\t\t选择操作:\n");
                printf("\t\t\t\t1: 输入元素\n");
                printf("\t\t\t\t2: 查询元素\n");
                printf("\t\t\t\t3: 删除元素\n");
                printf("\t\t\t\t4: 插入元素\n");
                printf("\t\t\t\t5: 清空顺序表\n");
                printf("\t\t\t\t6: 输出顺序表\n");
                printf("\t\t\t\t7: 合并顺序表\n");
                printf("\t\t\t\t8: 回退上一步\n");
                printf("\t\t\t\t您的选择:");
                scanf("%d", &C);
                while(C < 1 || C > 8)
                {
                    printf("\t\t\t\t输入不合法，请重新输入\n");
                    printf("\t\t\t\t您的选择:");
                    scanf("%d", &C);
                }
                switch(C)
                {
                    case 1: system("cls");
                            switch(kind)
                            {
                                case 1: Listinput(La); break;
                                case 2: Listinput(Lb); break;
                                case 3: Listinput(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 2: system("cls");
                            switch(kind)
                            {
                                case 1: ListQuery(La); break;
                                case 2: ListQuery(Lb); break;
                                case 3: ListQuery(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 3: system("cls");
                            switch(kind)
                            {
                                case 1: ListDelete(La); break;
                                case 2: ListDelete(Lb); break;
                                case 3: ListDelete(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 4: system("cls");
                            switch(kind)
                            {
                                case 1: ListInsert(La); break;
                                case 2: ListInsert(Lb); break;
                                case 3: ListInsert(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 5: system("cls");
                            switch(kind)
                            {
                                case 1: ListClear(La); break;
                                case 2: ListClear(Lb); break;
                                case 3: ListClear(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 6: system("cls");
                            switch(kind)
                            {
                                case 1: ListPrintf(La); break;
                                case 2: ListPrintf(Lb); break;
                                case 3: ListPrintf(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 7: system("cls"); ListMerge(La, Lb, Lc); Chooseoperator(1, 2); break;
                    case 8: system("cls"); Chooseoperator(1, 2);
                }
    }
}
int main()
{
    printf("*******************************您好，欢迎使用本系统*****************************\n\n");
    Chooseoperator(1, 1);
	return 0;
}