数据结构中的顺序表

最新推荐文章于 2024-08-16 08:54:14 发布

小齐勇闯天涯

最新推荐文章于 2024-08-16 08:54:14 发布

阅读量185

点赞数 7

文章标签：数据结构

本文链接：https://blog.csdn.net/qq_58356691/article/details/139010220

版权

/ 逻辑结构：线性结构

顺序表/

\ 存储结构：顺序存储

操作

创建顺序表 √

向顺序表中插入元素(尾插) √

向顺序表中插入元素(任意位置插入) √

删除顺序表中的元素(尾删) √

删除顺序表中的元素(任意位置删除) √

修改顺序表中的元素(根据位置修改) √

查找顺序表中的元素(根据位置查找) √

顺序表的排序 √

顺序表的剔重 √

清空顺序表 √

销毁顺序表 √

遍历顺序表中所有元素--实际不需要，只是我们学习阶段看现象用的 √

seq_list.h

#ifndef __SEQ_LIST_H__
#define __SEQ_LIST_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N 10

//顺序表的结构体--数据对象
typedef struct _Seq_list{
    int s[N];   //数据元素的类型可以自己定义 我这里以int为例
                //如果数据元素有多个数据项 也可以自己再定义结构体来表示
    int count;  //用来记录表中已有的数据元素的个数
}list_t;

list_t *create_list_1();
int create_list_2(list_t **my_list);
int insert_list_by_tail(list_t *my_list, int data);
int print_list(list_t *my_list);
int insert_list_by_pos(list_t *my_list, int pos, int data);
int delete_list_by_tail(list_t *my_list);
int delete_list_by_pos(list_t *my_list, int pos);
int modify_list_by_pos(list_t *my_list, int pos, int new_data);
int search_list_by_pos(list_t *my_list, int pos, int *num);
int clean_list(list_t *my_list);
int destroy_list(list_t **my_list);
int sort_list(list_t *my_list);
int tichong(list_t *my_list);

#endif

seq_list.c

#include "seq_list.h"

//创建顺序表--通过返回值实现
list_t *create_list_1(){
    list_t *my_list = (list_t *)malloc(sizeof(list_t));
    if(NULL == my_list){
        printf("内存分配失败\n");
        return NULL;
    }
    //清空
    memset(my_list, 0, sizeof(list_t));
    return my_list;
}

//创建顺序表--使用地址传参来实现
int create_list_2(list_t **my_list){
    //入参的合理性检查
    if(NULL == my_list){
        printf("入参为NULL\n");
        return -1;
    }
    *my_list = (list_t *)malloc(sizeof(list_t));
    if(NULL == *my_list){
        printf("内存分配失败\n");
        return -1;
    }
    //清空
    memset(*my_list, 0, sizeof(list_t));
    return 0;
}

//向顺序表中插入元素(尾插)
int insert_list_by_tail(list_t *my_list, int data){
    if(NULL == my_list){
        printf("入参为NULL\n");
        return -1;
    }
    if(N == my_list->count){
        printf("表已满 插入失败\n");
        return -1;
    }
    my_list->s[my_list->count] = data;
    my_list->count++;
    return 0;
}

//遍历顺序表中所有元素的函数
int print_list(list_t *my_list){
    if(NULL == my_list){
        printf("入参为NULL\n");
        return -1;
    }
    int i = 0;
    for(i = 0; i < my_list->count; i++){
        printf("%d  ", my_list->s[i]);
    }
    printf("\n");
    return 0;
}

//向顺序表中插入元素(任意位置插入)
int insert_list_by_pos(list_t *my_list, int pos, int data){
    if(NULL == my_list){
        printf("入参为NULL\n");
        return -1;
    }
    if(N == my_list->count){
        printf("表已满 插入失败\n");
        return -1;
    }
    //插入位置合理性检查
    if(pos < 0 || pos > my_list->count){
        printf("插入位置不合理 插入失败\n");
        return -1;
    }
    //执行插入操作
    //先把待插入位置后面的数据依次向后移动一步
    int i = 0;
    for(i = my_list->count-1; i >= pos; i--){
        my_list->s[i+1] = my_list->s[i];
    }
    //把新元素插入到pos位
    my_list->s[pos] = data;
    my_list->count++;
    return 0;
}

//删除顺序表中的元素(尾删)
int delete_list_by_tail(list_t *my_list){
    if(NULL == my_list){
        printf("入参为NULL\n");
        return -1;
    }
    if(0 == my_list->count){
        printf("表已空 删除失败\n");
        return -1;
    }
    //尾删只需将count--即可
    my_list->count--;
    return 0;
}

//删除顺序表中的元素(任意位置删)
int delete_list_by_pos(list_t *my_list, int pos){
    if(NULL == my_list){
        printf("入参为NULL\n");
        return -1;
    }
    if(0 == my_list->count){
        printf("表已空 删除失败\n");
        return -1;
    }
    //删除位置合理性检查
    if(pos < 0 || pos >= my_list->count){
        printf("删除位置不合理 删除失败\n");
        return -1;
    }
    //执行删除操作
    int i = 0;
    for(i = pos; i < my_list->count-1; i++){
        my_list->s[i] = my_list->s[i+1];
    }
    my_list->count--;
    return 0;
}

