【每日刷题】Day71

【每日刷题】Day71

🥕个人主页：开敲🍉

🔥所属专栏：每日刷题🍍

🌼文章目录🌼

1. 牛群分隔

2. 912. 排序数组 - 力扣（LeetCode）

3. 791. 自定义字符串排序 - 力扣（LeetCode）

1. 牛群分隔

//思路：归并。将＜x的值和≥x的值分别存入两个数组中。随后先将＜x的值放回链表，后将≥x的值放回链表。

typedef struct ListNode LN;

struct ListNode* cow_partition(struct ListNode* head, int x )

{

    int arr1[101] = {0};

    int count1 = 0;

    int arr2[101] = {0};

    int count2 = 0;

    LN* pmove = head;

    while(pmove)

    {

        if(pmove->val>=x)

            arr2[count2++] = pmove->val;//存大

        else

            arr1[count1++] = pmove->val;//存小

        pmove = pmove->next;

    }

    pmove = head;

    int flag1 = 0;

    int flag2 = 0;

    while(flag1<count1)

    {

        pmove->val = arr1[flag1++];//放小

        pmove = pmove->next;

    }

    while(flag2<count2)

    {

        pmove->val = arr2[flag2++];//放大

        pmove = pmove->next;

    }

    return head;

}

2. 912. 排序数组 - 力扣（LeetCode）

//思路①：记数排序

void CountSort(int* nums,int size)

{

    int max = 0;

    int min = 0;

    for(int i = 0;i<size;i++)

    {

        if(nums[i]>nums[max])

            max = i;

        if(nums[i]<nums[min])

            min = i;

    }

    int x = nums[max];

    int y = nums[min];

    int* hash = (int*)calloc(x-y+1,sizeof(int));

    for(int i = 0;i<size;i++)

    {

        hash[nums[i]-y]+=1;

    }

    int count = 0;

    for(int i = 0;i<=x-y;i++)

    {

        while(hash[i])

        {

            nums[count++] = i+y;

            hash[i]--;

        }

    }

}

int* sortArray(int* nums, int numsSize, int* returnSize)

{

    CountSort(nums,numsSize);

    *returnSize = numsSize;

    return nums;

}

//思路②：堆排序

//交换函数

void Swap(int* x,int* y)

{

    int tmp = *x;

    *x = *y;

    *y = tmp;

}

 

//向下调整建堆

void AdjustDown(int* arr,int parents,int size)

{

    int child = parents*2+1;

    while(child<size)

    {

        if(child+1<size&&arr[child+1]>arr[child])

            child++;

        if(arr[child]>arr[parents])

            Swap(&arr[child],&arr[parents]);

        else

            break;

        parents = child;

        child = parents*2+1;

    }

}

 

//堆排序

void HeapSort(int* arr,int size)

{

    for(int i = (size-2)/2;i>=0;i--)

    {

        AdjustDown(arr,i,size);

    }

    while(size)

    {

        Swap(&arr[0],&arr[size-1]);

        size--;

        AdjustDown(arr,0,size);

    }

}

 

int* sortArray(int* nums, int numsSize, int* returnSize)

{

    HeapSort(nums,numsSize);

    *returnSize = numsSize;

    return nums;

}

//思路③：希尔排序

//插入排序

void InsertSort(int* arr,int size)

{

    for(int i = 0;i<size-1;i++)

    {

        int end = i+1;

        int tmp = arr[end];

        while(end-1>=0)

        {

            if(arr[end-1]>tmp)

                arr[end] = arr[end-1];

            else

                break;

            end--;

        }

        arr[end] = tmp;

    }

}

//希尔排序

void ShellSort(int* arr,int size)

{

    int gap = size;

    while(gap>1)

    {

        gap = gap/3+1;

        for(int i = 0;i<size-gap;i++)

        {

            int end = i+gap;

            int tmp = arr[end];

            while(end-gap>=0)

            {

                if(arr[end-gap]>tmp)

                    arr[end] = arr[end-gap];

                else

                    break;

                end-=gap;

            }

            arr[end] = tmp;

        }

    }

    InsertSort(arr,size);

}

 

