刷题 ------ 排序

文章目录

  • 1.K 次取返后最大化的数组和(堆)
  • 2.数组的相对排序(桶)
  • 3.最小绝对差
  • 4.根据数字二进制下1的数目排序(qsort)
  • 5.有多少小于当前数字的数字
  • 6.非递增顺序的最小子序列
  • 7.按照频率将数组升序排序(qsort)
  • 8.将句子排序
  • 9.找到最大长度为 k 的子序列(双排序)
  • 10.对奇偶下标分别排序
  • 11. 按身高排序
  • 12. 最小和分割
  • 13.大于等于顺序前缀和的最小缺失整数
  • 14.文物朝代判断

基于上篇的排序算法,本篇刷了一下leetcode上的关于排序算法的题,因为我是点的排序标签刷的,所以有些题排完序答案就出来了,就没有写题解了。

1.K 次取返后最大化的数组和(堆)

在这里插入图片描述

看完题目,首先得知道的就是,我们应该尽量把全部的负数去取反,因为最小的负数取反之后就会很大,所以到全部的负数都取反,不能再取之后,或者说是k次取完了。

  • 如果k次取完了,那正好,直接返回当前数组的和就好了.
  • 如果负数变更完了,k 还有偶数次,负负得正 所以你就可以一直取同样的一个数,所以还是可以返回当前数组的和就好了。
  • 但是还有有一种情况,就是说,负数变更完了,而k是奇数次,变更那个最小的数就好了。
int cmp_int(const void* x, const void* y)
{
    return *(int*)x - *(int*)y;
}

int largestSumAfterKNegations(int* nums, int numsSize, int k)
{
    qsort(nums,numsSize,sizeof(int),cmp_int);
    int i = 0, sum = 0;
    //先将负数全部反正
    while(i < numsSize && k > 0 && nums[i] <= 0)
    {
        nums[i] = -nums[i];
        i++;
        k--;
    }
    //判断剩下的k是否为奇数。
    if(k % 2 != 0)
    {
        //再排序
        qsort(nums,numsSize,sizeof(int),cmp_int);
        nums[0] = -nums[0];
    }
    for (i = 0; i < numsSize; i++)
    {   
        sum += nums[i];
    }

    return sum;
}

还有一种思路是:选出最小的那一个数据,然后取反,之后接着选最小的数据,直到k次全部完毕。

  • 可以用选择排序的方法,每次进行选择。
  • 还可以建立一个小顶堆出来,然后将堆顶的数据去反后,再维护此堆。
