C 顺序表

表的结构

#define MAXSIZE 20 // 最大支持的数据量
#define listData uint32_t // 数据类型

typedef struct list_t {
    listData data[MAXSIZE]; // 数组存储数据元素
    uint32_t length; // 表当前的长度
} list_t;

常用方法

• list_init：初始化，建立一个空表
• list_empty：判断当前表是否为空
• list_clear：清空当前表
• list_get：获取当前表中的某一个数据
• list_find：在当前表中查找符合要求的某一个数据的位置
• list_insert：插入一个数据
• list_delete：删除一个数据
• list_merge：合并2个表，移除重复数据
• list_length：表长
• list_display：打印表数据

实现代码

list.h

#ifndef __LIST_H__
#define __LIST_H__

#include <stdint.h>
#include <stdbool.h>

#define OK 0x0000
#define ERROR 0xFFFF

#define MAXSIZE 20
#define listData uint32_t

typedef struct list_t {
    listData data[MAXSIZE];
    uint32_t length;
} list_t;

void list_init(list_t* p_list);
bool list_empty(list_t* p_list);
void list_clear(list_t* p_list);
uint32_t list_get(list_t* p_list, uint32_t index, listData* data);
int32_t list_find(list_t* p_list, listData data);
uint32_t list_insert(list_t* p_list, uint32_t index, listData data);
uint32_t list_delete(list_t* p_list, uint32_t index);
uint32_t list_merge(list_t* p_list, list_t* p_list_2);
uint32_t list_length(list_t* p_list);
void list_display(list_t* p_list);

#endif // __LIST_H__

list.c

#include "list.h"

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

/* 获取当前的数组下标 */
static int32_t get_current_valid_index(list_t* p_list) {
    return (p_list->length - 1);
}

/* 检查是否有重复的元素 */
static bool check_duplicates(list_t* p_list, uint32_t length, listData data) {
    for (uint32_t i = 0; i < length; i++) {
        if (memcmp(&data, &p_list->data[i], sizeof(listData)) == 0) {
            return true;
        }
    }
    return false;
}

void list_init(list_t* p_list) {
    p_list->length = 0;
}

bool list_empty(list_t* p_list) {
    if (p_list->length == 0) {
        return true;
    }
    return false;
}

void list_clear(list_t* p_list) {
    p_list->length = 0;
}

uint32_t list_get(list_t* p_list, uint32_t index, listData* data) {
    if (list_empty(p_list) || index > get_current_valid_index(p_list)) {
        return ERROR;
    }

    memcpy(data, &p_list->data[index], sizeof(listData));
    return OK;
}

int32_t list_find(list_t* p_list, listData data) {
    if (list_empty(p_list)) {
        return -1;
    }

    for (uint32_t i = 0; i < p_list->length; i++) {
        if (memcmp(&data, &p_list->data[i], sizeof(listData)) == 0) {
            return i;
        }
    }
    return -1;
}

uint32_t list_insert(list_t* p_list, uint32_t index, listData data) {
    if (index >= MAXSIZE || p_list->length >= MAXSIZE) {
        return ERROR;
    }

    if (check_duplicates(p_list, p_list->length, data)) {
        return ERROR;
    }

    if (index == p_list->length) {
        memcpy(&p_list->data[index], &data, sizeof(listData));
    } else if (index > p_list->length) {
        memcpy(&p_list->data[p_list->length], &data, sizeof(listData));
    } else {
        for (uint32_t i = p_list->length; i > index; i--) {
            memcpy(&p_list->data[i], &p_list->data[i - 1], sizeof(listData));
        }
        memcpy(&p_list->data[index], &data, sizeof(listData));
    }

    p_list->length++;
    return OK;
}

uint32_t list_delete(list_t* p_list, uint32_t index) {
    if (list_empty(p_list) || index > get_current_valid_index(p_list)) {
        return ERROR;
    }

    if (index < get_current_valid_index(p_list)) {
        for (uint32_t i = index; i < p_list->length; i++) {
             memcpy(&p_list->data[i], &p_list->data[i + 1], sizeof(listData));
        }
    }

    p_list->length--;
    return OK;
}

uint32_t list_merge(list_t* p_list, list_t* p_list_2) {
    if (list_empty(p_list_2)) {
        return ERROR;
    }

    uint32_t length = p_list->length;
    for (uint32_t i = 0; i < p_list_2->length; i++) {
        if (!check_duplicates(p_list, length, p_list_2->data[i])) {
            list_insert(p_list, p_list->length, p_list_2->data[i]);
        }
    }

    return OK;
}

uint32_t list_length(list_t* p_list) {
    return p_list->length;
}

void list_display(list_t* p_list) {
    printf("\n==========list_display begin===========\n");
    for (uint32_t i = 0; i < p_list->length; i++) {
        printf("list[%d].data = %d\n", i, p_list->data[i]);
    }
    printf("==========list_display end===========\n\n");
}

测试代码 main.c

#include <stdio.h>

#include "list.h"

int main(int argc, char const *argv[])
{
    list_t list;
    list_init(&list);

    /* 顺序插入 */
    list_insert(&list, 0, 0);
    list_insert(&list, 1, 1);
    list_insert(&list, 2, 2);
    list_display(&list); // 0、1、2

    /* 中间插入 */
    list_insert(&list, 1, 99);
    list_display(&list); // 0、99、1、2

    /* 尾部插入重复数据，无法插入 */
    list_insert(&list, 3, 99);
    list_display(&list); // 0、99、1、2

    /* 获取第2位的数据，计数为Index = 0/1/2... */
    listData value;
    uint32_t ret = list_get(&list, 2, &value);
    printf("ret: %d, value: %d\n", ret, value); // 0, 1

    /* 查找数据3是否存在 */
    int32_t index = list_find(&list, 3);
    printf("find 3, index = %d\n", index); // -1，不存在
    index = list_find(&list, 1);
    printf("find 1, index = %d\n", index); // 2，存在

    /* 删除数据 */
    list_delete(&list, 1);
    list_display(&list); // 0、1、2

    /* 合并表 */
    list_t list2;
    list_init(&list2);

    list_insert(&list2, 0, 10);
    list_insert(&list2, 1, 2);
    list_insert(&list2, 2, 13);
    list_insert(&list2, 3, 14);
    list_display(&list2); // 0、2、3、4

    list_merge(&list, &list2);
    list_display(&list); // 0、1、2、10、13、14

	return 0;
}