本文共 3570 字，大约阅读时间需要 11 分钟。

顺序表操作实现与应用

本篇将记录顺序表的增删改查操作实现及其应用。通过代码和实际运行结果，展示如何实现顺序表的基本操作，并探讨其应用场景。

顺序表的概念

顺序表是一种线性数据结构，数据存储在连续的存储单元中，支持高效的增删改查操作。常见的顺序表操作包括：

• 增：在顺序表头、尾或指定位置插入新成员
• 删：从顺序表头、尾或指定位置删除单个或多个成员
• 改：在顺序表头、尾或指定位置修改单个或多个节点的数值
• 查：遍历顺序表，显示所有节点的数值

实现依据

基于C语言实现的顺序表操作代码如下：

#include 
   
    
#include 
    
     
#define SIZE 10
struct list {
    int buf[SIZE];
    int last;
};
struct list* list_init() {
    struct list* mylist = malloc(sizeof(struct list));
    mylist->last = -1;
    return mylist;
}
int addtail(int newdata, struct list* mylist) {
    if (mylist->last >= SIZE - 1) {
        printf("顺序表已满！\n");
        return -1;
    }
    mylist->last++;
    mylist->buf[mylist->last] = newdata;
}
int insert(int olddata, int newdata, struct list* mylist) {
    printf("\n====将%d插入到%d后面====\n", newdata, olddata);
    int m = 0;
    for (int i = 0; i <= mylist->last; i++) {
        if (mylist->buf[i] == olddata) {
            m = 1;
            int n = mylist->last;
            mylist->last++;
            for (int j = 0; j < n - i; j++) {
                mylist->buf[mylist->last - j] = mylist->buf[n - j];
            }
            mylist->buf[i + 1] = newdata;
            if (olddata == newdata) {
                i++;
            }
        }
    }
    if (m == 0) {
        printf("原顺序表没有%d这个成员,插入数据失败!\n", olddata);
    }
}
int delete(int olddata, struct list* mylist) {
    int m = 0;
    for (int i = 0; i <= mylist->last; i++) {
        if (mylist->buf[i] == olddata) {
            m = 1;
            for (int j = i; j < mylist->last; j++) {
                mylist->buf[j] = mylist->buf[j + 1];
            }
            mylist->last--;
            i--;
        }
    }
    printf("\n=====删除成员%d=====\n", olddata);
    if (m == 0) {
        printf("原顺序表没有%d这个成员,删除数据失败!\n", olddata);
    }
}
int change(int olddata, int newdata, struct list* mylist) {
    int m = 0;
    printf("\n成员%d数值改为%d\n", olddata, newdata);
    for (int i = 0; i <= mylist->last; i++) {
        if (mylist->buf[i] == olddata) {
            mylist->buf[i] = newdata;
            m = 1;
        }
    }
    if (m == 0) {
        printf("原顺序表没有%d这个成员,更改数据失败!\n", olddata);
    }
}
int show(struct list* mylist) {
    printf("顺序表各成员数据：\t");
    for (int i = 0; i <= mylist->last; i++) {
        printf("%d\t", mylist->buf[i]);
    }
    printf("\n");
}
int main(int argc, char** argv) {
    struct list* mylist = list_init();
    addtail(1, mylist);
    addtail(3, mylist);
    addtail(5, mylist);
    addtail(6, mylist);
    show(mylist);
    insert(1, 2, mylist);
    show(mylist);
    insert(3, 4, mylist);
    show(mylist);
    insert(6, 7, mylist);
    show(mylist);
    delete(1, mylist);
    show(mylist);
    delete(7, mylist);
    show(mylist);
    delete(4, mylist);
    show(mylist);
    change(2, 8, mylist);
    show(mylist);
    change(5, 8, mylist);
    show(mylist);
    change(6, 8, mylist);
    show(mylist);
    insert(10, 7, mylist);
    show(mylist);
    delete(10, mylist);
    show(mylist);
    change(10, 8, mylist);
    show(mylist);
    return 0;
}
    
   

运行结果

执行上述代码可得到以下输出：

顺序表各成员数据：	1	3	5	6
====将2插入到1后面====
顺序表各成员数据：	1	2	3	5	6
====将4插入到3后面====
顺序表各成员数据：	1	2	3	4	5	6
====将7插入到6后面====
顺序表各成员数据：	1	2	3	4	5	6	7
=====删除成员1=====
顺序表各成员数据：	2	3	4	5	6	7
=====删除成员7=====
顺序表各成员数据：	2	3	4	5	6
=====删除成员4=====
顺序表各成员数据：	2	3	5	6
成员2数值改为8
顺序表各成员数据：	8	3	5	6
成员5数值改为8
顺序表各成员数据：	8	3	8	6
成员6数值改为8
顺序表各成员数据：	8	3	8	8
====将10插入到7后面====
顺序表各成员数据：	8	3	8	8	10
=====删除成员10=====
顺序表各成员数据：	8	3	8	8
成员10数值改为8
顺序表各成员数据：	8	3	8	8

总结

该代码实现了顺序表的增删改查功能，通过实际运行验证了其正确性。代码中使用了数组来模拟顺序表的存储方式，并通过循环实现了基本的数据操作。用户可以根据实际需求对代码进行修改和优化。