c语言实现顺序表及其相关操作

#c语言实现顺序表及其相关操作
1．实验目的：
（1）熟练掌握VC或Dev C++集成环境和程序开发步骤；
（2）熟练掌握顺序表的插入、删除、查找定位等基本算法；
（3）能利用顺序表解决简单的问题。

2．实验原理：
1定义：采用一块连续的储存单元，（数组）来储存线性表中的数据元素。从前往后依次存放，线性表的数据元素在数组中。
2描述：
一
（1）struct list用来定义线性表的顺序储存方式。
（2） struct list L,L为一个线性表的名称，L由两个成员组成。
（3）Elem[]数组，用来存放线性表中的数据元素。
（4）Length用来表示线性表的实际长度。
二
采用顺序储存的线性表称为顺序表
三
顺序表中的逻辑顺序与储存顺序（物理次序）是一致的。
struct list
{
Elemtype elem[MAXSIZE];
Int length;
};
struct list L;
Typedef struct list Sqlist;
Struct list L;
L=(Sqlist)malloc(sizeof(Sqlist));
3.算法（略）
4.顺序表的特点
（1）采用一块连续的储存单元存放元素
（2） 逻辑关系（次序）与储存（物理）关系（次序）一致
（3）可以随机存取
（4） 优点:存储密度高，查找方便
（5） 插入，删除，需要挪动元素，效率低，浪费存储空间。（开辟容量>实际使用容量）
（6）顺序储存结构是为整个线性表建立的储存方式

3．实验内容：
已知一顺序表l中的存储的数据元素的类型为整型。
顺序表中元素的值为（年份，月份，日，专业代码，班级代码，学号末两位）
（1）定义一个算法，初始化顺序表。
（2）定义一个算法，建立顺序表，即把数据输入顺序表。
（3）定义一个算法，遍历顺序表。
（4）定义一个算法，顺序表的插入操作，在顺序表中第5个元素前插入一个值为23的元素。
（5）定义一个算法，删除顺序表中值为8的元素。
（6）定义一个算法，查找顺序表中值为X的元素的位置，有的话返回其下标，没有返回-1。
（7）定义一个算法，求顺序表中值为X的元素的个数。
（8）定义一个算法，把顺序表（6,0,4,12）链接到原始顺序表的后面。（两个顺序表类型一致）
（以上每种算法调用之后，均要执行顺序表的遍历操作。）

代码如下（示例）：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define TRUE 1

#define MAXSIZE 20     /*初始分配的顺序表长度*/
typedef  int ElemType;  /*定义表元素的类型*/
typedef struct {
    ElemType elem[MAXSIZE];  /*存储空间的基地址，即存储线性表中元素的存储空间及大小*/
    int length;           /*顺序表的当前长度*/
}SeqList;

int Init_SeqList(SeqList* L); /*初始化顺序表*/
int Create_SeqList(SeqList* L, int n); /*创建顺序表*/
int Insert_SeqList(SeqList* L, int i, ElemType x);/*顺序表的插入操作*/
int Traverse_SeqList(SeqList* L);  /*顺序表的遍历*/
int Delete1_SeqList(SeqList* L, int i); /*顺序表的按序号删除操作*/
int Delete2_SeqList(SeqList* L, ElemType x); /*顺序表的按数据删除操作*/
int Find_SeqList(SeqList* L, ElemType x); /*查找值为x的元素*/

int Init_SeqList(SeqList* L) {
    L->length=0; 		/*空表长度为0 */
    return TRUE;
}/*InitList*/

int Create_SeqList(SeqList* L, int n) {
    ElemType x;
    int i;
    for (i = 0;i<n ; i++) {/*创建顺序表*/
        printf("Please Input data %d： ", i+1);
        scanf("%d", &L->elem[i]);
        L->length++;
        if (i>MAXSIZE-1)
            return ERROR;
    }
    return TRUE;
}/*CreateList*/

/*输出顺序表中的元素*/
int Traverse_SeqList(SeqList* L) {
    int i;
    for (i = 0; i < L->length; i++)
        printf("%-7d", L->elem[i]);
    printf("%\n\n");
    return TRUE;
}/*TraverseList*/
/*在顺序表L中，序号i的位置上插入值为x的元素*/
int Insert_SeqList(SeqList* L, int i, ElemType x) {
    int j;
    if (i<1 || i>MAXSIZE)//i不在顺序表的范围内
        return ERROR;
    if (L->length == MAXSIZE)//顺序表已满
        return ERROR;
    for (j = L->length-1; j>=i-1;j--) {//插入--从后往前循环
        L->elem[j+1]=L->elem[j];
    }
    L->elem[i-1]=x;
    L->length++;
    return TRUE;
}/*ListInsert*/

/*在顺序表中删除第i个元素*/
int Delete1_SeqList(SeqList* L, int i) {
    int j;
    if (i<1 || i>MAXSIZE)
        return ERROR;
    for (j = i; j<=L->length-1; j++)//从前往后一个一个往前挤--从前往后挤
        L->elem[j-1]=L->elem[j];
    L->length--;
    return TRUE;
}

