数据结构：有关顺序表的九种操作，多文件编程、代码详细

一、概念：

逻辑结构：线性结构

存储结构：顺序存储（顺序表）-- 基础数组实现

缺点：

空间使用不够灵活，需要提前确定数组的大小

插入和删除元素比较麻烦，因为需要批量的移动元素

优点：

按照位置查找元素比较快，因为可以通过数组下标来访问元素

二、操作

1. 创建线性表

2. 插入数据元素（尾插、任意位置插入法）

3. 删除数据元素（尾删法、任意位置删除法）

4. 修改数据元素（根据位置、值修改）

5. 在顺序表中查找元素（按位置查找）

6. 顺序表的排序 -- 排序

7. 清空顺序表

8. 释放顺序表

9. 打印顺序表中的成员----实际用不到，用来学习阶段看现象 

三、代码实现

 3.1  seq_list.h文件：

#ifndef __SEQ_LIST_H__
#define __SEQ_LIST_H__
#include <stdio.h>
#include <stdlib.h>

#define N 7

typedef struct _Student{
    int data;
}stu_t;

typedef struct Student{
    stu_t s[N];
    int count;
}seq_list_t;

//创建顺序表
int create_seq_list(seq_list_t **);
//向顺序表中插入数据 -- 尾插法
int insert_seq_list_by_tail(seq_list_t *my_class, int in_data);
//向顺序表中插入数据 -- 任意位置插入法
int insert_seq_list_by_pos(seq_list_t *my_class, int in_data, int pos);
//按照值修改元素
int update_seq_list_by_data(seq_list_t *my_class,int old_value,int new_value);
//删除数据元素 -- 尾删法
int delete_from_deq_list_by_tail(seq_list_t *my_class);
//删除数据元素 -- 任意位置删除法
int delete_from_deq_list_by_pos(seq_list_t *my_class, int pos);
//清空顺序表
int clean_seq_list(seq_list_t *my_class);
//释放顺序表
int destroy_seq_list(seq_list_t **my_class);
//按照位置在顺序表中查找数据
int search_data_from_seq_list(seq_list_t *my_class, int pos, int *out_data);
//按照位置修改元素
int update_seq_list_by_pos(seq_list_t *my_class, int pos, int new_value);
//顺序表排序
int sort_seq_list(seq_list_t *my_class, int flag);
//打印顺序表中的元素
int print_seq_list(seq_list_t *my_class);

#endif

3.2 seq_list.c文件：

#include "seq_list.h"

//创建顺序表 使用地址传参方式创建 
int create_seq_list(seq_list_t **my_class){
    //入参合理性检查
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    *my_class = (seq_list_t *)malloc(sizeof(seq_list_t));
    if(NULL == *my_class){
        printf("内存分配失败\n");
        return -1;
    }
    (*my_class)->count = 0;
    return 0;
}

//向顺序表中插入数据的函数--尾插法
int insert_seq_list_by_tail(seq_list_t *my_class, int in_data){
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(my_class->count == N){
        printf("表已满，插入失败\n");
        return -1;
    }
    my_class->s[my_class->count].data = in_data; 
    my_class->count++;
    return 0;
}

//向顺序表中插入数据的函数-- 任意位置插入法
int insert_seq_list_by_pos(seq_list_t *my_class, int in_data, int pos){
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(my_class->count == N){
        printf("表已满，插入失败\n");
        return -1;
    }
    //对插入位置的合理性做检查
    if( pos < 0 && pos > my_class->count){
        printf("插入位置不合理，插入失败\n");
        return -1;
    }
    //开始插入
    //先将待插入位置后面的数据依次向后移动一步
    int i = 0;
    for(i = my_class->count-1; i >= pos; i--){
        my_class->s[i+1] = my_class->s[i];
    }
    //将数据插入待插入位置
    my_class->s[pos].data = in_data;
    my_class->count++;
    return 0;
}
//删除数据元素 -- 尾删法
int delete_from_deq_list_by_tail(seq_list_t *my_class){
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(my_class->count == 0){
        printf("表已空，删除失败\n");
        return -1;
    }
    my_class->count--;
    return 0;
}
//删除数据元素 -- 任意位置删除法
int delete_from_deq_list_by_pos(seq_list_t *my_class, int pos){
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(my_class->count == 0){
        printf("表已空，删除失败\n");
        return -1;
    }
    if(0 < pos && pos >= my_class->count){
        printf("删除位置不合理，删除失败\n");
        return -1;
    }
    //执行删除操作
    //从待删除位置开始，后面的元素依次向前移动一步
    int i = 0;
    for(i = pos; i < my_class->count-1; i++){
        my_class->s[i] = my_class->s[i+1];
    }
    my_class->count--;
    return 0;
}
//按照位置修改元素
int update_seq_list_by_pos(seq_list_t *my_class, int pos, int new_value){
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(pos < 0 && pos >= my_class->count){
        printf("输入位置不合理，修改失败\n");
        return -1;
    }
    my_class->s[pos].data = new_value;
    return 0;
}
//按照值修改元素
int update_seq_list_by_data(seq_list_t *my_class,int old_value,int new_value){
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    int i = 0;
    int k = 0; //设标志位判断输入的值old_value是否存在表里 0 存在 1 不存在
    while(i < my_class->count){
        if(my_class->s[i].data == old_value){
            my_class->s[i].data = new_value; 
            //表里存在old_value 将k 置为1 
            k = 1;         
        }
        i++;
    }
    //表里没 old_value这个值 k 的值没有改变
    if(k == 0){
        printf("输入数据不存在, 修改失败\n");
        return -1;
    } 
    return 0;   
}

