数组

最新推荐文章于 2022-03-27 18:21:09 发布
最新推荐文章于 2022-03-27 18:21:09 发布
阅读量294 收藏
点赞数
分类专栏： Leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/realism_/article/details/104561366
版权

804. 唯一摩尔斯密码词

这次没有任何技巧而言，感觉就是再次熟悉一下，二级指针空间的分配回收，库函数strcat()的使用

int uniqueMorseRepresentations(char ** words, int wordsSize){
    char mossCode[26][5] = {
        ".-","-...","-.-.","-..",".","..-.","--.","....","..",".---",
        "-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-",
        "..-","...-",".--","-..-","-.--","--.."
    };
    char **result=(char **)malloc(sizeof(char *)*wordsSize);
    for (int i = 0; i < wordsSize; i++) {
         result[i]=(char *)malloc(sizeof(char)*49);//字符串最长为4,4*12+1
        memset(result[i], 0, sizeof(char)*49);
    }

    int i,length,j,sum=0;
    for(i=0;i<wordsSize;i++){
        length=strlen(*(words+i));//行指针
        for(j=0;j<length;j++){
            strcat(result[i],mossCode[words[i][j]-'a']);//计算出words[i]的mosscode
        }
    }
    for(i=0;i<wordsSize;i++){
        for(j=i+1;j<wordsSize;j++){
            if(strcmp(result[i],result[j])==0)
                break;
        }
        if(j==wordsSize)
            sum++;
    }
    for(i=0;i<wordsSize;i++)
        free(result[i]);
    free(result);
    return sum;
}

1351. 统计有序矩阵中的负数

注意利用好，每行每列都是非递增排序就OK拉

int countNegatives(int** grid, int gridSize, int* gridColSize){
    int i,j,m=gridSize,n=*gridColSize,sum=0,tap;
    for(i=0;i<m;i++){
        for(j=n-1;j>=0;j--){
                if(grid[i][j]>=0){
                    tap=0;
                    break;
                }
                tap=-1;
        }
        if(tap==-1){
            sum+=n;
        }else{
            sum+=n-j-1;
        }
    }
    return sum;
}

1337. 方阵中战斗力最弱的 K 行

总的来说来说，是一个排序题，外加索引绑定（索引绑定可以用二维数组，也可结构体，至于其他方法，还没去了解）。
定义结构体大小不能用变量，阿偶
结构体学的很潜，我都不知道qsort能和结构体组合使用。returnSize是返回给主函数，来控住数组的打印的。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
struct Node{
     int index;
     int power;
 };
 int cmp(const void *a,const void *b){
     return (*(struct Node *)a).power - (*(struct Node *)b).power;//a-b从小到大排序b-a则为从大到小排序
 }
int* kWeakestRows(int** mat, int matSize, int* matColSize, int k, int* returnSize){
    int i,j,m=matSize,n=*matColSize;
    struct Node nodes[101]={0};
    for(i=0;i<m;i++){
        nodes[i].index=i;
        for(j=0;j<n;j++){
            if(mat[i][j]==1){   
                nodes[i].power++;
            }    
        }
    }
    qsort(nodes,m,sizeof(struct Node),cmp);
    int *res = (int *)malloc(k * sizeof(int));
    memset(res, 0, k * sizeof(int));
    (*returnSize) = k;//估计主函数中调用了此形参
    for(i=0;i<k;i++){
        res[i]=nodes[i].index;
    }
    return res;
}

717. 1比特与2比特字符

这道题的思路还是满简单的。遍历到的数若为1，则i增2（因为只要遇到1。10，11都是存在的情况），反之则增1。对于0可以是单独的0，或者10，也即只有在最后两位为00的情况下，给定的字符串才是以0结束的。所以我们对0以及他的前一位进行校验即可。情况一共有两种（以下情况，i均指向数组bitsSize的倒数第二个数）：

  1. 最后两位为00，因为bits[bitsSize-1]==0，所以循环结束的时候，字符串刚好以0结束
  2. 最后两位为10，最后循环结束i==bitsSize，越界拉