void Swap(int* x, int* y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

void Heapify(int* nums, int numsSize, int i)
{
    int minIndx = i, lc = i * 2 + 1, rc = i * 2 + 2;
    if(lc < numsSize && nums[lc] < nums[minIndx])
    {
        minIndx = lc;
    }
    if(rc < numsSize && nums[rc] < nums[minIndx])
    {
        minIndx = rc;
    }
    if(minIndx != i)
    {
        Swap(&nums[i],&nums[minIndx]);
        Heapify(nums,numsSize,minIndx);
    }
}


int largestSumAfterKNegations(int* nums, int numsSize, int k)
{
    int i,sum = 0;
    //创建一个小顶堆
    for (i = (numsSize - 1) / 2; i >= 0; i--)
    {
        Heapify(nums,numsSize,i);
    }
    while(k > 0)
    {
        //将最小值拿出来后取反
        nums[0] = -nums[0]; 
        //维护堆,""
        Heapify(nums,numsSize,0);
        k--;
    }
    for (i = 0; i < numsSize; i++)
    {
        sum += nums[i];
    }

    return sum;
}

2.数组的相对排序(桶)

在这里插入图片描述
这道题可以用桶排序来做。

  • 首先把arr1中所有出现的数字按照放入桶(哈希表)中。
  • 然后遍历arr2中的对应的元素,放入ans中,即实现以arr2的形式排序arr1
  • 最后将桶中还未取来的,依次放入ans中就好了。
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* relativeSortArray(int* arr1, int arr1Size, int* arr2, int arr2Size, int* returnSize)
{
    int* bucket = (int*)calloc(1001,sizeof(int));
    int* ans = (int*)malloc(sizeof(int) * arr1Size);
    int size = 0,i,maxnum = 0;
    //桶排序
    for (i = 0; i < arr1Size; i++)
    {
        bucket[arr1[i]]++;
        if(maxnum < arr1[i])
        {
            maxnum = arr1[i];
        }
    }
    //按照arr2的顺序取出
    for (i = 0; i < arr2Size; i++)
    {
        while(bucket[arr2[i]] != 0)
        {
            ans[size++] = arr2[i];
            bucket[arr2[i]]--;
        }
    }
    
    //将arr1中剩余的按照升序放入ans中
    for (i = 0; i <= maxnum; i++)
    {
        while(bucket[i] >= 1)
        {
            ans[size++] = i;
            bucket[i]--;
        }
    }
    *returnSize = size;
    return ans;
}

3.最小绝对差

在这里插入图片描述

这道题就是让我们首先知道最小绝对差是多少,然后选出是最小绝对差的两个下标就好了。

  • 首先给数组排序,相邻两个数的绝对差肯定是小的。
  • 然后找处最小的。
  • 最后再遍历一遍,选出符合最小绝对差的下标。
int cmp_int(const void* x, const void* y)
{
    return *(int*)x - *(int*)y;
}


int** minimumAbsDifference(int* arr, int arrSize, int* returnSize, int** returnColumnSizes)
{
    int** ans = (int**)malloc(sizeof(int*) * (arrSize - 1));
    *returnColumnSizes = (int*)malloc(sizeof(int*) * (arrSize - 1));
    int i,gap,size = 0;
    for (i = 0; i < (arrSize - 1); i++)
    {
        ans[i] = (int*)malloc(sizeof(int) * 2);
        (*returnColumnSizes)[i] = 2;
    }
    qsort(arr,arrSize,sizeof(int),cmp_int);
    //求最小绝对差值
    gap = abs(arr[0] - arr[1]);
    for (i = 1; i < arrSize - 1; i++)
    {
        if(abs(arr[i] - arr[i+1]) < gap)
        {
            gap = abs(arr[i] - arr[i+1]);
        }
    }
    for (i = 0; i < arrSize - 1; i++)
    {
        if(abs(arr[i] - arr[i+1]) == gap)
        {
            ans[size][0] = arr[i];
            ans[size++][1] = arr[i+1];
        }
    }
    *returnSize = size;
    return ans;
}

4.根据数字二进制下1的数目排序(qsort)

在这里插入图片描述
这道题,让我对qsort函数有了一个新的认知。
在这里插入图片描述

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int GetBinaryDigitSum(int n)
{
    int* nums = (int*)malloc(sizeof(int) * 32);
    int size = 0;
    while(n != 0)
    {
        nums[size++] = n % 2;
        n /= 2;
    }   
    int i, sum = 0;
    for (i = 0; i < size; i++)
    {
        sum += nums[i];
    }

    return sum;
}

int cmp_sum(const void* x, const void* y)
{
    int numx = *(int*)x,numy = *(int*)y;
    //求出二进制1的位置
    int c = GetBinaryDigitSum(numx),d = GetBinaryDigitSum(numy);
    //如果二进制1的位数相同,那么去利用原来数的大小去排序
    return c == d ? numx - numy : c - d;
}


int* sortByBits(int* arr, int arrSize, int* returnSize)
{
    qsort(arr,arrSize,sizeof(int),cmp_sum);
    *returnSize = arrSize;
    return arr;
}

5.有多少小于当前数字的数字

在这里插入图片描述

就对于每个数进行挨个求,直接用暴力就能解决,同业也可以用排序的方式来解决

  • 首先需要将当前的这个数和下标存在一起,然后对数进行排序,这样子就会得到一个这样的数组
    在这里插入图片描述
  • 最后遍历data数组,用prev记录着上一个比自己小的数就好了.
int cmp_val(const void* x, const void* y)
{
    return ((int**)x)[0][0] - ((int**)y)[0][0];
}

int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize)
{
    //data 里面存放的是数据和下标
    int** data = (int**)malloc(sizeof(int*) * numsSize);
    int* ans = (int*)malloc(sizeof(int) * numsSize);
    *returnSize = numsSize;
    int i;
    for (i = 0; i < numsSize; i++)
    {
        data[i] = (int*)malloc(sizeof(int) * 2);
        data[i][0] = nums[i];
        data[i][1] = i;
    }

    //给data以val进行排序
    qsort(data,numsSize,sizeof(data),cmp_val);
    int prev = -1;
    for (i = 0; i < numsSize; i++)
    {
        if(i == 0 || data[i][0] != data[i-1][0])
        {
            prev = i;
        }
        ans[data[i][1]] = prev;
    }

    return ans;
}

