【数据结构】静态顺序表

1. Makefile

.PHONY: clean

CC = gcc
CFLAGS = -g -Wall -DDEBUG -std=c99

# match *.c
SOURCE = $(wildcard ./*.c)
# replace * with *.c
BIN = $(patsubst %.c, %, $(notdir $(SOURCE)))

$(BIN): $(SOURCE)
	$(CC) $(CFLAGS) $(SOURCE) -o $@

clean:
	rm -rf $(BIN)

2. static_seq_list.h

/*
* File Name: static_seq_list.h
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#ifndef __STATIC_SEQ_LIST_H__
#define __STATIC_SEQ_LIST_H__

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

#ifdef __cplusplus
extern "C" {
#endif

#define MAX_STATIC_LIST_SIZE 10

typedef int static_seq_list_data_t;
typedef struct {
    static_seq_list_data_t data[MAX_STATIC_LIST_SIZE];
    int size;
} static_seq_list_t;

int get_static_seq_list_size(const static_seq_list_t *static_seq_list);

bool is_static_seq_list_empty(const static_seq_list_t *static_seq_list);

void print_static_seq_list(const static_seq_list_t *static_seq_list);

void static_seq_list_init(static_seq_list_t *static_seq_list);

void push_front_static_seq_list(static_seq_list_t *static_seq_list,
                                static_seq_list_data_t data);

void push_back_static_seq_list(static_seq_list_t *static_seq_list,
                               static_seq_list_data_t data);

void insert_static_seq_list(static_seq_list_t *static_seq_list,
                            int pos,
                            static_seq_list_data_t data);

void pop_front_static_seq_list(static_seq_list_t *static_seq_list);

void pop_back_static_seq_list(static_seq_list_t *static_seq_list);

void erase_static_seq_list(static_seq_list_t *static_seq_list, int pos);

void remove_static_seq_list_by_data(static_seq_list_t *static_seq_list,
                                    static_seq_list_data_t data);

void remove_static_seq_list_by_all_data(static_seq_list_t *static_seq_list,
                                        static_seq_list_data_t data);

void clear_static_seq_list(static_seq_list_t *static_seq_list);

void destroy_static_seq_list(static_seq_list_t *static_seq_list);

#ifdef __cplusplus
}
#endif

#endif // __STATIC_SEQ_LIST_H__

3. static_seq_list.c

/*
* File Name: static_seq_list.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "static_seq_list.h"

int get_static_seq_list_size(const static_seq_list_t *static_seq_list)
{
    int static_seq_list_size = 0;

    if (NULL != static_seq_list) {
        static_seq_list_size = static_seq_list->size;
    }

    return static_seq_list_size;
}

bool is_static_seq_list_empty(const static_seq_list_t *static_seq_list)
{
    return 0 == get_static_seq_list_size(static_seq_list);
}

void print_static_seq_list(const static_seq_list_t *static_seq_list)
{
    int i = 0, size = get_static_seq_list_size(static_seq_list);
    for (; i < size; ++i) {
        printf("[%-3d]", static_seq_list->data[i]);
    }

    printf("\n");
}

void static_seq_list_init(static_seq_list_t *static_seq_list)
{
    if (NULL == static_seq_list) {
        return;
    }

    static_seq_list->size = 0;
    memset(static_seq_list->data,
        0x0, sizeof(static_seq_list_data_t) * MAX_STATIC_LIST_SIZE);
}

void push_front_static_seq_list(static_seq_list_t *static_seq_list,
                                static_seq_list_data_t data)
{
    int i = 0, size = get_static_seq_list_size(static_seq_list);
    if (MAX_STATIC_LIST_SIZE == size) {
        printf("in %s, static_seq_list is full\n", __func__);
        return;
    }

    for (i = size - 1; i >= 0; --i) {
        static_seq_list->data[i + 1] = static_seq_list->data[i];
    }

    static_seq_list->data[0] = data;
    ++static_seq_list->size;
}

void push_back_static_seq_list(static_seq_list_t *static_seq_list,
                               static_seq_list_data_t data)
{
    int size = get_static_seq_list_size(static_seq_list);
    if (MAX_STATIC_LIST_SIZE == size) {
        printf("in %s, static_seq_list is full\n", __func__);
        return;
    }

    static_seq_list->data[size] = data;
    ++static_seq_list->size;
}

void insert_static_seq_list(static_seq_list_t *static_seq_list,
                            int pos,
                            static_seq_list_data_t data)
{
    int i = 0, size = get_static_seq_list_size(static_seq_list);
    if (pos < 0 || pos > size) {
        printf("invaild parameter, pos : %d\n", pos);
        return;
    }

    if (MAX_STATIC_LIST_SIZE == size) {
        printf("in %s, static_seq_list is full\n", __func__);
        return;
    }

    for (i = size - 1; i >= pos; --i) {
        static_seq_list->data[i + 1] = static_seq_list->data[i];
    }

    static_seq_list->data[pos] = data;
    ++static_seq_list->size;
}

void pop_front_static_seq_list(static_seq_list_t *static_seq_list)
{
    if (is_static_seq_list_empty(static_seq_list)) {
        return;
    }

    int i = 0;
    for (; i < static_seq_list->size - 1; ++i) {
        static_seq_list->data[i] = static_seq_list->data[i + 1];
    }

    --static_seq_list->size;
}

void pop_back_static_seq_list(static_seq_list_t *static_seq_list)
{
    if (is_static_seq_list_empty(static_seq_list)) {
        return;
    }

    --static_seq_list->size;
}

void erase_static_seq_list(static_seq_list_t *static_seq_list, int pos)
{
    if (is_static_seq_list_empty(static_seq_list)) {
        return;
    }

    int i = 0, size = get_static_seq_list_size(static_seq_list);
    if (pos < 0 || pos > size) {
        printf("invaild parameter, pos : %d\n", pos);
        return;
    }

    for (i = pos; i < size - 1; ++i) {
        static_seq_list->data[i] = static_seq_list->data[i + 1];
    }

    --static_seq_list->size;
}

static int find_static_seq_list_by_data(const static_seq_list_t *static_seq_list,
                                        static_seq_list_data_t data)
{
    int i = 0, size = get_static_seq_list_size(static_seq_list);
    for (; i < size; ++i) {
        if (data == static_seq_list->data[i]) {
            return i;
        }
    }

    return -1;
}

void remove_static_seq_list_by_data(static_seq_list_t *static_seq_list,
                                    static_seq_list_data_t data)
{
    if (is_static_seq_list_empty(static_seq_list)) {
        return;
    }

    int pos = find_static_seq_list_by_data(static_seq_list, data);
    if (-1 != pos) {
        erase_static_seq_list(static_seq_list, pos);
    }
}

void remove_static_seq_list_by_all_data(static_seq_list_t *static_seq_list,
                                        static_seq_list_data_t data)
{
    int i = 0, size = get_static_seq_list_size(static_seq_list);
    for (; i < size; ++i) {
        remove_static_seq_list_by_data(static_seq_list, data);
    }
}

void clear_static_seq_list(static_seq_list_t *static_seq_list)
{
    static_seq_list_init(static_seq_list);
}

void destroy_static_seq_list(static_seq_list_t *static_seq_list)
{
    static_seq_list_init(static_seq_list);
}

4. test_static_seq_list.c

/*
* File Name: test_static_seq_list.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "static_seq_list.h"

void test()
{
    static_seq_list_t static_seq_list;
    printf("init static_seq_list\n");
    static_seq_list_init(&static_seq_list);
    printf("static seq list size: %d\n", get_static_seq_list_size(&static_seq_list));
    if (is_static_seq_list_empty(&static_seq_list)) {
        printf("static_seq_list is empty\n");
    } else {
        printf("static_seq_list is not empty\n");
    }
    print_static_seq_list(&static_seq_list);

    /* Add data */
    printf("add data\n");
    push_front_static_seq_list(&static_seq_list, 1);
    push_front_static_seq_list(&static_seq_list, 4);
    push_front_static_seq_list(&static_seq_list, 2);

    push_back_static_seq_list(&static_seq_list, 4);
    push_back_static_seq_list(&static_seq_list, 5);
    push_back_static_seq_list(&static_seq_list, 4);

    insert_static_seq_list(&static_seq_list, 2, 6);

    printf("static seq list size: %d\n", get_static_seq_list_size(&static_seq_list));
    if (is_static_seq_list_empty(&static_seq_list)) {
        printf("static_seq_list is empty\n");
    } else {
        printf("static_seq_list is not empty\n");
    }
    print_static_seq_list(&static_seq_list);

    /* Delete data */
    printf("delete data\n");
    printf("pop_front_static_seq_list\n");
    pop_front_static_seq_list(&static_seq_list);
    print_static_seq_list(&static_seq_list);
    printf("pop_back_static_seq_list\n");
    pop_back_static_seq_list(&static_seq_list);
    print_static_seq_list(&static_seq_list);
    printf("erase_static_seq_list, pos = 2\n");
    erase_static_seq_list(&static_seq_list, 2);
    print_static_seq_list(&static_seq_list);

    printf("remove_static_seq_list_by_data, data = 6\n");
    remove_static_seq_list_by_data(&static_seq_list, 6);
    print_static_seq_list(&static_seq_list);
    printf("remove_static_seq_list_by_all_data, data = 4\n");
    remove_static_seq_list_by_all_data(&static_seq_list, 4);
    print_static_seq_list(&static_seq_list);

    printf("clear_static_seq_list\n");
    clear_static_seq_list(&static_seq_list);
    printf("static seq list size: %d\n", get_static_seq_list_size(&static_seq_list));
    if (is_static_seq_list_empty(&static_seq_list)) {
        printf("static_seq_list is empty\n");
    } else {
        printf("static_seq_list is not empty\n");
    }
    print_static_seq_list(&static_seq_list);

    printf("destroy_static_seq_list\n");
    destroy_static_seq_list(&static_seq_list);
    printf("static seq list size: %d\n", get_static_seq_list_size(&static_seq_list));
    if (is_static_seq_list_empty(&static_seq_list)) {
        printf("static_seq_list is empty\n");
    } else {
        printf("static_seq_list is not empty\n");
    }
    print_static_seq_list(&static_seq_list);
}

int main(void)
{
    test();

    return 0;
}