bool isOneBitCharacter(int* bits, int bitsSize){
    int i;
    bool flag=false;
    for(i=0;i<bitsSize-1;){//前四次按照普通的循环写的结束条件为bitsSize,然后一直错一直错,搞的我怀疑人生，以为for中三个表达式的执行顺序记错了
        if(bits[i]==1)
            i+=2;
        else
            ++i;
    }
    if(i==bitsSize-1)
        flag=true;
    return flag;
}

136. 只出现一次的数字

这道题的方法涉及到我的知识盲区，位运算的实际运用。但是在理论上我又是懂位运算的。下面我先讲讲我遇到这题时候的一些想法。
1.用额外的空间，且额外空间还未知，因为我不知道最大的数是几
在这里插入图片描述
[]中的数为给定的一组数，蓝色的数组为新开辟的数组。eg:第一位数字为4，则new[4]++;

  1. 先将nums排序，但我想到最快的方法就是快排，也要nlogn。
  2. 第三个当然就是大神的方法咯，位运算！！！
    C语言位运算符：与（&）、或（|）、异或（^）、取反（！）、左移（<<）与右移（>>）。这些运算符只能用于整型操作数，即只能用于带符号或无符号的char,short,int与long类型。
    异或运算具有交换律，也即进行运算时的顺序不会改变结果。[4,1,2,1,2]，4——100（2），1——001（2），2——010（2），100001010001010=100
int singleNumber(int* nums, int numsSize){
    int temp=nums[0],i;
    if(numsSize>1){
        for(i=1;i<numsSize;i++){
            temp^=nums[i];
        }
    }
    return temp;
}

1207. 独一无二的出现次数

  1. 因为arr[i]的范围是给定了的，所以可以用此方法。
  2. count1[]中最多只有arrSize个不为0的数，所以只用给count2[]申请arrSize个空间
  3. count1[]用于记录各个数出现的次数；count2[]用于记录次数的个数
  4. 既然我浪费了空间，不想在排序浪费时间了，所以用了count2[]
    既然我浪费了空间，不想在排序浪费时间了
bool uniqueOccurrences(int* arr, int arrSize){
    int i,j;
    bool temp=true;
    int *count1=(int *)malloc(sizeof(int)*2001);
    memset(count1,0,sizeof(int)*2001);
    int *count2=(int *)malloc(sizeof(int)*(arrSize+1));
    memset(count2,0,sizeof(int)*(arrSize+1));
    for(i=0;i<arrSize;i++){
        if(arr[i]>=0)
            count1[arr[i]]++;
        else
            count1[arr[i]+2000]++;
    }
    for(j=0;j<2001;j++){
        if(count1[j]>0)
            count2[count1[j]]++;
        if(count2[count1[j]]>1)
            temp=false;
    }
    free(count1);
    free(count2);
    return temp;
}

54. 螺旋矩阵

注意墙壁的更新，这道题我自己在DEVc++ 5.11里调试过，然后喃，将二维数组直接传给二级指针是会报错的，原因是因为二维数组的二维是个假概念，在实际存储中都是一维存储，所以会报错。那么改为传指针数组就好拉……

int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
    if(matrixSize==0){//注意考虑为空的情况
        *returnSize=0;
        return 0;
    }     
    int left=0,right=*matrixColSize-1,up=0,down=matrixSize-1,length=matrixSize*(*matrixColSize);
    int i,j,k=0;//i,j交替动
    int *res=(int *)malloc(sizeof(int)*length); 
    while(left<=right&&up<=down&&k<length){//往右 
        i=up,j=left;
        while(j<=right&&k<length){
            res[k]=matrix[i][j];
            k++;
            j++;
        }  
        up++;
        i=up;
        j=right;
        while(i<=down&&k<length){//往下 
            res[k]=matrix[i][j];
            k++;
            i++;
        }
        right--;
        i=down;
        j=right;
        while(j>=left&&k<length){//往左 
            res[k]=matrix[i][j];
            k++;
            j--;
        }
        down--;
        i=down;
        j=left;
        while(i>=up&&k<length){//往上 
            res[k]=matrix[i][j];
            k++;
            i--;
        }
        left++;
        i=up;
        j=left;
    }
    *returnSize=length;
    return res;
}

1. 两数之和

用了一个qsort，c自带的快排函数

struct Node{
     int index;
     int power;
 };
int cmp(const void *a,const void *b){
     return (*(struct Node *)a).power - (*(struct Node *)b).power;//a-b从小到大排序b-a则为从大到小排序
 }