6.非递增顺序的最小子序列

在这里插入图片描述

看完题之后,应该先排序,然后分别求出其前缀和与后缀和,拿当前数的后缀和与前一个数的前缀和去比较,像这个样子,
在这里插入图片描述
下面是代码:
在这里插入图片描述

  • 所以我写的时候全部求出来了。官方题解,也就是这个意思,但是人家不用挨个全部求出来。
  • 只要先计算出总共的和,然后从后往前遍历的时候本来就能算出后缀和,拿sum-后缀和,不就是前缀和吗?
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int cmp_int(const void* x, const void* y)
{
    return *(int*)x - *(int*)y;
}

int* minSubsequence(int* nums, int numsSize, int* returnSize)
{
    int sum = 0;
    //先排序
    qsort(nums,numsSize,sizeof(int),cmp_int);
    int* ans = (int*)malloc(sizeof(int) * numsSize);
    int size = 0;
    int i,suffixsum = 0;
    for (i = 0; i < numsSize; i++)
    {
        sum += nums[i];
    }

    for (i = numsSize - 1; i >= 0; i--)
    {
        suffixsum += nums[i];
        ans[size++] = nums[i];
        if(sum - suffixsum < suffixsum)
        {
            break;
        }
    }

    *returnSize = size;
    return ans;
}

7.按照频率将数组升序排序(qsort)

在这里插入图片描述

优先考虑频率的排序,如果频率相同的话,再将其值按照降序的排序。

  • 保证整个数组是有序,使重复的数在一起。
  • 然后利用二维数组记录出每个数出现的次数。
  • data[1][0] 表示1出现的次数
  • data[1][1] 表示-1出现的次数
  • 利用qsort对数组进行频率排序,频率相同的话,再将其值按照降序的排序.


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

#define ROW 101
#define COL 2

int data[ROW][COL];

int GetFreq(x)
{
    if(x >= 0)
    {
        return data[x][0];
    }
    else
    {
        return data[-x][1];
    }
}
 //按照频率排序
int cmp_freq(const void* x, const void* y)
{
    int numx = *(int*)x, numy = *(int*)y;
    int frex = GetFreq(numx), frey = GetFreq(numy);
    //如果频率相同,去比较值的大小。
    return frex == frey ? y - x : frex - frey;
}       

int cmp_int(const void* x, const void* y)
{
    return *(int*)x - *(int*)y;
}


int* frequencySort(int* nums, int numsSize, int* returnSize)
{
    int i,j;
    //重置二维数组
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COL; j++)
        {
            data[i][j] = 0;
        }
    }
    for (i = 0; i < numsSize; i++)
    {
        if(nums[i] >= 0)
        {
            //正数出现的次数
            data[nums[i]][0]++;
        }
        else
        {
            //负数出现的次数
            data[-nums[i]][1]++;
        }
    }
    qsort(nums,numsSize,sizeof(int),cmp_int);
    qsort(nums,numsSize,sizeof(int),cmp_freq);
    *returnSize = numsSize;
    return nums;
}

8.将句子排序

在这里插入图片描述

遍历一所给字符串,然后将其隐射到哈希中去。
就比如下图这个样子
在这里插入图片描述

  • 然后整个哈希进行遍历,不为NULL依次放入ans中就好了
#define WORD_LEN 201

char * sortSentence(char * s)
{
    int i = 0,j = 0,len = strlen(s);
    char** words = (char**)malloc(sizeof(char*) * 11);
    char* ans = (char*)malloc(sizeof(char) * len);
    int pos = 0;
    for (i = 0; i < 11; i++)
    {
        words[i] = NULL;
    }
    //i记录起点
    i = 0;
    while(i < len)
    {
        //tmp 里面存放着单词
        char* tmp = (char*)malloc(sizeof(char) * WORD_LEN);
        //找数字
        while(j < len && !(s[j] >= '0' && s[j] <= '9'))
        {
            j++;
        }
        //在对应的索引处进行插入字符串
        int index = s[j] - '0';
        s[j] = '\0';
        strcpy(tmp,s + i);
        words[index] = tmp;
        //跳过空格
        j += 2;
        //i记录起点
        i = j;
    }

    //按照顺序拿出来就好了
    for (i = 0; i < 11; i++)
    {
        if(words[i] != NULL)
        {
            int size = strlen(words[i]);
            memcpy(ans + pos,words[i],sizeof(char) * size);
            pos += size;
            ans[pos++] = ' ';
        }
    }
    //调整最后一个字符
    ans[--pos] = '\0';
    return ans;
}

