C语言：选择+编程（每日一练Day6）

不念不忘少年蓝@ 2023-10-15 08:18 106阅读 0赞

## ![55f0f6eb5fef45b8b31fc561c321cc87.png][] ##

**目录**

编辑选择题：

题一：

题二：

题三：

题四：

题五：

编程题：

题一：至少是其他数字两倍的最大数

思路一：

思路二：

题二：两个数组的交集

思路一：

本人实力有限可能对一些地方解释和理解的不够清晰，可以自己尝试读代码，或者评论区指出错误，望海涵！

感谢大佬们的一键三连！ 感谢大佬们的一键三连！ 感谢大佬们的一键三连！

--------------------

## 选择题：  ##

### 题一： ###

> **1、**以下叙述中**正确的是**（ ）  
> **A: 只能在循环体内和switch语句体内使用break语句**  
> **B:** 当break出现在循环体中的switch语句体内时，其作用是跳出该switch语句体，并中止循环体的执行  
> **C:** continue语句的作用是：在执行完本次循环体中剩余语句后，中止循环  
> **D:** 在while语句和do-while语句中无法使用continue语句

> **答案解析：**
> 
>  break语句通常用在循环语句和switch语句中。当break用于switch语句中时，可使程序跳出switch而执行switch以后的语句；当break语句用于do-while、for、while循环语句中时，可使程序终止循环而执行循环后面的语句，即满足条件时便跳出循环。continue语句的作用是跳过循环体中剩余的语句而强行执行下一次循环。B、C和D三个选项中均有错误。因此A选项正确。

### 题二： ###

> **2、**下列 for **循环的次数**为（ ）  
> for(int i = 0 ; i || i++ < 5;);

> **A:** 0  **B:** 5  **C:** 1 **D: 无限**

> **答案解析：**
> 
>  逻辑或运算如果前表达式为真，后表达式不计算，第一次循环时i为0，执行i++，第二次循环时i为1，是个真值，不再执行i++，也就死循环了。

### 题三： ###

> **3、**以下描述中**正确**的是（ ）  
> **A:** 由于do-while循环中循环体语句只能是一条可执行语句，所以循环体内不能使用复合语句  
> **B:** do-while循环由do开始，用while结束，在while(表达式)后面不能写分号  
> **C: 在do-while循环体中，不一定要有能使while后面表达式的值变为零("假")的操作**  
> **D:** do-while循环中，根据情况可以省略while

> **答案解析：**
> 
>  do-while循环中的循环体通常都是复合语句代码块，A错误，while(表达式)后面要写分号，B错误，while不能省，D错误。

### 题四： ###

> **4、**设函数 fun 和实参数组的说明是如下形式，则对函数的调用语句中，**正确**的是（ ）  
> void fun(char ch,float x\[\]);  
> float a\[10\];

> **A:**fun("asd" , a\[\]);  **B:**fun('x' , A); 
> 
> **C:**fun('68' , 2.8);  **D:fun(32 , a);**

> **答案解析：**
> 
>  A选项数组传参只需要写数组名就行，a\[\]时错误的，B选项第二个参数写成了大写，错了。C选项第二个参数是浮点数，但是fun函数的第二参数是数组不匹配，fun函数参数x需要传一个数组或者float \*指针，只有D选项的形式是正确的。

### 题五： ###

> **5、**在C语言中，一个函数不写返回值类型，**默认返回值类型**为（）
> 
> **A:int****B:**char **C:**void  **D:**都不是

> **答案解析：**
> 
>  一个函数不写返回值类型，默认的返回类型是int，但不提倡这么做。

## 编程题： ##

### 题一：至少是其他数字两倍的最大数 ###

[747. 至少是其他数字两倍的最大数 - 力扣（LeetCode）][747. _ - _LeetCode]

![0064f20aaeb84b6fb40971f3d1a1840a.png][]

>  **示例：**
> 
>     输入：nums = [3,6,1,0]
>     输出：1
>     解释：6 是最大的整数，对于数组中的其他整数，6 至少是数组中其他元素的两倍。6 的下标是 1 ，所以返回 1 。

#### 思路一： ####

**排序查找法：**

**第一步：将原数组拷贝一份**，然后直接将**数组按升序排序**；

**第二步：****判断倒数第一位是不是倒数第二位的两倍**，**不是**：直接返回；**是**：记录最后一位的值；

**第三步：**然后**遍历原数组找到下标返回。**

