【每日一套题·一起刷好题】· 第四篇

举报
安然无虞 发表于 2022/05/26 22:55:50 2022/05/26
【摘要】 大家好，我是安然无虞。 文章目录 每篇前言 一、选择题1.选择一：全局局部和传值传址2.选择二：转义字符3.选择三：#define和t...

在这里插入图片描述

大家好，我是安然无虞。

文章目录

每篇前言

博客主页：安然无虞

作者认证：2021年博客新星Top2

咱的口号：🌹小比特，大梦想🌹

作者请求：由于博主水平有限，难免会有错误和不准之处，我也非常渴望知道这些错误，恳请铁汁批评斧正。

火爆专栏：蓝桥杯基础算法剖析
欢迎加入：比特社区
在这里插入图片描述

一、选择题

1.选择一：全局局部和传值传址

1、执行下面程序，正确的输出是（ C ）

在这里插入图片描述A:5,7 B:7,5 C:3,8 D:8,3
答案解析：

很明显，这里的局部变量和全局变量重名了，C语言规定，当局部变量和全局变量重名时，优先使用局部变量， 所以执行打印函数时用的是局部变量x,y，也就是在主函数里创建的x,y；
但是，swap函数调用时用的是全局变量，那么程序如果改成这样，答案又会是什么呢？
在这里插入图片描述
这么一修改，答案就选择B了，原因：此时的x, y是全局变量，存放在静态区，调用swap函数交换x,y的值，出了函数作用域，x,y依然存在。
引申：传址调用和传值调用， 已经讲过很多次了，还不是很清楚的铁子可以看看这篇文章哈：编程重点·函数

2.选择二：转义字符

2、以下不正确的定义语句是（ B ）

A:double x[5] = {2.0, 4.0, 6.0, 8.0, 10.0};

B:char c2[] = {'\x10', '\xa', '\8'};

C:char c1[] = {'1','2','3','4','5'};

D:int y[5+3]={0, 1, 3, 5, 7, 9};
答案解析：
本题B选项考查转义字符，\ddd中ddd表示1~3个八进制的数字，\xdd中dd表示2个十六进制的数字， 但八进制数字是0-7，没有8，故B选项中’\8’是错误的，关于转义字符，详情请看：转义字符
本题不小心可能会错选C，对于字符数组c1的定义和初始化虽然存在问题，但是这样初始化也牵强可以，只不过找不到’\0’（结束标志）

3.选择三：#define和typedef

3、test.c文件中包括如下语句，文件中定义的四个变量中，是指针类型的变量为【多选】（ ACD ）

#define INT_PTR int*
typedef int* int_ptr;
INT_PTR a, b;
int_ptr c, d;

   
  
    
   
  • 1
    • 
   
  • 2
    • 
   
  • 3
    • 
   
  • 4
    •

A:a B:b C:c D:d
答案解析：
#define是宏定义，仅仅是直接替换, INT_PTR a, b; 进行宏替换后代码是这样的：int *a, b;这里的int *是a的 类型，b的类型是int，而typedef是把该类型定义一个别名，别名是一个独立的类型了，使用这个 类型创建的变量都是这个类型的！

4.选择四：条件操作符

4、 若给定条件表达式(M)?(a++):(a--)，则其中表达式 M（ C ）

A:和(M==0)等价 B:和(M==1)等价
C:和(M!=0)等价 D:和(M!=1)等价
答案解析：给定条件表达式(M)?(a++):(a–) ，属于(表达式1)? (表达式2): (表达式3)为三目运算符。很简单我就不解释咯，不是很清楚的铁子可以学习我的这篇文章哦：操作符详解

5.选择五：scanf函数

5、有如下定义语句，则正确的输入语句是【多选】（ AB ）

int b;
char c[10];

   
  
    
   
  • 1
    • 
   
  • 2
    •

A:scanf("%d%s",&b,&c); B:scanf("%d%s",&b,c);

C:scanf("%d%s",b,c); D:scanf("%d%s",b,&c);
答案解析：
&c和c两个地址值是一样的，程序的效果相同，但同时也必须把变量b的地址给scanf，数组名和&数组名虽然表示的意义不一样，数组名表示数组首元素的地址，&数组名表示取出整个数组的地址，两个地址值是相同的。

在这里插入图片描述

二、编程设计题

面试题：数组中数字出现的次数

题目链接：数组中数字出现的次数
题目描述：
一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。
示例：
在这里插入图片描述

解题思路