9.找到最大长度为 k 的子序列(双排序)

在这里插入图片描述

题目中不允许改变元素顺序,但是呢,要想得到最大的子序列,其子序列中的数据肯定还是原数组中最大的那几个数,于是我们可以排序两次,选出最大值后,再按照原来的顺序取回去就好了,如下图:
在这里插入图片描述

  • 建立一个二维数组出来,data[i][0]放val data[i][1] 放其所对应的索引。
  • 首先对二维数组data进行值的排序,选出k个最大的值。
  • 再选出来的数组进行下标排序。[begin,numsSize].
  • 最后拷贝到ans中就好了


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int cmp_val(const void* x,const void* y)
{
    return ((int**)x)[0][0] - ((int**)y)[0][0];
}
int cmp_index(const void* x,const void* y)
{
    return ((int**)x)[0][1] - ((int**)y)[0][1];
}


int* maxSubsequence(int* nums, int numsSize, int k, int* returnSize)
{   
    if(numsSize == k)
    {
        *returnSize = k;    
        return nums;
    }
    int i;
    int** data = (int**)malloc(sizeof(int*) * numsSize);
    int* ans = (int*)malloc(sizeof(int) * k);
    int size = 0;
    for (i = 0; i < numsSize; i++)
    {
        data[i] = (int*)malloc(sizeof(int) * 2);
        data[i][0] = nums[i];
        data[i][1] = i;
    }
    //先按照值排序
    qsort(data,numsSize,sizeof(data[0]),cmp_val);
    int begin = numsSize - k;
    //再将选中的那些按照原先的位置排序[begin,k]
    qsort(data + begin,k,sizeof(data[0]),cmp_index);
    //拷贝即可[begin,numsSize]
    for (i = begin; i < numsSize; i++)
    {
        ans[size++] = data[i][0];
    }
    *returnSize = k;
    return ans;
}

10.对奇偶下标分别排序

在这里插入图片描述

  • 构造两个数组,分别放偶数下标所对应的数,和奇数下标所对应的数。
  • 然后将偶数数组升序排序,奇数数组降序排序
  • 最后交叉放回数组中即可。
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

//升序
int Asc_cmp_int(const void* x,const void* y)
{
    return *(int*)x - *(int*)y;
}
//降序
int Des_cmp_int(const void* x,const void* y)
{
    return *(int*)y - *(int*)x;
}


int* sortEvenOdd(int* nums, int numsSize, int* returnSize)
{
    int* eveni = (int*)malloc(sizeof(int) * (numsSize / 2 + 1));
    int* oddi = (int*)malloc(sizeof(int) * (numsSize / 2 + 1));
    int i,eSize = 0,oSize = 0;
    for (i = 0; i < numsSize; i++)
    {
        if(i % 2 == 0)
        {
            eveni[eSize++] = nums[i];
        }
        else
        {
            oddi[oSize++] = nums[i];
        }
    }
    //偶数下标按照升序
    qsort(eveni,eSize,sizeof(int),Asc_cmp_int);
    //奇数下标按照降序
    qsort(oddi,oSize,sizeof(int),Des_cmp_int);
    int size = 0;
    for (i = 0; i < eSize; i++)
    {
        nums[size] = eveni[i];
        size += 2;
    }
    size = 1;
    for (i = 0; i < oSize; i++)
    {
        nums[size] = oddi[i];
        size += 2;
    }

    *returnSize = numsSize;
    return nums;
}
// 4 1 2 3

// 4  2 
// 1 3

// 2 4 
// 3 1
// 2 3 4 1

11. 按身高排序

在这里插入图片描述

这跟上面的9题是很类似的,同样也是利用一个二维数组,一个存身高,然后另一个存下标
在这里插入图片描述

  • 看上面图中,先将身高按照降序排序,然后依次按找下标取字符串就好了.