int* twoSum(int* nums, int numsSize, int target, int* returnSize){//双指针走起，哎，需要排序
     int i,l=0,r=numsSize-1;
    int mid=0;
    int *res=(int *)malloc(sizeof(int)*2);
    struct Node *nodes=(struct Node *)malloc(sizeof(struct Node)*numsSize);
    for(i=0;i<numsSize;i++){
        nodes[i].index=i;
        nodes[i].power=nums[i];
    }
    qsort(nodes,numsSize,sizeof(struct Node),cmp);//索引绑定已就绪,排序没起作用
    while(l<r){
        if((nodes[l].power+nodes[r].power)==target){
            res[0]=nodes[l].index;
            res[1]=nodes[r].index;
            *returnSize=2;
            return res;
        }else if((nodes[l].power+nodes[r].power)<target)
            l++;
        else
            r--; 
    }
    *returnSize=2;
    return 0;
}

66. 加一

一遍AC，现在自己解题的时候，也记得要考虑多种情况了。

int* plusOne(int* digits, int digitsSize, int* returnSize){
    int *res=(int *)malloc(sizeof(int)*(digitsSize+1));
    int j=digitsSize-1,carry=1;
    for(j=digitsSize-1;j>=0;j--){
        digits[j]=digits[j]+carry;
        if(digits[j]>=10){
            carry=1;
            digits[j]=digits[j]-10;
        }
        else
            carry=0;
        res[j+1]=digits[j];    
    }
    if(carry==1){//最高位的进位
        res[0]=1;
        *returnSize=digitsSize+1;
    }
    else{
        res=res+1;
        *returnSize=digitsSize;
    }
    return res;
}

1356. 根据数字二进制下 1 的数目排序

排序用了很Low的冒泡

int* sortByBits(int* arr, int arrSize, int* returnSize){//count记录每个数字包含1的个数
    int i,j,temp;
    int *count=(int *)malloc(arrSize*sizeof(int));
    memset(count,0,arrSize*sizeof(int));
    int *arr1=(int *)malloc(arrSize*sizeof(int));
    memset(arr1,0,arrSize*sizeof(int));
    memcpy(arr1,arr,sizeof(int)*arrSize);
    for(i=0;i<arrSize;i++){
        while(arr1[i]>0){
            temp=arr1[i]%2;
            if(temp==1)
                count[i]++;
            arr1[i]=arr1[i]/2;
        }      
    }

    for (i=0;i<arrSize-1;i++){
        bool flag=false;
        for (j=0;j<arrSize-1-i;j++){
            if (count[j] >count[j+1] || (arr[j]>arr[j+1]&&count[j]==count[j+1])){
                
                temp = count[j];
                count[j] = count[j+1];
                count[j+1] = temp;
                
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;

                flag=true;
            }
        }
        if(flag==false)
            break;
    }
    
    (*returnSize)=arrSize;
    free(count);
    free(arr1);
    return arr;
}
}

349. 两个数组的交集

放两个版本，当然是先放最新的咯，看看自己最开始写的，觉得蠢得不行。
所以遇到数组题，先想想排序吧

int cmp(const void *a,const void *b){
     return (*(int *)a) - (*(int *)b);//a-b从小到大排序b-a则为从大到小排序
 }
int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    //写数组题，一般都要先进行排序处理
     if (!nums1 || !nums2) {
        *returnSize = 0;
        return NULL;
    }
    int *res=(int *)malloc(sizeof(int)*(nums1Size<nums2Size? nums1Size:nums2Size));
    int i,j,count=0;//分别用于遍历数组nums1和数组nums2
    qsort(nums1,nums1Size,sizeof(int),cmp);
    qsort(nums2,nums2Size,sizeof(int),cmp);
    for(i=0,j=0;i<nums1Size&&j<nums2Size;){
        if(nums1[i]<nums2[j]){
            i++;
        }else if(nums1[i]>nums2[j]){
            j++;
        }else{
            res[count++]=nums1[i];
            i++;
            j++;
            if(count>1&&res[count-1]==res[count-2])
                count--;
        }
    }
    *returnSize=count;
    res = (int *)realloc(res, count* sizeof(int));//扩内存的时候慎用，这是缩内存，所以还行
    return res;
}

