47. 全排列 II Permutations II

题目 https://leetcode-cn.com/problems/permutations-ii/

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

void sort(int *nums,int size){
    
    
    int left,right,mid;
    mid = 0;left=1;right=size-1;
    int c;
    if(left>right){
    
    
        return;
    }

    while(left<=right){
    
    
        while(left<=right && nums[mid] < nums[right]) right--;
        if(left>right){
    
    
            break;
        }
        c = nums[mid];
        nums[mid] = nums[right];
        nums[right] = c;
        mid = right;
        right--;

        while(left<=right && nums[mid] > nums[left]) left++;
        if(left>right){
    
    
            break;
        }
        c = nums[mid];
        nums[mid] = nums[left];
        nums[left] = c;
        mid = left;
        left++;
    }

    sort(nums,mid);
    sort(&nums[mid+1],size-mid-1);
}

int **returnNums_t;
int *returnColumnSizes_t;
int returnSize_t;
int returnLen_t;

void getSets(int* nums, int numsSize,int *tmp,int tmp_len,int *flag){
    
    
    if(tmp_len > numsSize){
    
    
        return;
    }
    else if(tmp_len == numsSize){
    
    
        returnColumnSizes_t[returnLen_t] = tmp_len;
        returnNums_t[returnLen_t] = malloc(sizeof(int) * tmp_len);
        memcpy(returnNums_t[returnLen_t],tmp,sizeof(int) * tmp_len);
        returnLen_t++;
        return;
    }

    int i,j;
    for(i=0;i<numsSize;){
    
    
        if(flag[i] == 0){
    
    
            flag[i] = 1;
            tmp[tmp_len] = nums[i];
            getSets(nums,numsSize,tmp,tmp_len+1,flag);
            flag[i] = 0;
            j = nums[i];
            while(i<numsSize && nums[i] == j){
    
    
                i++;
            }
        }else{
    
    
            i++;
        }
    }
}

int** permuteUnique(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    
    
    sort(nums,numsSize);

    int i;
    returnSize_t = 1;
    for(i=numsSize;i>1;i--){
    
    
        returnSize_t *= i;
    }
    returnColumnSizes_t = malloc(sizeof(int) * returnSize_t);
    returnNums_t = malloc(sizeof(int*) * returnSize_t);
    returnLen_t = 0;

    int *tmp = malloc(sizeof(int) * numsSize);
    int *flag = malloc(sizeof(int) * numsSize);
    memset(flag,0,sizeof(int) * numsSize);
    getSets(nums,numsSize,tmp,0,flag);

    *returnSize = returnLen_t;
    *returnColumnSizes = returnColumnSizes_t;
    return returnNums_t;
}