C语言设计模式-策略模式

#include <stdio.h>

#include <stdlib.h>

typedef signed int int32_t;

void swap(int *a, int *b)

{

    int tmp;

    tmp = *a;

    *a = *b;

    *b = tmp;

}

void print_arr(int arr[], int32_t length)

{

    int32_t i;

    for (i = 0; i < length - 1; i++) {

        printf("%u, ", arr[i]);

    }

    if (length > 0) {

        printf("%u.", arr[i]);

    }

}

void arr_backup(int arr[], int arr_bkp[], int32_t length)

{

    for (int32_t i = 0; i < length; i++) {

        arr_bkp[i] = arr[i];

    }

}

/* C语言实现策略模式

 * 策略是不同排序算法

 */

// 策略接口

typedef struct {

    void (*execute)(int arr[], int32_t length);

} strategy_t;

// 具体策略: 冒泡排序，一轮排序后最右边数最大， 从小到大排序

void bubble_sort(int arr[], int32_t length)

{

    for (int32_t i = 0; i < length; i++) {

        for (int32_t j = 0; j < length - i - 1; j++) {

            if (arr[j] > arr[j + 1]) {

                swap(&arr[j], &arr[j + 1]);

            }

        }

    }

}

// 具体策略： 选择排序， 每一次排序找到最小的数放在最左边，从小到大排序

void select_sort(int arr[], int32_t length)

{

    int32_t index;

    for (int32_t i = 0; i < length; i++) {

        index = i;

        for (int32_t j = i + 1; j < length; j++) {

            if (arr[j] < arr[index]) {

                index = j;

            }

        }

        if (index != i) {

            swap(&arr[index], &arr[i]);

        }

    }

}

// 具体策略： 插入排序, 假设第一个数最小，再看第二个数，如果比前面数小的话，从前面的数找到插入位置

void insert_sort(int arr[], int32_t length)

{

    int32_t j;

    int tmp;

    for (int32_t i = 1; i < length; i++) {

        if (arr[i] < arr[i - 1]) {

            tmp = arr[i];

            // 插入到前面有序数组，如果前面的数比tmp大，依次后移

            for (j = i - 1; j >= 0 && arr[j] > tmp; j--) {

                arr[j + 1] = arr[j];

            }

            arr[j + 1] = tmp;

        }

    }

}

// 上下文

typedef struct {

    strategy_t *strategy;

} context_t;

// 设置策略

void set_strategy(context_t *ctx, strategy_t *strategy)

{

    ctx->strategy = strategy;

}

// 执行策略

void exec_strategy(context_t *ctx, int arr[], int32_t length)

{

    ctx->strategy->execute(arr, length);

}

int main()

{

    int arr[] = {2, 6, 4, 3, 3, 6, 1, 2};

    int arr_bkp[8] = {0};

    arr_backup(arr, arr_bkp, 8);

    // 初始化上下文

    context_t context;

    strategy_t b_sort_strategy = {bubble_sort};

    set_strategy(&context, &b_sort_strategy);

    printf("冒泡排序前:\n");

    print_arr(arr, 8);

    exec_strategy(&context, arr, 8);

    printf("\n冒泡排序后:\n");

    print_arr(arr, 8);

    arr_backup(arr_bkp, arr, 8);

    // 设置策略是选择排序

    strategy_t s_sort_strategy = {select_sort};

    set_strategy(&context, &s_sort_strategy);

    printf("\n选择排序前:\n");

    print_arr(arr, 8);

    exec_strategy(&context, arr, 8);

    printf("\n选择排序后:\n");

    print_arr(arr, 8);

    arr_backup(arr_bkp, arr, 8);

    // 设置策略是插入排序

    strategy_t i_sort_strategy = {insert_sort};

    set_strategy(&context, &i_sort_strategy);

    printf("\n插入排序前:\n");

    print_arr(arr, 8);

    exec_strategy(&context, arr, 8);

    printf("\n插入排序后:\n");

    print_arr(arr, 8);

    return 0;

}