对于起泡排序和快速排序，分别统计排序过程中元素的比较次数和移动次数，并对时间性能进行比较的C语言代码及运行结果

起泡排序和快速排序是两种常见的排序算法，它们的时间复杂性和性能有所不同。

**起泡排序（Bubble Sort）:**
起泡排序通过反复交换相邻未排序的元素进行排序。这里我们仅提供一个基本的C语言版本，用于展示过程：

#include <stdio.h>

void bubble_sort(int arr[], int n) {
    int i, j, swap;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                swap = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = swap; // 比较并交换
            }
        }
    }
}

// 统计函数，这里假设只考虑元素间的比较和交换
int compare_count_bubble(int arr[], int n) {
    int count = 0;
    for (int i = 0; i < n * (n - 1) / 2; i++) { // 大约 n*(n-1)/2 次比较
        count++;
    }
    return count;
}

int move_count_bubble(int arr[], int n) {
    int count = 0;
    for (int i = 0; i < n * (n - 1) / 2; i++) { // 大约 n*(n-1)/2 次交换
        count += 1; // 这里假设每次都是1次交换
    }
    return count;
}

**快速排序（Quick Sort）:**
快速排序则是采用分治策略，通常情况下内部循环会比外部循环少很多次，因为它是一种自适应排序算法：

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

void quick_sort(int arr[], int low, int high) {
    if (low < high) {
        int pivot_index = partition(arr, low, high);
        quick_sort(arr, low, pivot_index - 1);
        quick_sort(arr, pivot_index + 1, high);
    }
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);

    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            // 只有在找到更小值的时候才交换，所以比较次数相对较少
            // 移动次数由partitioning决定，取决于元素分布情况
            [...]
        }
    }
    arr[i + 1] = pivot;
    return i + 1;
}

// 类似于bubble_sort中的统计方法
int compare_count_quick(int arr[], int n) {
    int count = 0;
    // QuickSort实际平均是比较次数远小于(n^2)的一半，因为分区过程减少了很多比较
    count = n * log2(n); // 使用近似的公式，实际情况更复杂
    return count;
}

int move_count_quick(int arr[], int n) {
    int count = 0;
    // QuickSort的实际移动次数也依赖于元素分布，平均情况下比 Bubble Sort 少
    count = n * log2(n) - n; // 这里也是近似的估计
    return count;
}

注意，上述代码片段仅用于说明，实际运行的结果将因输入数据的不同而有所变化。对于特定的数据集，可以编写专门的测试程序来测量准确的比较次数和移动次数。