int cmp_hight(const void* x, const void* y)
{
    return ((int**)y)[0][0] - ((int**)x)[0][0];
}


char** sortPeople(char** names, int namesSize, int* heights, int heightsSize, int* returnSize)
{
    char** ans = (char**)malloc(sizeof(char*) * namesSize);
    int size = 0;
    int** data = (int**)malloc(sizeof(int*) * namesSize);
    int i;
    for (i = 0; i < namesSize; i++)
    {
        data[i] = (int*)malloc(sizeof(int) * 2);
        data[i][0] = heights[i];
        data[i][1] = i; //存放下标
    }
    qsort(data,namesSize,sizeof(data[0]),cmp_hight);

    for (i = 0; i < namesSize; i++)
    {
        ans[size++] = names[data[i][1]];
    }

    *returnSize = size;
    return ans;
}

12. 最小和分割

在这里插入图片描述
这道题,首先得知道一个理论把,就是一堆有序的数里面,将他平均分隔组成的两个数。
要想和最小,那么一定得是间隔的去取,就比如下图,是135 + 24
在这里插入图片描述
知道这一点,这道题就好办了。

void GetDigit(int* nums,int* size,int num)
{
    *size = 0;
    while(num != 0)
    {
        nums[(*size)++] = num % 10;
        num /= 10;
    }
}

int cmp_int(const void* x, const void* y)
{
    return *(int*)x - *(int*)y;
}

int splitNum(int num)
{
    int* nums = (int*)malloc(sizeof(int) * 10);
    int size = 0;
    GetDigit(nums,&size,num);
    qsort(nums,size,sizeof(nums[0]),cmp_int);
    int i, x = 0, y = 0;
    for (i = 0; i < size; i++)
    {
        if(i % 2 == 0)
        {
            x = x * 10 + nums[i];
        }
        else
        {
            y = y * 10 + nums[i];
        }
    }

    printf("x = %d ,y = %d \n",x,y);
    return x + y;
}

13.大于等于顺序前缀和的最小缺失整数

在这里插入图片描述

  • 首先计算出顺序前缀和。
  • 然后将数组中所有的数放入桶(哈希表中),同时求出最大值来。
  • 如果前缀和大于最大值,说明前缀和肯定没有出现,如果小于取哈希表中查出现过没有,如果没出现过,返回整个前缀和就好了。
  • 如果出现过,就在桶(哈希表)中从它的下一个位置去找,找到第一次未出现的数就是。
int missingInteger(int* nums, int numsSize)
{
    int* map = (int*)calloc(52,sizeof(int));
    int i,prefix = 0;
    //先求出顺序前缀
    for (i = 0; i < numsSize; i++)
    {
        prefix += nums[i];
        if(i+1 < numsSize && nums[i] + 1 != nums[i+1])
        {
            break;
        }
    }

    //统计每个数是否出现,同时求出最大值
    int max = 0;
    for (i = 0; i < numsSize; i++)
    {
        map[nums[i]] = 1;
        if(nums[i] > max)
        {
            max = nums[i];
        }
    }

    //如果说前缀和 比最大值都大,就证明里面肯定没有, || prefix 没有出现过
    if(prefix > max || map[prefix] == 0)
    {
        //满足条件直接返回就好了
        return prefix;
    }

    //说明prefix 出现在数组中,取找它的下一个没有出现过的。
    for (i = prefix + 1; i <= 52; i++)
    {
        if(map[i] == 0)
        {
            return i;
        }
    }

    return -1;
}

14.文物朝代判断

在这里插入图片描述
扑克牌?顺子?癞子? 0 代表癞子?
这道题就是说给你个数组,数组里面的数字你随便排组合,如果能连起来就好了。

  • 首先统计出癞子的个数(0的个数),然后再算出缺失数字的个数。
  • 如果癞子的个数 >= 缺失的个数就能构成顺子。
int cmp_int(const void* x,const void* y)
{
    return *(int*)x - *(int*)y;
}

