数据结构 | 顺序表实现

————————————————————————————————————————————

顺序表

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

概念图

模块设计：伪代码写的非常差劲- -见谅

//初始化顺序表（InitList）

使用malloc函数申请一个指定大小100*4字节的地址并将首地址赋值给L的结构体成员elem

if 指针为NULL

函数溢出，退出执行

为结构体成员listsize赋值列表大小100

为结构体成员length赋值元素长度0

返回值(1)

//建立表（Build）

定义整型 i 循环使用

定义整型 n 存储元素个数

if 元素个数超过了列表大小

使用realloc函数对L的结构体成员elem指向的地址空间大小调整为 n+10

if 指针为NULL

函数溢出，退出执行

为结构体成员listsize赋值列表大小 n+10

for i<-0 to n

将输入的数据元素存入第 i 位

为结构体成员length赋值元素长度 n

return OK

//打印表的元素（Print）

定义 int i作为辅助指针时使用

for i++ 0~length

打印顺序表中的元素

打印顺序表中元素的长度

//删除值为X的元素（ListDelete1）

传入顺序表L与需要删除的值X

定义辅助 i

for 遍历顺序表中的元素

if 指针的值等于X

跳出循环

if i等于length（for循环后未找到X）

return ERROR；

i++（执行这一步之前 i 指向X的位置）

for 遍历顺序表

i 位置的值覆盖 i-1 位置的值

长度减一

返回OK；

//删除第X位的元素（ListDelete2）

传入顺序表与位置X-1

定义辅助 i

if 位置在0~length-1之外

return ERROR；

i = x+1（执行这一步之前，x指向需要删除的位置）

for 遍历顺序表

i 的位置覆盖掉 i-1的位置

长度减一

return OK

//逆置函数（Inverse）

定义辅助 i 和 temp

for i 遍历函数的 1/2

首尾交换

//冒泡排序（Sort）

定义辅助 i，j，temp

for i 遍历0~length

for j 遍历 0~length - i

if 第j个大于第j+1个

两数值交换

//插入x，使依然有序（ListInsert）

定义辅助 i,k

if 现在length>=listsize

L->elem重新修改顺序表的长度为原listsize+10

if L->elem等于NULL

exit OVERFLOW

listsize表大小在原来基础上+10

for i 遍历顺序表

if L->elem+i的值>x

跳出循环

k 暂存 i 的值

for i从length向前遍历，直到>k

数据元素向后挪一位

对k位的值赋x

长度加一

return OK

//合并两个线性表（Merger）

main函数中调用InitList和Build新建第二张线性表Lb

将两张线性表传入Merger方法中

定义int i,j,k辅助

定义新顺序表Lc

调用InitList方法初始化Lc

if Lc的顺序表大小<A的长度+B的长度

修改Lc的长度为 A.length+B.length+10

if 指针为NULL

exit溢出

列表大小置为A.length+B.length+10

i,j,k置为0

while i小于A.length且j小于B.length

if 指向L的i的值小于指向Lb的j的值

指向Lc的k的值 = 指向L的i的值

k指向下一个

i指向下一个

else

指向Lc的k的值 = 指向Lb的j的值

k指向下一个

j指向下一个

while i<length //此时默认j超过了length范围

指向Lc的k的值 = 指向L的i的值

k指向下一个

i指向下一个

while j<length

指向Lc的k的值 = 指向Lb的j的值

k指向下一个

j指向下一个

Lc的长度 = L的长度 + Lb的长度

将Lc的值赋给L

return OK

代码实现：

 