//比较函数升序
    int my_cmp(const void* p1,const void* p2)
    {
        return *(int*)p1 - *(int*)p2;
    }
    
    int dominantIndex(int* nums, int numsSize)
    {
        if(numsSize == 1)
        {
            return -1;
        }
        int num[1000] = {0};
        //拷贝一份到num中
        memcpy(num,nums,sizeof(nums[0])*numsSize);
        //将num数组的元素升序排序
        qsort(num,numsSize,sizeof(nums[0]),my_cmp);
        //比较后两个是否满足题目条件
        if(num[numsSize-1] >= num[numsSize-2]*2)
        {
            //记录最大元素
            int count = num[numsSize-1];
            //查找最大元素
            for(int i = 0;i < numsSize;i++)
            {
                if(nums[i] == count)
                {
                    return i;
                }
            }
        }
        return -1;
    }

#### 思路二： ####

**下标比较法：**

**第一步：**分别从用来找**次小值**a= -1 ，用来找**最大值**b= 0 下标开始遍历数组；

**第二步：**如果当前遍历过程中的**值比下标“ b ”的值大**，那么**a记录b和b记录当前最大值**，当当前遍历值比**b下标值小或者下标不在数组中**，就将当前**遍历值给a**，通过循环达到**a为次小值**，**b为最大值；**

**第三步：**然后**判断是否为两倍**，是输出b，不是则输出“-1”。

int dominantIndex(int* nums, int numsSize)
    {
        if(numsSize == 1) 
            return 0;
        int a = -1
        int b = 0;
        for(int i = 1; i < numsSize; i++)
        {
            if (nums[i] > nums[b]) 
            {
                a = b; b = i;
            } 
            else if (a == -1 || nums[i] > nums[a]) 
            {
                a = i;
            }
        }
        return nums[b] >= nums[a] * 2 ? b : -1;
    }

### 题二：两个数组的交集 ###

[349. 两个数组的交集 - 力扣（LeetCode）][349. _ - _LeetCode]

![e390463cc1d3402a87cc4b79b85e127d.png][]

####  思路一： ####

**第一步：**首先分别将**两个数组按升序排列**，开辟**足够容纳交集大小的数组tmp；**

**第二步：**同时**遍历两个数组**：只要**任意一个数组遍历结束，就结束**，当数组**值相同时**，**第一次放数据或者不重复，则将数据存放到tmp数组中**，**否则：数组1值比数组2值小，数组1下标增加，反之数组2下标增加**，循环操作，直到一个数组遍历结束；

**第三步：**然后**返回tmp数组。**

//升序排列
    int my_cmp(const void* p1,const void* p2)
    {
        return *(int*)p1 - *(int*)p2;
    }
    
    int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize)
    {
        //分别将两个数组按升序排列
        qsort(nums1,nums1Size,sizeof(nums1[0]),my_cmp);
        qsort(nums2,nums2Size,sizeof(nums1[0]),my_cmp);
        //开辟足够容纳交集大小的数组
        int* tmp = (int*)malloc(sizeof(nums1[0])*(nums1Size + nums2Size));
        *returnSize = 0;
        //遍历两个数组的下标
        int s1 = 0;
        int s2 = 0;
        //只要任意一个数组遍历结束，就结束
        while(s1 < nums1Size && s2 < nums2Size)
        {
            //数组值相同
            if(nums1[s1] == nums2[s2])
            {
                //保证唯一性
                if(!(*returnSize) || tmp[(*returnSize)-1] != nums1[s1])
                {
                    tmp[(*returnSize)++] = nums1[s1];
                }
                s1++;
                s2++;
            }
            //数组1值比数组2值小，数组1下标增加，反正数组2下标增加
            else if(nums1[s1] < nums2[s2])
            {
                s1++;
            }
            else
            {
                s2++;
            }
        }
        return tmp;
    }

## 本人实力有限可能对一些地方解释和理解的不够清晰，可以自己尝试读代码，或者评论区指出错误，望海涵！ ##

## 感谢大佬们的一键三连！ 感谢大佬们的一键三连！ 感谢大佬们的一键三连！ ##

![c90de1178d0345148d109f22b2169307.jpeg][]

[55f0f6eb5fef45b8b31fc561c321cc87.png]: https://img-blog.csdnimg.cn/55f0f6eb5fef45b8b31fc561c321cc87.png
[747. _ - _LeetCode]: https://leetcode.cn/problems/largest-number-at-least-twice-of-others/description/
[0064f20aaeb84b6fb40971f3d1a1840a.png]: https://img-blog.csdnimg.cn/0064f20aaeb84b6fb40971f3d1a1840a.png
[349. _ - _LeetCode]: https://leetcode.cn/problems/intersection-of-two-arrays/description/
[e390463cc1d3402a87cc4b79b85e127d.png]: https://img-blog.csdnimg.cn/e390463cc1d3402a87cc4b79b85e127d.png
[c90de1178d0345148d109f22b2169307.jpeg]: https://img-blog.csdnimg.cn/c90de1178d0345148d109f22b2169307.jpeg