bool checkDynasty(int* places, int placesSize)
{
    qsort(places,placesSize,sizeof(int),cmp_int);
    int i = 0,zero = 0,miss = 0;
    //计算出0有多少个
    while(i < placesSize && places[i] == 0)
    {
        i++;
        zero++;
    }
    //去找缺失的数字的个数
    for (i; i < placesSize - 1; i++)
    {
        if(places[i+1] == places[i])
        {
            return false;
        }
        miss += places[i+1] - places[i] - 1;
    }
    return zero >= miss ? true : false;
} 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/340720.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

生成当天递增唯一的流水号的几种方式

说明&#xff1a;当开发中&#xff0c;如交易、文件传输过程中的文件名&#xff0c;可能需要我们使用一串唯一的数字来锁定这一条“交互记录”&#xff0c;即流水号。 本文介绍几种生成6位递增唯一&#xff0c;且每日重置的流水号的方式。 方式一&#xff1a;使用Redis 我们…

Leetcode—22.括号生成【中等】

2023每日刷题&#xff08;七十九&#xff09; Leetcode—22.括号生成 算法思想 实现代码 class Solution { public:vector<string> generateParenthesis(int n) {vector<string> ans;int m n * 2;string path(m, 0);function<void(int, int)> dfs [&…

自己构建webpack+vue3+ts

先看看我的目录结构&#xff08;我全局使用TS&#xff09;&#xff1a; 一、安装配置webpack打包 安装esno npm install esnoesno 是基于 esbuild 的 TS/ESNext node 运行时,有了它&#xff0c;就可以直接通过esno *.ts的方式启动脚本&#xff0c;package.json中添加 type:…

力扣62. 不同路径

动态规划 思路&#xff1a; 定义 dp[r][c] 为到达坐标 (r, c) 的路径数&#xff1a; 它只能有同一行左边相邻方格向右到达或者同一列上方相邻方格向下到达&#xff1b;状态转移方程&#xff1a; dp[r][c] dp[r][c - 1] dp[r - 1][c]初始状态 dp[0][0] 1第一行的路径数是 1第…

二维码地址门牌管理系统:社区新风向

文章目录 前言一、集成先进技术的系统二、便捷居民体验三、支持社区管理四、未来展望与可扩展性 前言 随着科技的不断发展&#xff0c;智能化管理已经深入到我们的生活中。二维码门牌管理系统作为一款创新产品&#xff0c;在社区管理领域迅速引起广泛关注。这款系统不仅提升了…

CTFhub-bak文件

CTFhub-Web-信息泄露-备份文件下载-bak文件 题目信息 解题过程 看到提示说和index.php有关&#xff0c;在url后面加index.php.bak&#xff0c;跳转到http://challenge-7a4da2076cfabae6.sandbox.ctfhub.com:10800/index.php.bak网址&#xff0c;即&#xff1a; 跳转到下载页…

彻底搞定让人头痛的nginx location 路径匹配规则

nginx location 路径匹配规则 一、前言二、说在前面三、开始表演 一、前言 很多同学&#xff0c;在配置nginx的时候&#xff0c;都会遇到一个头痛的问题&#xff0c;就是location 的路径应该怎么写&#xff1f;到底要不要加斜杠&#xff0c;有点傻傻分不清楚。今天就来帮助大家…

蓝桥杯真题(Python)每日练Day3

题目 题目分析 为了找到满足条件的放置方法&#xff0c;可以带入总盘数为2和3的情景&#xff0c;用递归做法实现。 A中存在1 2两个盘&#xff0c;为了实现最少次数放入C且上小下大&#xff0c;先将1放入B&#xff0c;再将2放入C&#xff0c;最后将1放入C即可。同理当A中存在1 …

柔性数组和C语言内存划分

柔性数组和C语言内存划分 1. 柔性数组1.1 柔性数组的特点&#xff1a;1.2 柔性数组的使用1.3 柔性数组的优势 2. 总结C/C中程序内存区域划分 1. 柔性数组 也许你从来没有听说过柔性数组&#xff08;flexible array)这个概念&#xff0c;但是它确实是存在的。 C99 中&#xff…

以太坊账户地址与比特B地址生成方法对比

作者 张群&#xff08;赛联区块链教育首席讲师&#xff0c;工信部赛迪特聘资深专家&#xff0c;CSDN认证业界专家&#xff0c;微软认证专家&#xff0c;多家企业区块链产品顾问&#xff09;关注张群&#xff0c;为您提供一站式区块链技术和方案咨询。 以太坊和比特B地址在生成方…