int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    int i,j,k=0,temp;
    if(nums2Size>nums1Size)
        temp=nums2Size;
    else
        temp=nums1Size;
    int *result=(int *)malloc(sizeof(int)*temp);
    memset(result,0,sizeof(int)*temp);
    for(i=0;i<nums1Size;i++){
        for(j=0;j<nums2Size;j++){
            if(nums1[i]==nums2[j]){//没有判断result里的数是否重复
                result[k]=nums1[i];     
                k++;
                break;
            }     
        }
    }
    for (i=0;i<k;i++){ 
        for (j=0;j<k-1-i;j++){
            if (result[j] > result[j+1]){
                temp = result[j];
                result[j] = result[j+1];
                result[j+1] = temp;
            }
        }
    }
    if(k==0){
        (*returnSize)=0;
        return result;
    }else{
        for(i=0,j=1;j<k;j++)//我的天，用的这个删除重复数字的方法，要求是有序的。半天了才发现，呜呜呜
            if(result[i]!=result[j])
                result[++i]=result[j];
     (*returnSize)=i+1;
     return result;
    }
}

26. 删除排序数组中的重复项

这题的思维和上一题的第二版中我用的那个排序方法是一样的

int removeDuplicates(int* nums, int numsSize){//双指针，前提是有序，这题已经有序了
    int i=0,j;//i为新数组的下标
    if(numsSize==0)
        return 0;
    for(j=0;j<numsSize;j++){
        if(nums[j]!=nums[i])
            nums[++i]=nums[j];
    }
    return i+1;
}
Matilda-sweet
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言总结（一维数组、二维数组、字符数组和字符串）
csuft20164442的博客
01-23 12万+
C语言总结第七章、数组一维数组一维数组的定义一维数组的引用一维数组的初始化程序举例二维数组及多维数组二维数组的定义二维数组元素的引用二维数组元素的初始化程序举例字符数组和字符串字符数组 第七章、数组 数组是构造数据类型之一 数组： 有序数据的集合,用数组名标识 元素： 属同一数据类型,用数组名和下标确定 一维数组 一维数组的定义 定义方式： 例： int a[6] 一维数组的引用 1、数组...
找倒数第K个数
easyjsf的专栏
04-29 321
<br />原文地址：http://blog.csdn.net/nokiaguy/archive/2009/01/17/3818966.aspx<br /> <br /> <br />public class Test { static class Node { public int data; public Node nextNode; } //////////////////////////////////////////
o（n）复杂度求倒数第k个数（双指针）
weixin_68375611的博客
03-21 221
1.求中间数 2.求倒数第k个数 * 保持俩指针距离为k
Python 对数据集进行归一化处理并存储为 mat 格式的文件
华仔仔的博客
12-07 9924
在做科研工作时，我们不仅从理论角度分析所提 idea 的种种优势，还需要进行大量的实验，得到的实验效果可以进一步地支撑 idea 的优越性，这样更具有说服力。实验所使用的数据集作为实验的重要组成部分，我们往往需要对拿来的数据集进行数据预处理工作，因为通常使用的数据集往往都是来自各行各业的数据，而一个数据集往往具有多个属性，每个属性的值是否使用的同一量纲，这往往是个问题，如果不是采用同一个量纲进行评价，得到的值放在一起进行运算，是否公正合理？ 因此，归一化处理工作尤为重要，我们要将不同量纲的表达式变为无量纲，
leetcode面试题 02.02. 返回倒数第 k 个节点C
Evernewss的博客
05-05 161
int kthToLast(struct ListNode* head, int k){ struct ListNode *p=head; int i=0; while(p!=NULL){ p=p->next; i++; } k=i-k;i=0; p=head; while(p...
面试题 02.02. 返回倒数第 k 个节点
yeyueyouhun的博客
02-27 129
实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。 自己解 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; ...
数组指针和指针数组
mick_hu的博客
09-17 14万+
首先，理解一下数组指针和指针数组这两个名词： “数组指针”和“指针数组”，只要在名词中间加上“的”字，就知道中心了—— 数组的指针：是一个指针，什么样的指针呢？指向数组的指针。 指针的数组：是一个数组，什么样的数组呢？装着指针的数组。 然后，需要明确一个优先级顺序：()>[]>*，所以： (*p)[n]：根据优先级，先看括号内，则p是一个指针，这个指针指向一个一维数组，数组长...
c语言—数组详解(建议收藏)
热门推荐
Welcome to my blog.
07-06 15万+
文章目录一、一维数组1.一维数组的创建和初始化(1).数组的创建(2).数组的初始化2.一维数组的使用3.一维数组在内存中的存储二、二维数组1.二维数组的创建和初始化(1).二维数组的创建(2).二维数组的初始化2.二维数组的使用3.二维数组在内存中的存储三、数组作为函数参数1.一维数组2.二维数组四、数组指针和指针数组1.指针数组2.数组指针 一、一维数组 1.一维数组的创建和初始化 (1).数组的创建 数组是一组相同类型元素的集合。 数组的创建方式： type_t arr_name [const
js数组常用方法
夏天的博客
03-27 9万+
js数组常用方法还挺多的，如果面试官问你这道题可不要只回答几个哟，那是会扣分的！下面是一篇详细的js数组教程文章
Java数组
qq_63762763的博客
03-27 4万+
一. Java数组01 1.数组的定义 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。 二.Java数组02 1.数组的声明与创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: ``··dataType[] arrayRefVar;//首选的方法 或 dataType arrayRefVar[];//效果相同，但不是首选方法 Java语言使用
数组_matlab数组_
10-02
在MATLAB中，数组是一种非常基础且重要的数据结构，它允许我们存储和处理大量数值数据。MATLAB数组的使用广泛，涵盖了科学计算、数据分析、图像处理等众多领域。本资料包着重介绍了MATLAB中的数组计算，包括数组的...
初识JAVA数组
09-04
【初识JAVA数组】 在Java语言中，数组是一种基本的复合数据类型，它代表了有序数据的集合。数组的关键特性是其元素具有相同的类型，并且可以通过一个数组名称和下标来唯一地确定每个元素的位置。Java支持一维数组和...
js多维数组转一维数组
06-16
js基础代码实现
php 判断数组是几维数组
10-27
1. **一维数组**：数组中的每个元素都是简单值（如整数、字符串等），没有嵌套数组。 2. **多维数组**：数组中的元素可以是另一个数组，即存在嵌套的情况。根据嵌套层数的不同，可以分为二维数组、三维数组等。 ###...
基于Springboot和Vue的图书借还管理系统源码 图书借还管理系统代码（高分毕设）
07-28
图书借还管理系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
C语言内存管理：静态与动态分配的较量
07-28
C语言是一种通用的编程语言，由丹尼斯·里奇（Dennis Ritchie）在20世纪70年代早期于美国电话电报公司（AT&T）的贝尔实验室开发。C语言以其高效性、灵活性和可移植性而闻名，它是一种过程式编程语言，提供了对底层硬件的直接访问能力。 C语言的特点包括： 1. **简洁高效**：C语言的语法简洁，执行效率高，适合编写系统软件。 2. **接近硬件**：C语言提供了对内存地址和位操作的直接控制，使其非常适合硬件级编程。 3. **可移植性**：C语言编写的程序可以在不同的操作系统和硬件平台上编译和运行，具有很好的可移植性。 4. **丰富的库支持**：C语言拥有大量的标准库，如标准输入输出库（stdio.h）、数学库（math.h）等。 5. **结构化编程**：C语言支持结构化编程，允许使用循环、条件判断和函数等控制结构。 6. **指针**：C语言的指针功能强大，可以操作内存地址，实现复杂的数据结构和算法。 7. **编译型语言**：C语言是一种编译型语言，源代码需要通过编译器转换成机器码才能运行。 C语言广泛应用于操作系统（如Unix和Linux）、嵌入式系统、高性能
通讯协议规范-命令包格式
07-28
提供一份通讯协议规范，包含命令包、格式等，在上下位机调试的时候可参考该文档，制定对应的通讯协议。
四足宠物机器狗动态步行规划与仿真.pdf
最新发布
07-28
四足宠物机器狗动态步行规划与仿真
C语言中的数组详解
"C语言数组是构造数据类型的一种，它允许将相同类型的数据组合在一起，方便处理批量数据。数组被定义为使用下标变量的数据类型，能够表示大量同质值。数组分为一维、二维及多维，其中下标的个数决定了数组的维数。一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值