【数据结构】动态顺序表

1. Makefile

.PHONY: clean

CC = gcc
CFLAGS = -g -Wall -DDEBUG

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

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

clean:
	rm -rf $(BIN)

2. dynamic_seq_list.h

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

#ifndef __DYNAMIC_SEQ_LIST_H__
#define __DYNAMIC_SEQ_LIST_H__

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

#ifdef __cplusplus
extern "C" {
#endif

#define DEFAULT_CAPACITY 3
#define DOUBLE 2

typedef int dynamic_seq_list_data_t;
typedef struct {
    dynamic_seq_list_data_t *data;
    int size;
    int capacity;
} dynamic_seq_list_t;

int get_dynamic_seq_list_size(const dynamic_seq_list_t *dynamic_seq_list);

int get_dynamic_seq_list_capacity(const dynamic_seq_list_t *dynamic_seq_list);

bool is_dynamic_seq_list_empty(const dynamic_seq_list_t *dynamic_seq_list);

void print_dynamic_seq_list(const dynamic_seq_list_t *dynamic_seq_list);

void dynamic_seq_list_init(dynamic_seq_list_t *dynamic_seq_list);

void push_front_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list,
                                 dynamic_seq_list_data_t data);

void push_back_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list,
                                dynamic_seq_list_data_t data);

void insert_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list,
                             int pos,
                             dynamic_seq_list_data_t data);

void pop_front_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list);

void pop_back_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list);

void erase_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list, int pos);

void remove_dynamic_seq_list_by_data(dynamic_seq_list_t *dynamic_seq_list,
                                     dynamic_seq_list_data_t data);

void remove_dynamic_seq_list_by_all_data(dynamic_seq_list_t *dynamic_seq_list,
                                         dynamic_seq_list_data_t data);

void clear_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list);

void destroy_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list);

#ifdef __cplusplus
}
#endif

#endif // __DYNAMIC_SEQ_LIST_H__

3. dynamic_seq_list.c

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

#include "dynamic_seq_list.h"

int get_dynamic_seq_list_size(const dynamic_seq_list_t *dynamic_seq_list)
{
    int dynamic_seq_list_size = 0;

    if (NULL != dynamic_seq_list) {
        dynamic_seq_list_size = dynamic_seq_list->size;
    }

    return dynamic_seq_list_size;
}

int get_dynamic_seq_list_capacity(const dynamic_seq_list_t *dynamic_seq_list)
{
    int dynamic_seq_list_capacity = 0;

    if (NULL != dynamic_seq_list) {
        dynamic_seq_list_capacity = dynamic_seq_list->capacity;
    }

    return dynamic_seq_list_capacity;
}

bool is_dynamic_seq_list_empty(const dynamic_seq_list_t *dynamic_seq_list)
{
    return 0 == get_dynamic_seq_list_size(dynamic_seq_list);
}

void print_dynamic_seq_list(const dynamic_seq_list_t *dynamic_seq_list)
{
    int i = 0, size = get_dynamic_seq_list_size(dynamic_seq_list);
    for (; i < size; ++i) {
        if (dynamic_seq_list->data) {
            printf("[%-3d]", dynamic_seq_list->data[i]);
        }
    }

    printf("\n");
}

void dynamic_seq_list_init(dynamic_seq_list_t *dynamic_seq_list)
{
    dynamic_seq_list->size = 0;
    dynamic_seq_list->capacity = DEFAULT_CAPACITY;
    dynamic_seq_list->data = (dynamic_seq_list_data_t *)calloc(
            dynamic_seq_list->capacity, sizeof(dynamic_seq_list_data_t));
    if (NULL == dynamic_seq_list->data) {
        perror("calloc dynamic_seq_list->data fail");
        exit(EXIT_FAILURE);
    }
}

static void check_capacity(dynamic_seq_list_t *dynamic_seq_list)
{
    int capacity = get_dynamic_seq_list_capacity(dynamic_seq_list);

    if (get_dynamic_seq_list_size(dynamic_seq_list) == capacity) {
        int new_capacity = capacity * DOUBLE;
        dynamic_seq_list_data_t *new_data = (dynamic_seq_list_data_t *)realloc(
                dynamic_seq_list->data, sizeof(dynamic_seq_list_data_t) * new_capacity);
        if (NULL == new_data) {
            perror("realloc new_data fail");
            exit(EXIT_FAILURE);
        } else {
            dynamic_seq_list->data = new_data;
            new_data = NULL;
        }

        dynamic_seq_list->capacity = new_capacity;
    }

    printf("do not expansion\n");
}

void push_front_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list,
                                 dynamic_seq_list_data_t data)
{
    check_capacity(dynamic_seq_list);

    int i = 0, size = get_dynamic_seq_list_size(dynamic_seq_list);
    for (i = size - 1; i >= 0; --i) {
        dynamic_seq_list->data[i + 1] = dynamic_seq_list->data[i];
    }

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

void push_back_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list,
                                dynamic_seq_list_data_t data)
{
    check_capacity(dynamic_seq_list);

    dynamic_seq_list->data[get_dynamic_seq_list_size(dynamic_seq_list)] = data;
    ++dynamic_seq_list->size;
}

void insert_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list,
                             int pos,
                             dynamic_seq_list_data_t data)
{
    check_capacity(dynamic_seq_list);

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

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

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

void pop_front_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list)
{
    if (is_dynamic_seq_list_empty(dynamic_seq_list)) {
        return;
    }

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

    --dynamic_seq_list->size;
}

void pop_back_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list)
{
    if (is_dynamic_seq_list_empty(dynamic_seq_list)) {
        return;
    }

    --dynamic_seq_list->size;
}