/*在顺序表中按照数据删除对象，即删除值为x的元素*/
int Delete2_SeqList(SeqList* L, ElemType x) {
    int i, j;
    for (i = 0; i<=L->length-1; i++)/*查找数据x的位置*/
        if (L->elem[i]==x)
            break;
    if (i==L->length)/*s顺序表中没有值为x的对象*/
        return ERROR;
    for (j = i+1; j<=L->length-1; j++)/*删除值为x的对象*/
        L->elem[j-1]=L->elem[j];
    L->length--;
    return TRUE;
}/*Delete2*/

/*在顺序表中查找指定值元素，返回其序号，若没有返回ERROR*/
int Find_SeqList(SeqList* L, ElemType x) {
    int i = 0;
    for (i = 0; i < L->length - 1; i++)
    {
        if (L->elem[i] == x)
            break;
    }
    if (i == L->length)
        return  ERROR;
    else return i+1;
   
}/*Find*/

/*顺序表链接，把表s2连接在s1的后面，失败返回0*/
int Cat_SeqList(SeqList* L1, SeqList* L2)
{
    int i;
    if (L1->length+L2->length>MAXSIZE)/*溢出，无法连接*/
        return ERROR;
    for (i=0; i<=L2->length-1; i++)
        L1->elem[L1->length+i]=L2->elem[i];
    L1->length = L1->length + L2->length;//更新L1中length的值
    return TRUE;

}/*Cat*/

int main() {
    struct list* s1, * s2;
    int n, m, k;
    char c;

    printf("**************************************************\n");
    printf("               顺 序 表 常 用 算 法\n");
    printf("**************************************************\n\n");

    s1 = (SeqList*)malloc(sizeof(SeqList));	/*建立顺序表sl，为sl开辟存储空间*/
    s2 = (SeqList*)malloc(sizeof(SeqList));	/*建立顺序表sl，为s2开辟存储空间*/

    printf("1、初始化线性表:设置表长为0\n");
    if (Init_SeqList(s1))  printf("顺序表初始化成功……\n\n");

    printf("2、创建顺序表：\n");
    do {
        printf("请输入顺序表长度（n>=0）：");
        scanf("%d", &n);   /*输入顺序表的元素个数*/
    } while (n < 0);
    if (Create_SeqList(s1, n)) printf("顺序表创建成功……\n\n"); ;

    printf("3、遍历顺序表：\n");  /*依次访问顺序表中所有元素*/
    Traverse_SeqList(s1);

    printf("4、顺序表的插入操作：\n");
    printf("请输入待插入的位序：");
    scanf("%d", &m);
    printf("请输入待插入的数据：");
    scanf("%d", &k);
    if (Insert_SeqList(s1, m, k)) printf("插入操作执行成功……\n操作结果：");
    Traverse_SeqList(s1);

    printf("5、请输入删除方式，1表示按内容删除，2表示按序号删除\n");
    scanf("%d", &m);
    if (m == 2)
    {
        printf("您是选择按照序号删除对象，请输入带删除元素的序号：");
        scanf("%d", &k);
        if (Delete1_SeqList(s1, k))
            printf("删除第%d号元素成功……\n操作结果", k);
        else
            printf("删除失败！");
        printf("操作结果是：");
        Traverse_SeqList(s1);
    }

    else if (m == 1)
    {
        printf("您是选择按照内容删除对象，请输入待删除元素的数据的值：");
        scanf("%d", &m);
        if (Delete2_SeqList(s1, m))
            printf("删除元素%d的值成功……\n操作结果:", m);
        else
            printf("删除失败！\n");
        Traverse_SeqList(s1);
    }
    else
        printf("输入错误！\n");


    printf("6、请输入待查找元素值：");
    scanf("%d", &m);
    if (Find_SeqList(s1, m) != ERROR)
        printf("查找成功，值为 %d 的元素序号为 %d\n", m, Find_SeqList(s1, m));
    else
        printf("查找失败！顺序表中没有值为%d的元素。\n", m);


    printf("7、创建顺序表s2：\n");
    if (Init_SeqList(s2))printf("初始化表s2成功！\n");
    printf("请输入顺序表s2长度（n>=0）：");
    scanf("%d", &n);   //输入顺序表s2的元素个数

    if (Create_SeqList(s2, n)) printf("顺序表s2创建成功……\n\n"); ;

    printf("8、顺序表的连接操作：\n");
    if (Cat_SeqList(s1, s2))  printf("顺序表链接操作成功……\n操作结果:");
    Traverse_SeqList(s1);

    return 0;
}

6.运行结果
7.总结（注意事项）。
（1）本文中的序号均指的是正常使用的序号（从1开始）而不是以数组的下标（从0开始）
（避免和error（0）重复，导致造成歧义，出现错误结果）
（2）插入，删除，连接等操作成功之后不能忘记更新length数值
（3）进行插入，删除，连接等操作时需要留心，避免数组越界
for (j = i; j<=L->length-1; j++)//注意j的下标
L->elem[j-1]=L->elem[j];
（4）插入–从后往前挪动–循环从后往前–起始（L->length-1）
for (j = L->length-1; j>=i-1;j–)
L->elem[j+1]=L->elem[j];
（5）删除–从前向后挪动–循环从前往后–起始（i）
for (j = i; j<=L->length-1; j++)
L->elem[j-1]=L->elem[j];