int* sortArray(int* nums, int numsSize, int* returnSize)

{

    ShellSort(nums,numsSize);

    *returnSize = numsSize;

    return nums;

}

//思路④：归并排序

//归并排序子函数

void _MergeSort(int* arr,int* tmp,int left,int right)

{

    if(left>=right)

        return;

    int mid = (left+right)/2;

    _MergeSort(arr,tmp,left,mid);

    _MergeSort(arr,tmp,mid+1,right);

    int begin1 = left;

    int end1 = mid;

    int begin2 = mid+1;

    int end2 = right;

    int count = 0;

    while(begin1<=end1&&begin2<=end2)

    {

        if(arr[begin1]<=arr[begin2])

            tmp[count++] = arr[begin1++];

        else

            tmp[count++] = arr[begin2++];

    }

    while(begin1<=end1)

    {

        tmp[count++] = arr[begin1++];

    }

    while(begin2<=end2)

    {

        tmp[count++] = arr[begin2++];

    }

    memcpy(arr+left,tmp,sizeof(int)*count);

}

 

//归并排序

void MergeSort(int* arr,int size)

{

    int* tmp = (int*)malloc(sizeof(int)*(size+1));

    _MergeSort(arr,tmp,0,size);

    free(tmp);

    tmp = NULL;

}

 

int* sortArray(int* nums, int numsSize, int* returnSize)

{

    MergeSort(nums,numsSize-1);

    *returnSize = numsSize;

    return nums;

}

//思路⑤：归并排序(非递归)

//归并排序 (非递归)

void MergeSortNoRe(int* arr, int size)

{

    int* tmp = (int*)malloc(sizeof(int) * size);

    int gap = 1;

    while (gap < size)

    {

        for (int i = 0; i < size; i += 2 * gap)

        {

            int count = 0;

            int begin1 = i;

            int end1 = i + gap - 1;

            int begin2 = i + gap;

            int end2 = i + 2 * gap - 1;

            if (begin2 >= size)

                break;

            if (end2 >= size)

                end2 = size - 1;

            while (begin1 <= end1 && begin2 <= end2)

            {

                if (arr[begin1] < arr[begin2])

                    tmp[count++] = arr[begin1++];

                else

                    tmp[count++] = arr[begin2++];

            }

            while (begin1 <= end1)

            {

                tmp[count++] = arr[begin1++];

            }

            while (begin2 <= end2)

            {

                tmp[count++] = arr[begin2++];

            }

            memcpy(arr + i, tmp, sizeof(int) * (end2 - i + 1));

        }

        gap *= 2;

    }

}

int* sortArray(int* nums, int numsSize, int* returnSize)

{

    MergeSortNoRe(nums,numsSize);

    *returnSize = numsSize;

    return nums;

}

3. 791. 自定义字符串排序 - 力扣（LeetCode）

//思路：哈希。记录s字符串中每个字母的个数，根据order字符串字母出现的顺序将字母放入答案数组中。

char* customSortString(char* order, char* s)

{

    char* ans = (char*)malloc(sizeof(char)*201);

    int count = 0;

    int hash[27] = {0};

    for(int i = 0;i<strlen(s);i++)

    {

        hash[s[i]-'a']+=1;//统计个数

    }

    for(int i = 0;i<strlen(order);i++)

    {

        while(hash[order[i]-'a'])

        {

            ans[count++] = order[i];//判断s中是否有这个字母以及有多少个，再根据order字符串中字母出现的顺序放入答案数组

            hash[order[i]-'a']--;

        }

    }

    for(int i = 0;i<strlen(s);i++)

    {

        while(hash[s[i]-'a'])//将s中剩余字母放进答案数组

        {

            ans[count++] = s[i];

            hash[s[i]-'a']--;

        }

    }

    ans[count] = '\0';//最后别忘了加上'\0'

    return ans;

}