void erase_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list, int pos)
{
    if (is_dynamic_seq_list_empty(dynamic_seq_list)) {
        return;
    }

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

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

    --dynamic_seq_list->size;
}

static int find_dynamic_seq_list_by_data(const dynamic_seq_list_t *dynamic_seq_list,
                                         dynamic_seq_list_data_t data)
{
    int i = 0, size = get_dynamic_seq_list_size(dynamic_seq_list);
    for (; i < size; ++i) {
        if (data == dynamic_seq_list->data[i]) {
            return i;
        }
    }

    return -1;
}

void remove_dynamic_seq_list_by_data(dynamic_seq_list_t *dynamic_seq_list,
                                     dynamic_seq_list_data_t data)
{
    if (is_dynamic_seq_list_empty(dynamic_seq_list)) {
        return;
    }

    int pos = find_dynamic_seq_list_by_data(dynamic_seq_list, data);
    if (-1 != pos) {
        erase_dynamic_seq_list(dynamic_seq_list, pos);
    }
}

void remove_dynamic_seq_list_by_all_data(dynamic_seq_list_t *dynamic_seq_list,
                                         dynamic_seq_list_data_t data)
{
    int i = 0, size = get_dynamic_seq_list_size(dynamic_seq_list);
    for (; i < size; ++i) {
        remove_dynamic_seq_list_by_data(dynamic_seq_list, data);
    }
}

void clear_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list)
{
    if (NULL == dynamic_seq_list) {
        return;
    }

    dynamic_seq_list->size = 0;
    memset(dynamic_seq_list->data, 0x0, dynamic_seq_list->capacity);
    dynamic_seq_list->capacity = 0;
}

void destroy_dynamic_seq_list(dynamic_seq_list_t *dynamic_seq_list)
{
    clear_dynamic_seq_list(dynamic_seq_list);
    free(dynamic_seq_list->data);
    dynamic_seq_list->data = NULL;
}

4. test_dynamic_seq_list.c

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

#include "dynamic_seq_list.h"

void test()
{
    dynamic_seq_list_t dynamic_seq_list;
    printf("init dynamic_seq_list\n");
    dynamic_seq_list_init(&dynamic_seq_list);
    printf("dynamic seq list size: %d\n", get_dynamic_seq_list_size(&dynamic_seq_list));
    printf("dynamic seq list capacity: %d\n", get_dynamic_seq_list_capacity(&dynamic_seq_list));
    if (is_dynamic_seq_list_empty(&dynamic_seq_list)) {
        printf("dynamic_seq_list is empty\n");
    } else {
        printf("dynamic_seq_list is not empty\n");
    }
    print_dynamic_seq_list(&dynamic_seq_list);

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

    push_back_dynamic_seq_list(&dynamic_seq_list, 4);
    push_back_dynamic_seq_list(&dynamic_seq_list, 5);
    push_back_dynamic_seq_list(&dynamic_seq_list, 4);

    insert_dynamic_seq_list(&dynamic_seq_list, 2, 6);

    printf("dynamic seq list size: %d\n", get_dynamic_seq_list_size(&dynamic_seq_list));
    printf("dynamic seq list capacity: %d\n", get_dynamic_seq_list_capacity(&dynamic_seq_list));
    if (is_dynamic_seq_list_empty(&dynamic_seq_list)) {
        printf("dynamic_seq_list is empty\n");
    } else {
        printf("dynamic_seq_list is not empty\n");
    }
    print_dynamic_seq_list(&dynamic_seq_list);

    /* Delete data */
    printf("delete data\n");
    printf("pop_front_dynamic_seq_list\n");
    pop_front_dynamic_seq_list(&dynamic_seq_list);
    print_dynamic_seq_list(&dynamic_seq_list);
    printf("pop_back_dynamic_seq_list\n");
    pop_back_dynamic_seq_list(&dynamic_seq_list);
    print_dynamic_seq_list(&dynamic_seq_list);
    printf("erase_dynamic_seq_list, pos = 2\n");
    erase_dynamic_seq_list(&dynamic_seq_list, 2);
    print_dynamic_seq_list(&dynamic_seq_list);

    printf("remove_dynamic_seq_list_by_data, data = 6\n");
    remove_dynamic_seq_list_by_data(&dynamic_seq_list, 6);
    print_dynamic_seq_list(&dynamic_seq_list);
    printf("remove_dynamic_seq_list_by_all_data, data = 4\n");
    remove_dynamic_seq_list_by_all_data(&dynamic_seq_list, 4);
    print_dynamic_seq_list(&dynamic_seq_list);

    printf("clear_dynamic_seq_list\n");
    clear_dynamic_seq_list(&dynamic_seq_list);
    printf("dynamic seq list size: %d\n", get_dynamic_seq_list_size(&dynamic_seq_list));
    printf("dynamic seq list capacity: %d\n", get_dynamic_seq_list_capacity(&dynamic_seq_list));
    if (is_dynamic_seq_list_empty(&dynamic_seq_list)) {
        printf("dynamic_seq_list is empty\n");
    } else {
        printf("dynamic_seq_list is not empty\n");
    }
    print_dynamic_seq_list(&dynamic_seq_list);

    printf("destroy_dynamic_seq_list\n");
    destroy_dynamic_seq_list(&dynamic_seq_list);
    printf("dynamic seq list size: %d\n", get_dynamic_seq_list_size(&dynamic_seq_list));
    printf("dynamic seq list capacity: %d\n", get_dynamic_seq_list_capacity(&dynamic_seq_list));
    if (is_dynamic_seq_list_empty(&dynamic_seq_list)) {
        printf("dynamic_seq_list is empty\n");
    } else {
        printf("dynamic_seq_list is not empty\n");
    }
    print_dynamic_seq_list(&dynamic_seq_list);
}

int main(void)
{
    test();

    return 0;
}