//按照位置在顺序表中查找数据
int search_data_from_seq_list(seq_list_t *my_class,int pos, int *out_data){
   if(NULL == my_class || NULL == out_data){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(pos < 0 && pos >= my_class->count){
        printf("查找位置不合理，查找失败\n");
        return -1;
    } 
    *out_data = my_class->s[pos].data;
    return 0;
}

//顺序表排序  flag  0  升序   1  降序
int sort_seq_list(seq_list_t *my_class, int flag){
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(my_class->count == 0){
        printf("表为空，排序失败\n");
        return -1;
    }
    int k = 0; //假设有序
    int i = 0;
    int j = 0;
    stu_t temp;
    if(0 == flag){ //升序
        for(i=0; i < my_class->count-1; i++){
            k = 0;
            for(j = 0; j < my_class->count-i-1; j++){
                if(my_class->s[j].data > my_class->s[j+1].data){
                    temp = my_class->s[j];
                    my_class->s[j] = my_class->s[j+1];
                    my_class->s[j+1] = temp;
                    k = 1;
                }
            }
            if(k == 0){
                break;
            }
        }
    }else if(1 == flag){ //降序
        for(i=0; i < my_class->count-1; i++){
            k = 0;
            for(j = 0; j < my_class->count-i-1; j++){
                if(my_class->s[j].data < my_class->s[j+1].data){
                    temp = my_class->s[j];
                    my_class->s[j] = my_class->s[j+1];
                    my_class->s[j+1] = temp;
                    k = 1;
                }
            }
            if(k == 0){
                break;
            }
        }
    }
    return 0;
}

//清空顺序表 
int clean_seq_list(seq_list_t *my_class){
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    my_class->count = 0;
    return 0;
}
//释放顺序表
int destroy_seq_list(seq_list_t **my_class){
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    free(*my_class);
    *my_class = NULL;
    return 0;
}
//打印顺序表中的成员
int print_seq_list(seq_list_t *my_class){
    if(NULL == my_class){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    int i = 0;
    for(i = 0; i < my_class->count; i++){
        printf("%d  ",my_class->s[i].data);
    }
    printf("\n");
    return 0;
}

3.3 main.c文件：

#include "seq_list.h"

int main(){
    seq_list_t *my_class = NULL;
    //创建顺序表
    create_seq_list(&my_class);

    //向顺序表中插入数据 -- 尾插法
    insert_seq_list_by_tail(my_class, 35);
    insert_seq_list_by_tail(my_class, 20);
    insert_seq_list_by_tail(my_class, 13);
    insert_seq_list_by_tail(my_class, 10);
    insert_seq_list_by_tail(my_class, 18);

    //向顺序表中插入数据 -- 任意位置插入法
    insert_seq_list_by_pos(my_class, 8, 3);
    insert_seq_list_by_pos(my_class, 52, 4);
    printf("插入完后顺序表数据为：\n");
    //打印顺序表中的元素
    print_seq_list(my_class);

    // 表此时已经满， 13 不入表里
    insert_seq_list_by_tail(my_class, 13);
   
    //按照值修改元素  12 不存在这个表里
    update_seq_list_by_data(my_class, 12, 520);
    //按照位置修改元素
    update_seq_list_by_pos(my_class, 4, 25);
    printf("按位置修改完后顺序表数据为：\n");
    //打印顺序表中的元素
    print_seq_list(my_class);

    //顺序表排序 升序
    sort_seq_list(my_class, 0);
    printf("按升序排序后顺序表数据为：\n");
    //打印顺序表中的元素
    print_seq_list(my_class);
    
    int sum =0;
    //按照位置在顺序表中查找数据
    search_data_from_seq_list(my_class, 4, &sum);
    printf("查找到的数据sum= %d\n",sum);

    //删除数据元素 -- 任意位置删除法
    delete_from_deq_list_by_pos(my_class, 3);
    printf("任意位置删除后顺序表数据为：\n");
    //打印顺序表中的元素
    print_seq_list(my_class);

    //删除数据元素 -- 尾删法
    delete_from_deq_list_by_tail(my_class);
    printf("尾删后顺序表数据为：\n");
    //打印顺序表中的元素
    print_seq_list(my_class);

    //清空顺序表
    clean_seq_list(my_class);
    //释放顺序表
    destroy_seq_list(&my_class);
    return 0;
}

四、代码运行结果