首先，如果题目是这样的：一个数组nums里除某个数字之外，其他数字都出现了两次，请找出这个数字。
那么很简单，我们可以直接给出代码：
在这里插入图片描述
但是本题没有这么简单，方法还是那么个方法，不过需要我们多想一点。我们可以把数组分为两组进行异或，但是必须将这两个数分在不同的组里，而且相同的数字必须在同一组中，这样就可以知道是哪两个数字不同了。
但是难就难在，如何正确对这两个数字进行分组。
具体思路是这样的：

  • 将数组中所有数进行异或， 保存异或结果；
  • 找到异或结果中第一次出现1的位（任意出现1的位也可以）；
  • 按照找到的这个位进行分组即可

OK，思路就是这么个思路，具体请看代码。

代码执行

int* singleNumbers(int* nums, int numsSize, int* returnSize)
{
	//思考：为什么这里我用的是calloc()，而不是malloc()?
   int* ret = (int*)calloc(2, sizeof(int));//注意，malloc()和calloc()的区别
   *returnSize = 2;
   int n = 0;//将n和数组中所有元素相异或，异或结果放到n中
   int i = 0;
   for(i = 0; i < numsSize; i++)
   {
       n ^= nums[i];
   }
   //找异或结果n中第一次出现1的位
   int count = 0;
   //注意运算符的优先级
   while((n & 1 << count) == 0)//异或：相同为0，相异为1
   {
       count++;
   }
   //按照第一次出现1的位置进行分组
   for(i = 0; i < numsSize; i++)
   {
       if(nums[i] & 1 << count)
           ret[0] ^= nums[i];
       else
           ret[1] ^= nums[i];
   }
   return ret;
}

   
  
    
   
  • 1
    • 
   
  • 2
    • 
   
  • 3
    • 
   
  • 4
    • 
   
  • 5
    • 
   
  • 6
    • 
   
  • 7
    • 
   
  • 8
    • 
   
  • 9
    • 
   
  • 10
    • 
   
  • 11
    • 
   
  • 12
    • 
   
  • 13
    • 
   
  • 14
    • 
   
  • 15
    • 
   
  • 16
    • 
   
  • 17
    • 
   
  • 18
    • 
   
  • 19
    • 
   
  • 20
    • 
   
  • 21
    • 
   
  • 22
    • 
   
  • 23
    • 
   
  • 24
    • 
   
  • 25
    • 
   
  • 26
    • 
   
  • 27
    • 
   
  • 28
    •

完整代码：
在这里插入图片描述

面试题：有效的括号

原题链接：有效的括号
题目描述：
在这里插入图片描述示例：
在这里插入图片描述

解题思路

这道题目其实就是考察我们对于栈这个数据结构的认识，属于简单题，不过这里我用C语言来实现，而不是使用C++的STL，看看用C如何该如何解答类似的题目。

代码执行

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;//栈顶
	int capacity;//容量
}Stack;

void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);


//初始化
void StackInit(Stack* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;//特别注意：top初始化成0和-1的区别
	ps->capacity = 0;
}

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

// 入栈
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	//检查是否需要扩容
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newCapacity;
		}
	}
	ps->a[ps->top] = data;
	ps->top++;

}
// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	//printf("%d ", ps->a[ps->top - 1]);
	ps->top--;
}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}

