改进全排列程序，对于有重复数据的数组，对输出结果进行排重。 如对数组[1,2,3,4,3,6]，结果中有重复输出的部分只显示一次。c语言

改进全排列程序以排除重复数据输出的逻辑通常涉及到在生成排列的过程中检查是否有重复的元素，并在递归调用之前对数组进行排序。由于全排列会生成数组的所有可能组合，因此在递归生成下一个数字之前，需要确保新的数字与上一个数字不相同（以避免重复）。这里是一个简化的例子：

#include <stdio.h>
#include <stdbool.h>

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

void permute(int *arr, int start, int end, bool *used, int **result, int *count) {
    if (start == end) {
        result[*count] = (int *)malloc((end + 1) * sizeof(int));
        for (int i = 0; i <= end; i++) {
            result[*count][i] = arr[i];
        }
        (*count)++;
        return;
    }

    for (int i = start; i <= end; i++) {
        if (!used[i]) {
            if (i > start && arr[i] == arr[start]) continue; // Skip duplicates

            swap(&arr[start], &arr[i]);
            used[start] = true;
            permute(arr, start + 1, end, used, result, count);
            used[start] = false;

            swap(&arr[start], &arr[i]); // Backtrack
        }
    }
}

int** permuteUnique(int* arr, int arrSize, int* returnSize) {
    bool *used = (bool *)calloc(arrSize, sizeof(bool));
    int **result = (int **)malloc(sizeof(int *) * (arrSize + 1));
    *returnSize = 0;

    // Sort the array to group duplicates together
    for (int i = 0; i < arrSize - 1; i++) {
        for (int j = i + 1; j < arrSize; j++) {
            if (arr[i] > arr[j]) {
                swap(&arr[i], &arr[j]);
            }
        }
    }

    permute(arr, 0, arrSize - 1, used, result, returnSize);
    free(used);

    return result;
}

int main() {
    int arr[] = {1, 2, 3, 4, 3, 6};
    int returnSize;
    int **uniquePermutations = permuteUnique(arr, sizeof(arr)/sizeof(arr[0]), &returnSize);

    // Print unique permutations
    for (int i = 0; i < returnSize; i++) {
        for (int j = 0; j < returnSize; j++) {
            printf("%d ", uniquePermutations[i][j]);
        }
        printf("\n");
    }

    // Free allocated memory
    for (int i = 0; i < returnSize; i++) {
        free(uniquePermutations[i]);
    }
    free(uniquePermutations);

    return 0;
}

这个例子首先对输入数组进行排序，以便相同的元素聚集在一起，然后在递归函数 `permute` 中通过检查 `used` 数组来避免重复的排列，并且在每次递归调用之前检查新添加的元素是否与前一个元素相同。