C语言——内存函数介绍和模拟实现(memcpy、memmove、memset、memcmp)

之前我们讲过一些字符串函数&#xff08;http://t.csdnimg.cn/ZcvCo&#xff09;&#xff0c;今天我们来讲一讲几个内存函数&#xff0c;那么可能有人要问了&#xff0c;都有字符串函数了&#xff0c;怎么又来个内存函数&#xff0c;这不是一样的么&#xff1f; 我们要知道之前…

【C语言】指针进阶之sizeof和strlen函数的对比

目录 1.sizeofyu 2.strlen函数 3.sizeof与strlen的对比 1.sizeof >>sizeof计算变量所占内存内存空间 大小 的&#xff0c;单位是 字节 &#xff0c;如果操作数是类型的话&#xff0c;计算的是使⽤类型创建的变量所占内存空间的大小。 >>sizeof 只关注占⽤内存空…

Spring5系列学习文章分享---第一篇(概述+特点+IOC原理+IOC并操作之bean的XML管理操作)

目录 Spring&#xff08;概述特点IOC原理IOC并操作之bean的XML管理操作&#xff09;概述Spring是轻量级的开源的JavaEE框架Spring可以解决企业应用开发的复杂性Spring有两个核心部分ioc,aopSpring特点 loc(概念和原理)什么是 IOCIOC 底层原理IOC 过程图 IOC&#xff08;接口&am…

Java和Redis实现一个简单的热搜功能

1. 前言 我们有一个简单的需求&#xff1a; 搜索栏展示当前登陆的个人用户的搜索历史记录&#xff0c;删除个人历史记录。用户在搜索栏输入某字符&#xff0c;则将该字符记录下来 以zset格式存储的redis中&#xff0c;记录该字符被搜索的个数以及当前的时间戳 &#xff08;用…

阿里云优惠整理,最新2024阿里云优惠政策解读

阿里云优惠政策有哪些&#xff1f;2024年阿里云优惠政策风向改了&#xff0c;之前一直是老用户与狗的营销策略&#xff0c;今年阿里云2核2G、3M固定带宽服务器99元居然开启了老用户购买权限&#xff0c;并且续费不涨价&#xff0c;阿里云这波操作确实让用户赢麻了&#xff0c;在…

MBR扇区修复和GRUB引导修复实验

修复MBR扇区 步骤一&#xff1a;在进行实验之前我们需要新加一块磁盘&#xff0c;并对新加磁盘进行分区处理&#xff0c;用来备份sda磁盘的MBR及分区表信息。&#xff08;注&#xff1a;在实验中可以不像我如此这么繁琐&#xff0c;一个主分区&#xff0c;并格式化挂载即可&am…

PyQt5 快速入门(一)

第一节按钮控件,文本控件,输入框,app图标 文章目录 一.GUI按钮控件 二.文本控件 三.输入框 四.让窗口显示在屏幕中央 五.让窗口显示在屏幕中央 总结 一.GUI按钮控件 import sys from PyQt5.QtWidgets import QApplication, QWidget, QPushButtonif __name__ __main__:app …

UG制图-视图与投影

当我们进入图纸页后&#xff0c;我们需要对产品进行投影然后进行标注 注意&#xff1a;如果是从零件3D中直接进入制图&#xff0c;默认情况下图框所在的图层是不显示的&#xff0c;我们可以通过菜单或者快捷键ctrl L进入图层设置模块&#xff0c;将图层170和173勾选为显示 我…

MacM1Pro Parallels19.1.0 CentOS7.9 Install PostgrepSQL

相关阅读 MacM1Pro安装 Parallels Desktop 19.1.0 https://blog.csdn.net/qq_41594280/article/details/135420241 MacM1Pro Parallels安装Parallels Tools https://blog.csdn.net/qq_41594280/article/details/135398780 MacM1Pro Parallels安装CentOS7.9 https://blog.csdn.n…

Java JVM内存结构 虚拟机栈 本地方法栈 方法区 直接内存

Java Virtual Machine &#xff0c;Java 程序的运行环境&#xff08;Java 二进制字节码的运行环境&#xff09;。 常见的 JVM&#xff1a; 来源维基百科&#xff1a;https://en.wikipedia.org/wiki/Comparison_of_Java_virtual_machines 学习路线&#xff1a; 参考资料&#x…