//修改顺序表中的元素(根据位置修改)
int modify_list_by_pos(list_t *my_list, int pos, int new_data){
    if(NULL == my_list){
        printf("入参为NULL\n");
        return -1;
    }
    if(pos < 0 || pos >= my_list->count){
        printf("修改位置不合理 修改失败\n");
        return -1;
    }
    my_list->s[pos] = new_data;
    return 0;
}

//查找顺序表中的元素(根据位置查找)
int search_list_by_pos(list_t *my_list, int pos, int *num){
    if(NULL == my_list || NULL == num){
        printf("入参为NULL\n");
        return -1;
    }
    if(pos < 0 || pos >= my_list->count){
        printf("查找位置不合理 查找失败\n");
        return -1;
    }
    *num = my_list->s[pos];
    return 0;
}

//清空顺序表
int clean_list(list_t *my_list){
    if(NULL == my_list){
        printf("入参为NULL\n");
        return -1;
    }
    my_list->count = 0;
    return 0;
}

//销毁
int destroy_list(list_t **my_list){
    if(NULL == my_list || NULL == *my_list){
        printf("入参为NULL\n");
        return -1;
    }
    free(*my_list);
    *my_list = NULL;
    return 0;
}

//顺序表排序--升序
int sort_list(list_t *my_list){
    if(NULL == my_list){
        printf("入参为NULL\n");
        return -1;
    }
    int i = 0;
    int j = 0;
    int temp = 0;
    for(i = 0; i < my_list->count-1; i++){
        for(j = 0; j < my_list->count-1-i; j++){
            if(my_list->s[j] > my_list->s[j+1]){
                temp = my_list->s[j];
                my_list->s[j] = my_list->s[j+1];
                my_list->s[j+1] = temp;
            }
        }
    }
    printf("排序完成\n");
    return 0;
}

//顺序表剔重
int tichong(list_t *my_list){
    if(NULL == my_list){
        printf("入参为NULL\n");
        return -1;
    }
    int i = 0;
    int j = 0;
    int k = 0;
    for(i = 0; i < my_list->count-1; i++){
        for(j = i+1; j < my_list->count;){
            if(my_list->s[i] == my_list->s[j]){
                //说明找到重复的了
                for(k = j; k < my_list->count-1; k++){
                    my_list->s[k] = my_list->s[k+1];
                }
                my_list->count--;
            }else{
                j++;
            }
        }
    }
    printf("剔重完成\n");
    return 0;
}

main.c

#include "seq_list.h"

int main(int argc, const char *argv[])
{
    list_t *my_list = NULL;
    //my_list = create_list_1();
    create_list_2(&my_list);
    printf("my_list = %p\n", my_list);//非NULL

    //测试尾插
    insert_list_by_tail(my_list, 10);
    insert_list_by_tail(my_list, 20);
    insert_list_by_tail(my_list, 30);
    print_list(my_list);// 10 20 30

    //测试任意位置插入
    insert_list_by_pos(my_list, 4, 40);//不合理
    insert_list_by_pos(my_list, 3, 40);
    insert_list_by_pos(my_list, 1, 50);
    print_list(my_list);// 10 50 20 30 40

    //测试尾删
    delete_list_by_tail(my_list);
    delete_list_by_tail(my_list);
    print_list(my_list);// 10 50 20

    //测试任意位置删除
    delete_list_by_pos(my_list, 3);//不合理
    delete_list_by_pos(my_list, 1);
    print_list(my_list);// 10 20
    

    //测试修改
    modify_list_by_pos(my_list, 2, 100);//不合理
    modify_list_by_pos(my_list, 1, 100);
    print_list(my_list);// 10 100

    //测试查找
    int num = 0;
    search_list_by_pos(my_list, 0, &num);
    printf("num = %d\n", num);//10

    //测试排序
    insert_list_by_tail(my_list, 50);
    insert_list_by_tail(my_list, 70);
    insert_list_by_tail(my_list, 30);
    print_list(my_list);// 10 100 50 70 30
    sort_list(my_list);
    print_list(my_list);// 10 30 50 70 100

    //测试剔重
    insert_list_by_pos(my_list, 1, 10);
    insert_list_by_pos(my_list, 4, 10);
    insert_list_by_pos(my_list, 6, 30);
    insert_list_by_tail(my_list, 100);
    insert_list_by_tail(my_list, 100);
    print_list(my_list);// 10 10 30 50 10 70 30 100 100 100
    tichong(my_list);
    print_list(my_list);// 10 30 50 70 100

    //测试清空
    clean_list(my_list);
    print_list(my_list);// 没有元素了

    //测试销毁
    destroy_list(&my_list);
    printf("my_list = %p\n", my_list);//NULL

    return 0;
}