bool isValid(char * s){
   Stack st;
   StackInit(&st);
   while(*s)
   {
       //左括号，入栈
       if(*s == '[' || *s == '(' || *s == '{')
       {
           StackPush(&st, *s);
           s++;
       }
       //右括号，出栈，进行匹配，不匹配就报错
       else
       {
           if(StackEmpty(&st))
           {
               StackDestroy(&st);
               return false;
           }
           char top = StackTop(&st);
           StackPop(&st);
           if((top == '(' && *s != ')')
           ||(top == '[' && *s != ']')
           ||(top == '{' && *s != '}'))
           {
               StackDestroy(&st);//注意哦，在返回之前，要销毁栈，防止造成内存泄漏
               return false;
           }
           else
           {
               s++;
           }
           
       }
   }
  
   //判断特殊情况,如果栈不空，说明栈里面剩有左括号
   // if(StackEmpty(&st))
   // {
   //     StackDestroy(&st);
   //     return true;
   // }
   // else
   // {
   //     StackDestroy(&st);
   //     return false;
   // }

   //可简化
   bool ret = StackEmpty(&st);
   StackDestroy(&st);
   return ret;
}

   
  
    
   
  • 1
    • 
   
  • 2
    • 
   
  • 3
    • 
   
  • 4
    • 
   
  • 5
    • 
   
  • 6
    • 
   
  • 7
    • 
   
  • 8
    • 
   
  • 9
    • 
   
  • 10
    • 
   
  • 11
    • 
   
  • 12
    • 
   
  • 13
    • 
   
  • 14
    • 
   
  • 15
    • 
   
  • 16
    • 
   
  • 17
    • 
   
  • 18
    • 
   
  • 19
    • 
   
  • 20
    • 
   
  • 21
    • 
   
  • 22
    • 
   
  • 23
    • 
   
  • 24
    • 
   
  • 25
    • 
   
  • 26
    • 
   
  • 27
    • 
   
  • 28
    • 
   
  • 29
    • 
   
  • 30
    • 
   
  • 31
    • 
   
  • 32
    • 
   
  • 33
    • 
   
  • 34
    • 
   
  • 35
    • 
   
  • 36
    • 
   
  • 37
    • 
   
  • 38
    • 
   
  • 39
    • 
   
  • 40
    • 
   
  • 41
    • 
   
  • 42
    • 
   
  • 43
    • 
   
  • 44
    • 
   
  • 45
    • 
   
  • 46
    • 
   
  • 47
    • 
   
  • 48
    • 
   
  • 49
    • 
   
  • 50
    • 
   
  • 51
    • 
   
  • 52
    • 
   
  • 53
    • 
   
  • 54
    • 
   
  • 55
    • 
   
  • 56
    • 
   
  • 57
    • 
   
  • 58
    • 
   
  • 59
    • 
   
  • 60
    • 
   
  • 61
    • 
   
  • 62
    • 
   
  • 63
    • 
   
  • 64
    • 
   
  • 65
    • 
   
  • 66
    • 
   
  • 67
    • 
   
  • 68
    • 
   
  • 69
    • 
   
  • 70
    • 
   
  • 71
    • 
   
  • 72
    • 
   
  • 73
    • 
   
  • 74
    • 
   
  • 75
    • 
   
  • 76
    • 
   
  • 77
    • 
   
  • 78
    • 
   
  • 79
    • 
   
  • 80
    • 
   
  • 81
    • 
   
  • 82
    • 
   
  • 83
    • 
   
  • 84
    • 
   
  • 85
    • 
   
  • 86
    • 
   
  • 87
    • 
   
  • 88
    • 
   
  • 89
    • 
   
  • 90
    • 
   
  • 91
    • 
   
  • 92
    • 
   
  • 93
    • 
   
  • 94
    • 
   
  • 95
    • 
   
  • 96
    • 
   
  • 97
    • 
   
  • 98
    • 
   
  • 99
    • 
   
  • 100
    • 
   
  • 101
    • 
   
  • 102
    • 
   
  • 103
    • 
   
  • 104
    • 
   
  • 105
    • 
   
  • 106
    • 
   
  • 107
    • 
   
  • 108
    • 
   
  • 109
    • 
   
  • 110
    • 
   
  • 111
    • 
   
  • 112
    • 
   
  • 113
    • 
   
  • 114
    • 
   
  • 115
    • 
   
  • 116
    • 
   
  • 117
    • 
   
  • 118
    • 
   
  • 119
    • 
   
  • 120
    • 
   
  • 121
    • 
   
  • 122
    • 
   
  • 123
    • 
   
  • 124
    • 
   
  • 125
    • 
   
  • 126
    • 
   
  • 127
    • 
   
  • 128
    • 
   
  • 129
    • 
   
  • 130
    • 
   
  • 131
    • 
   
  • 132
    • 
   
  • 133
    • 
   
  • 134
    • 
   
  • 135
    • 
   
  • 136
    • 
   
  • 137
    • 
   
  • 138
    • 
   
  • 139
    • 
   
  • 140
    • 
   
  • 141
    • 
   
  • 142
    • 
   
  • 143
    • 
   
  • 144
    • 
   
  • 145
    • 
   
  • 146
    • 
   
  • 147
    •

之所以特意加上这道题目，为的就是说明用C语言的一部分缺陷，需要自己造轮子，远远没有面向对象语言用起来舒服，使用C++语言，只需要四五十行代码即可，在实现后面高阶数据结构时，C语言是不行的。不过你可能有疑问，为什么不包含头文件，因为这是接口型题目，可认为系统会自动给我们包含上。
完整代码：
在这里插入图片描述
在这里插入图片描述

三、遇见安然遇见你，不负代码不负卿。

码字不易，求个三连。

在这里插入图片描述

文章来源: bit-runout.blog.csdn.net，作者：安然无虞，版权归原作者所有，如需转载，请联系作者。

原文链接：bit-runout.blog.csdn.net/article/details/123761292

【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
数据结构 面向对象编程
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入