#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int status ;
typedef int ElemType ;
typedef struct//结构体定义SqList:其中含有int *elem指针,int length长度,int listsize列表大小
{
    ElemType *elem;
    int length, listsize;
} SqList;
status InitList(SqList *L)//初始化L
{
    L->elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));//L的指针申请长度为100个4字节int空间
    if(!L->elem) exit(OVERFLOW);//如果分配不成功则返回溢出
    L->listsize = LIST_INIT_SIZE;//定义L->listsize==100
    L->length = 0;//L的初始长度为0
    return OK;
}
status Build(SqList *L)//建立表,传入的是L的地址
{
    int i, n;
    printf("Please enter the number of elements n:
");
    scanf("%d", &n); //输入元素个数n
    if(n > LIST_INIT_SIZE)
    {
        //如果元素个数大于n,则使用realloc对malloc申请的内存进行大小的调整,调整为n+10
        L->elem = (ElemType *)realloc(L->elem, (n + LISTINCREMENT) * sizeof(ElemType));
        if(!L->elem) exit(OVERFLOW);
        L->listsize = n + LISTINCREMENT; //列表的大小置为n+10
    }
    for(i = 0; i < n; i++)
        scanf("%d", L->elem + i); //循环输入n个元素
    L->length = n; //长度置为n
    return OK;
}
void Print(SqList *L) //输出表中元素和长度
{
    int i;
    for(i = 0; i < L->length; i++)
        printf("%d ", *(L->elem + i));
    printf("
length is:%d

", L->length);
}
void Tips()//提示函数
{
    printf("<1> Output sequence table
");//输出顺序表及顺序表的长度
    printf("<2> Delete a node with a value of X 
");//删除值为x的结点
    printf("<3> Delete node to locate I 
");//删除给定位置i的结点
    printf("<4> Reverse the order table 
");//将顺序表逆置
    printf("<5> Sort sequential tables in ascending order 
");//将顺序表按升序排序
    printf("<6> Insert x into the appropriate position of the sequence table 
");//将x插入到顺序表的适当位置上
    printf("<7> Merge two ordered tables 
");//将两个有序表合并
    printf("<0> exit

");//退出
}
status ListDelete1(SqList *L, int x) //删除值为X的元素
{
    int i;
    for(i = 0; i < L->length; i++)
        if(*(L->elem + i) == x)
            break;
    if(i == L->length)
        return ERROR;
    for(i++; i < L->length; i++)
        *(L->elem + i - 1) = *(L->elem + i);
    L->length--;
    return OK;
}
status ListDelete2(SqList *L, int x) //删除第X个元素
{
    int i;
    if(x < 0 || x >= L->length)
        return ERROR;
    for(i = x + 1; i < L->length; i++)
        *(L->elem + i - 1) = *(L->elem + i);
    L->length--;
    return OK;
}
void Inverse(SqList *L)//逆置函数
{
    int i, t;
    for(i = 0; i < L->length / 2; i++)
    {
        t = *(L->elem + i);
        *(L->elem + i) = *(L->elem + L->length - i - 1);
        *(L->elem + L->length - i - 1) = t;
    }
}
void Sort(SqList *L)//冒泡排序（升序）
{
    int i, j, t;
    for(i = 1; i < L->length; i++)
        for(j = 0; j < L->length - i; j++)
        {
            if(*(L->elem + j) > *(L->elem + j + 1))
            {
                t = *(L->elem + j);
                *(L->elem + j) = *(L->elem + j + 1);
                *(L->elem + j + 1) = t;
            }
        }
    printf("Arranged in ascending order 

");//已按升序排列
}
status ListInsert(SqList *L, int x) //将X插入，使仍然有序
{
    int i, k;
    if(L->length >= L->listsize)
    {
        L->elem = (ElemType *)realloc(L->elem, (L->listsize + LISTINCREMENT) * sizeof(ElemType));
        if(!L->elem) exit(OVERFLOW);
        L->listsize += LISTINCREMENT;
    }
    for(i = 0; i < L->length; i++)
        if(x < * (L->elem + i))
            break;
    k = i;
    for(i = L->length; i > k; i--)
        *(L->elem + i) = *(L->elem + i - 1);
    *(L->elem + k) = x;
    L->length++;
    return OK;
}
status Merger(SqList *L, SqList *Lb) //合并两个线性表
{
    int i, j, k;
    SqList Lc;
    InitList(&Lc);
    if(Lc.listsize < L->length + Lb->length)
    {
        Lc.elem = (ElemType *)realloc(Lc.elem, (L->length + Lb->length + LISTINCREMENT) * sizeof(ElemType));
        if(!L->elem) exit(OVERFLOW);
        Lc.listsize = L->length + Lb->length + LISTINCREMENT;
    }
    i = j = k = 0;
    while(i < L->length && j < Lb->length)
    {
        if(*(L->elem + i) < * (Lb->elem + j))
        {
            *(Lc.elem + k) = *(L->elem + i);
            k++;
            i++;
        }
        else
        {
            *(Lc.elem + k) = *(Lb->elem + j);
            k++;
            j++;
        }
    }
    while(i < L->length)
    {
        *(Lc.elem + k) = *(L->elem + i);
        k++;
        i++;
    }
    while(j < Lb->length)
    {
        *(Lc.elem + k) = *(Lb->elem + j);
        k++;
        j++;
    }
    Lc.length = L->length + Lb->length;
    *L = Lc;
    return OK;
}
int main()
{
    int op, x, flag;
    SqList L, Lb; //定义SqList类型的两个结构L和Lb
    InitList(&L);
    Build(&L);
    Tips();
    scanf("%d", &op);
    while(op)
    {
        switch(op)
        {
        case 1:
            Print(&L);
            break;
        case 2:
            printf("Please enter the data you want to delete X :
");
            scanf("%d", &x);
            flag = ListDelete1(&L, x);
            if(flag)
                printf("success!!

");
            else
                printf("Element does not exist, delete failed !!

");
            break;
        case 3:
            printf("Please enter the location you want to delete I :
");//请输入要删除的位置i
            scanf("%d", &x);
            flag = ListDelete2(&L, x - 1); //第i个元素对应的下标为i-1
            if(flag)
                printf("success!!

");
            else
                printf("Element does not exist, delete failed !!

");//元素不存在,删除失败
            break;
        case 4:
            Inverse(&L);
            break;
        case 5:
            Sort(&L);
            break;
        case 6:
            printf("Please enter the data you want to insert X :
");//请输入要插入的数据X
            scanf("%d", &x);
            flag = ListInsert(&L, x);
            if(flag)
                printf("success!!

");//插入成功
            else
                printf("fail!!

");//插入失败
            break;
        case 7:
            printf("Please enter the contents of Lb :
");//请输入Lb内容
            InitList(&Lb);
            Build(&Lb);
            flag = Merger(&L, &Lb);
            if(flag)
                printf("success!!

");//合并成功
            break;
        }
        Tips();
        scanf("%d", &op);
    }
    return 0;
}