3个参数的中位值平均滤波算法C代码

以下是一个基于数组的3个参数的中位值平均滤波算法的C代码：

#include <stdio.h>

int main() {
    int arr[3];
    int i, j, temp, median;

    // 读取输入数据
    for (i = 0; i < 3; i++) {
        printf("请输入第%d个数：", i + 1);
        scanf("%d", &arr[i]);
    }

    // 排序
    for (i = 0; i < 3 - 1; i++) {
        for (j = 0; j < 3 - i - 1; j++) {
            if (arr[j] > arr[j+1]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }

    // 取中位数
    median = arr[1];

    // 输出结果
    printf("中位数为：%d\n", median);

    return 0;
}

该算法的思路是：读入3个数，将它们进行排序，然后取中间值作为中位数。当然，这个算法也可以用于更多个参数的中位值平均滤波，只需要将数组长度和排序部分的代码进行相应修改即可。

相关问题

中位值平均滤波算法C代码

以下是中位值平均滤波算法的 C 代码实现：

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

int cmpfunc(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

void median_filter(int data[], int size, int window_size, int filtered_data[]) {
    int half_size = window_size / 2;
    for (int i = half_size; i < size - half_size; i++) {
        int window[window_size];
        for (int j = 0; j < window_size; j++) {
            window[j] = data[i - half_size + j];
        }
        qsort(window, window_size, sizeof(int), cmpfunc);
        int sum = 0;
        for (int j = 0; j < window_size; j++) {
            sum += window[j];
        }
        filtered_data[i] = sum / window_size;
    }
}

int main() {
    int data[] = {1, 3, 5, 2, 4, 6, 8, 7, 9, 10};
    int size = sizeof(data) / sizeof(int);
    int window_size = 3;
    int filtered_data[size - window_size + 1];
    median_filter(data, size, window_size, filtered_data);
    for (int i = 0; i < size - window_size + 1; i++) {
        printf("%d ", filtered_data[i]);
    }
    return 0;
}

其中，函数 `median_filter` 接受四个参数：`data` 是待滤波的数据，`size` 是 `data` 数组的大小，`window_size` 是窗口大小，`filtered_data` 是存放滤波后的数据的数组。函数中使用了 `qsort` 函数进行中位数的计算。在 `main` 函数中，我们对一个简单的测试数据进行了滤波，并输出了滤波后的结果。

滑动均值滤波算法c语言代码

以下是一个简单的 C 语言实现滑动均值滤波算法的代码：

#include <stdio.h>

void sliding_average_filter(float *signal, float *filtered_signal, int signal_length, int window_size) {
    int i, j;
    float window_sum, mean;

    // 处理边界情况
    for (i = 0; i < window_size - 1; i++) {
        window_sum = 0.0;
        for (j = 0; j < i + 1; j++) {
            window_sum += signal[j];
        }
        mean = window_sum / (i + 1);
        filtered_signal[i] = mean;
    }

    // 处理中间部分
    for (i = window_size - 1; i < signal_length; i++) {
        window_sum = 0.0;
        for (j = i - window_size + 1; j < i + 1; j++) {
            window_sum += signal[j];
        }
        mean = window_sum / window_size;
        filtered_signal[i] = mean;
    }

    // 处理边界情况
    for (i = signal_length - window_size + 1; i < signal_length; i++) {
        window_sum = 0.0;
        for (j = i; j < signal_length; j++) {
            window_sum += signal[j];
        }
        mean = window_sum / (signal_length - i);
        filtered_signal[i] = mean;
    }
}

int main() {
    float signal[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
    float filtered_signal[10];
    int signal_length = 10;
    int window_size = 3;

    sliding_average_filter(signal, filtered_signal, signal_length, window_size);

    int i;
    for (i = 0; i < signal_length; i++) {
        printf("%f ", filtered_signal[i]);
    }
    printf("\n");

    return 0;
}

这个函数接受四个参数：一个输入信号 `signal`、一个输出信号 `filtered_signal`、输入信号的长度 `signal_length` 和一个窗口大小 `window_size`。它使用三个循环来处理边界情况和中间部分。在每次循环中，它计算当前窗口的和并计算平均值，然后把平均值添加到输出信号 `filtered_signal` 中。最终，函数修改了 `filtered_signal` 数组，其中包含了过滤后的信号。

你可以调整窗口大小来控制平滑程度。较大的窗口会产生更平滑的输出，但同时也会产生更多的延迟。函数中的第一个循环和最后一个循环用于处理输入信号的边界情况。这些情况需要特殊处理，因为窗口不能超出输入信号的边界。