C语言编程实现用堆排序及快速排序算法，从键盘输入数据用二叉链表建立二叉排序树进行中序遍历后的结果进行排序并输出排序结果。

好的，这是一个比较复杂的问题，我将尽力回答。首先，让我们回顾一下堆排序和快速排序算法的基本思想。

堆排序算法：

堆排序是一种基于树形结构的排序算法，它的基本思想是将待排序的序列构建成一个大根堆或小根堆，然后将堆顶元素与堆底元素交换，再重新调整堆，直到整个序列有序。

快速排序算法：

快速排序是一种基于分治思想的排序算法，它的基本思想是选取一个基准元素，将序列分为两个子序列，其中一个子序列中的所有元素都小于基准元素，另一个子序列中的所有元素都大于基准元素，然后对两个子序列分别进行快速排序。

现在，让我们来看一下如何用C语言编程实现这两种排序算法。

堆排序算法的实现：

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;

    if (l < n && arr[l] > arr[largest])
        largest = l;

    if (r < n && arr[r] > arr[largest])
        largest = r;

    if (largest != i) {
        swap(&arr[i], &arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    for (int i = n - 1; i >= 0; i--) {
        swap(&arr[0], &arr[i]);
        heapify(arr, i, 0);
    }
}

int main() {
    int n;
    printf("Enter the number of elements to be sorted: ");
    scanf("%d", &n);

    int* arr = (int*)malloc(n * sizeof(int));
    printf("Enter the elements to be sorted: ");
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    heapSort(arr, n);

    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    free(arr);
    return 0;
}

快速排序算法的实现：

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

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++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

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

int main() {
    int n;
    printf("Enter the number of elements to be sorted: ");
    scanf("%d", &n);

    int* arr = (int*)malloc(n * sizeof(int));
    printf("Enter the elements to be sorted: ");
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    quickSort(arr, 0, n - 1);

    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    free(arr);
    return 0;
}

接下来，让我们看一下如何用二叉链表建立二叉排序树。

二叉排序树的建立：

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

typedef struct node {
    int data;
    struct node* left;
    struct node* right;
} Node;

Node* createNode(int data) {
    Node* temp = (Node*)malloc(sizeof(Node));
    temp->data = data;
    temp->left = NULL;
    temp->right = NULL;
    return temp;
}

Node* insert(Node* root, int data) {
    if (root == NULL) {
        return createNode(data);
    }
    if (data < root->data) {
        root->left = insert(root->left, data);
    } else {
        root->right = insert(root->right, data);
    }
    return root;
}

void inorderTraversal(Node* root, int arr[], int* index) {
    if (root == NULL) {
        return;
    }
    inorderTraversal(root->left, arr, index);
    arr[(*index)++] = root->data;
    inorderTraversal(root->right, arr, index);
}

int main() {
    int n;
    printf("Enter the number of elements to be sorted: ");
    scanf("%d", &n);

    Node* root = NULL;
    printf("Enter the elements to be sorted: ");
    for (int i = 0; i < n; i++) {
        int data;
        scanf("%d", &data);
        root = insert(root, data);
    }

    int* arr = (int*)malloc(n * sizeof(int));
    int index = 0;
    inorderTraversal(root, arr, &index);

    // Sorting the array using Heap Sort or Quick Sort
    // ...

    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    free(arr);
    return 0;
}

最后，我们将排序后的数组输出，完整的代码如下：