第2章算法——程序的灵魂
程序=算法+数据结构
什么是算法？_拉杆给油不要慌的博客-CSDN博客_算法
算法（algorithm）是解决一系列问题的清晰指令，也就是，能对一定规范的输入，在有限的时间内获得所要求的输出。 6是解决做什么和怎么做的问题
简单来说，算法就是解决一个问题的具体方法和步骤。算法是程序的灵魂。
程序：（1）对数据的描述。 在程序中要制定用到哪些数据，以及这些数据的组织形式。这也是大名鼎鼎的数据结构（我还在期待着马上能啃这块）
对操作的描述。 要求计算机进行操作的步骤。（算法）
如何得到结构化的程序：
自顶向下
逐步细化
模块化设计
结构化编码
算法的分类：
这块还在学习思考，期待未来我可以补上这一块，谈一谈我自己的看法和鄙见（希望不会咕咕咕太久）
十大基本算法介绍__陌默的博客-CSDN博客_算法
1、冒泡排序
2、选择排序
3、插入排序
4、希尔排序
5、归并排序
6、快速排序
7、堆排序
8、计数排序
9、桶排序
10、基数排序
算法的特征：
一个算法应该具有以下五个重要的特征：
有穷性
（Finiteness）
算法的有穷性是指算法必须能在执行有限个步骤之后终止；
确切性
(Definiteness)
算法的每一步骤必须有确切的定义；
输入项
(Input)
一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件；
输出项
(Output)
一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的；
可行性
(Effectiveness)
算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步骤，即每个计算步骤都可以在有限时间内完成（也称之为有效性）。
第二章课后答案：
C程序设计第五版谭浩强课后答案 第二章答案_月已满西楼的博客-CSDN博客_c语言程序设计谭浩强第五版第二章课后答案
1. 什么是算法？试从日常生活中找3个例子，描述它们的算法
算法：简而言之就是求解问题的步骤，对特定问题求解步骤的一种描述。
比如生活中的例子：
考大学
首先填报志愿表、交报名费、拿到准考证、按时参加考试、收到录取通知书、按照日期到指定学校报到。
去北京听演唱会
首先在网上购票、然后按时坐车到北京，坐车到演唱会会场。
把大象放进冰箱
先打开冰箱门，然后将大象放进冰箱，关冰箱。
2. 什么叫结构化的算法？为什么要提倡结构化的算法？
结构化算法：由一些顺序、选择、循环等基本结构按照顺序组成，流程的转移只存在于一个基本的范围之内。
结构化算法便于编写，可读性高，修改和维护起来简单，可以减少程序出错的机会，提高了程序的可靠性，保证了程序的质量，因此提倡结构化的算法。
3. 试述3种基本结构的特点，请另外设计两种基本结构(要符合基类结构的特点)。
结构化程序设计方法主要由以下三种基本结构组成：
顺序结构：顺序结构是一种线性、有序的结构，它依次执行各语句模块
选择结构：选择结构是根据条件成立与否选择程序执行的通路。
循环结构：循环结构是重复执行一个或几个模块，直到满足某一条件位置
重新设计基本结构要满足以下几点：
只有一个入口
只有一个出口
结构内的每一部分都有机会执行到
结构内不存在死循环
第二章目录回顾：
2.1程序=算法+数据结构15
2.2什么是算法16
2.3简单的算法举例17
2.4算法的特性20
2.5怎样表示一个算法21
2.5.1用自然语言表示算法21
2.5.2用流程图表示算法21
2.5.3三种基本结构和改进的流程图25
2.5.4用N-S流程图表示算法28
2.5.5用伪代码表示算法31
2.5.6用计算机语言表示算法32
2.6结构化程序设计方法33
第3章最简单的C程序设计——顺序程序设计
计算物体自由下落的距离
一个物体从 100m 的高空自由落下，编写程序，求它在前 3s 内下落的垂直距离(结果保留2位小数)。设重力加速度为10米/秒^2。
#include <stdio.h>
int main(void)
{
double height;
height=0.5 * 10 * 3* 3; /*---------*/
printf("height = %.2f\n", height);
}
阶梯电价
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
为了提倡居民节约用电，某省电力公司执行"阶梯电价"，安装一户一表的居民用户电价分为两个"阶梯"：月用电量50千瓦时以内的，电价为0.53元/千瓦时；超过50千瓦时的用电量，电价上调0.05元/千瓦时。
输入用户的月用电量e(千瓦时)，计算并输出该用户应支付的电费(元)，结果保留2位小数。
输入输出示例：括号内是说明
输入
2 (repeat=2)
10 (e=10)
100 (e=100)
输出
cost = 5.30
cost = 55.50
#include <stdio.h>
int main(void)
{
int repeat, ri;
double cost, e;
scanf("%d", &repeat);
for(ri = 1; ri <= repeat; ri++){
scanf("%lf", &e);
if(e<=50) cost=e*0.53;
else cost=0.53*50+(e-50)*0.58;
/*---------*/
printf("cost = %.2f\n", cost);
}
}
求一元二次方程的根
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入参数a,b,c，求一元二次方程a*x*x＋b*x＋c＝0的根，结果保留2位小数。
输出使用以下语句：
printf("参数都为零，方程无意义!\n");
printf("a和b为0，c不为0，方程不成立\n");
printf("x = %0.2f\n", -c/b);
printf("x1 = %0.2f\n", (-b+sqrt(d))/(2*a));
printf("x2 = %0.2f\n", (-b-sqrt(d))/(2*a));
printf("x1 = %0.2f+%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
printf("x2 = %0.2f-%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
输入输出示例：括号内为说明
输入：
5 (repeat=5)
0 0 0 (a=0,b=0,c=0)
0 0 1 (a=0,b=0,c=1)
0 2 4 (a=0,b=2,c=4)
2.1 8.9 3.5 (a=2.1,b=8.9,c=3.5)
1 2 3 (a=1,b=2,c=3)
输出：
参数都为零，方程无意义!
a和b为0，c不为0，方程不成立
x = -2.00
x1 = -0.44
x2 = -3.80
x1 = -1.00+1.41i
x2 = -1.00-1.41i
#include <stdio.h>
#include <math.h>
int main(void)
{
int repeat, ri;
double a, b, c, d;
scanf("%d", &repeat);
for(ri = 1; ri <= repeat; ri++){
scanf("%lf%lf%lf", &a, &b, &c);
d=b*b-4*a*c;
if(a==0){
if(b==0){
if(c==0) printf("参数都为零，方程无意义!\n");
else printf("a和b为0，c不为0，方程不成立\n");
}
else printf("x = %0.2f\n", -c/b);
}
else{
if(d>=0){
printf("x1 = %0.2f\n", (-b+sqrt(d))/(2*a));
printf("x2 = %0.2f\n", (-b-sqrt(d))/(2*a));
}
else{
printf("x1 = %0.2f+%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
printf("x2 = %0.2f-%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
}
}
}
}
参考2
#include <stdio.h>
#include <math.h>
int main(void)
{
int repeat, ri;
double a, b, c, d;
scanf("%d", &repeat);
for(ri = 1; ri <= repeat; ri++){
scanf("%lf%lf%lf", &a, &b, &c);
d=b*b-4*a*c;
if(a==0&&b==0&&c==0) printf("参数都为零，方程无意义!\n");
if(a==0&&b==0&&c!=0) printf("a和b为0，c不为0，方程不成立\n");
if(a==0&&b!=0)
printf("x = %0.2f\n", -c/b);
if(a!=0&&d>=0){
printf("x1 = %0.2f\n", (-b+sqrt(d))/(2*a));
printf("x2 = %0.2f\n", (-b-sqrt(d))/(2*a));
}
if(a!=0&&d<0){
printf("x1 = %0.2f+%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
printf("x2 = %0.2f-%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
}
}
}
C语言中反斜杠"\"的意义和用法
C语言中反斜杠"\"的意义和用法_yf夜风的博客-CSDN博客_\
在阅读C语言代码经常可以看到代码中出现反斜杠"\"，不是很明白它的意思，遂对反斜杠"\"的意义和用法进行查询和总结记录：
1. 转义字符
非常常用的一种用法，在反斜杠后面加一个字符，表示一些特定的意思，如：
\n 换行符(LF)
\r 回车(CR) ，相当于键盘上的"Enter"
\t 跳到下一个TAB位置
\0 空字符(NULL)
\' 单引号（撇号）
\" 双引号
\\ 代表一个反斜线字符''\' 等，详细可百度“转义字符”。
例：
a.
printf("Hello World!");
printf("Hello World!");
输出：
Hello World!Hello World!
b.
printf("Hello World!\n");
printf("Hello World!\n");
输出：
Hello World!
Hello World!
2. 继续符
可用于一行的结尾，表示本行与下一行连接起来
C语言中以 ; 作为语句的结束，不以行为单位结束，当一行的内容太长不方便卸载一行时可使用反斜杠"\"作为继续符，分为多行书写
例如：STM32官方库文件"stm32f30x_usart.h"有如下一段：
#define IS_USART_123_PERIPH(PERIPH) (((PERIPH) == USART1) || \
((PERIPH) == USART2) || \
((PERIPH) == USART3))
写成一行意义完全相同：
#define IS_USART_123_PERIPH(PERIPH) (((PERIPH) == USART1) || ((PERIPH) == USART2) || ((PERIPH) == USART3))
在C语言中数据有两种形式：常量和变量
C语言数据类型（超详细）_无念至此的博客-CSDN博客_c语言数据
常量
可以分为
整型常量： 1000，-345等
实型常量：①十进制小数 123.456，-34.45。0.0②12.34e3（代表12.34*10的三次方）——由于在计算机中输入输出无法表示上角或下角，所以以E或e 代表以10为底的指数。
字符常量：①普通字符”a” 代表97（以二进制形式存放）
②转义字符\n等（上面有介绍在此不赘述了）
字符串常量：“boy”“123”（双撇号里可以包含一个字符串，单撇号里只能包含一个字符）
符号常量：用#define指令指定用一个符号名称代表一个常量
#define PI 3.1256 //注意行末没有分号
（学会使用这种方法在程序中提升效率，但不要忘记自己定义的符号常量代表的是什么）
变量
记住一定是先定义后使用
1.什么是变量？
* 变量本质上来说是内存中的一块空间，这块空间"有数据类型"、"有名字"、"有字面值"。
* 变量包含三部分：数据类型、名称、字面值【数据】
* 变量是内存中储存数据的最基本的单元。
2.数据类型的作用？
* 不同的数据有不同的类型，不同的数据类型底层会分配不同大小的空间。
* 数据类型是指导程序在运行阶段应该分配多大的内存空间。
3.变量要求：变量中存储的具体的"数据"必须和变量的"数据类型"一致，当不一致的时候编译报错。
4.声明/定义变量的语法格式：
数据类型 变量名；
5.变量声明之后怎么赋值？
语法格式：
变量名 = 字面值；
要求： 字面值的数据类型必须和变量的数据类型一致
= 等号是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行结束之后赋值给
左边的变量
6.声明和赋值可以放到一起完成。
int i = 10；
7.变量赋值以后，可以重新赋值，变量的值可以变化；
8.有了变量的概念之后，内存空间的得到了重复的使用：
9.通常访问一个变量包括两种访问形式：
*第一种：读取变量中保存的具体数据 get/获取
*第二种：修改变量中保存的具体数据 set/设置
i = 10; //set
System.out.println(i); //get
10.变量在一行上可以声明多个
int a，b，c
11.java中的变量必须先声明，在赋值，才能访问
int i; 程序执行到这里，内存空间并没有开辟出来，变量i并没有初始化。所以没有赋值之前是无法访问
12.在方法体当中的java代码，是遵守自上而下的顺序一次执行的。逐行执行
第一行
第二行
第三行
特点：在第二行的我代码必须完整的结束之后，第三行程序才能执行。
13.在同一个“作用域”当中，变量名不能重名，但是变量可以重新赋值。
变量的作用域
1.什么是作用域？
变量的作用域，其实描述的就是变量的有效范围。
在什么范围之内是可以被访问的，只要出了这个范围该变量就无法访问了
2.变量的作用域只要记住一句话：
出了大括号就不认识了。
关于变量的分类：
根据变量声明的位置来分类：
*局部变量
-在方法体当中声明的变量叫做局部变量
*成员变量
-在方法体外【类体之内】声明的变量叫做成员变量
在不同的作用域当中，变量名是可以相同的
思考：
标识符：
(4条消息) 标识符——C语言基础知识_一抹南伤的博客-CSDN博客
用来对变量，符号常量名，函数，数组类型等命名的有效字符序列统称为标识符（identifier）
例子：sum，average，huangshaozheng，_total（下划线：英文输入模式下shift+-）
Student_name ......(后面定义结构体变量时会很好表示变量的名称)
还要注意CLASS和class并不能表示同一变量，他们是两个不同的变量
数据类型
(4条消息) C语言基本数据类型_今天你debug了嘛？的博客-CSDN博客_c语言数据类型
一、整数类型
1.整型变量
整数类型数据即整型数据，整型数据没有小数部分的数值。整型数据可分为：基本型、短整型、长整型和无符号型四种。
基本型：以int表示。
短整型：以short int表示。
长整型：以long int表示。
无符号型：存储单元中全部二进位用来存放数据本身，不包括符号。无符号型中又分为无符号整型、无符号短整型和无符号长整型，分别以unsigned int，unsigned short和unsigned long表示。
要注意的是，不同的计算机体系结构中这些类型所占比特数有可能是不同的，下面列出的是32位机中整型家族各数据类型所占的比特数。
虽然int与unsigned int所占的位数一样，但int的最高位用作了符号位，而unsigned int的最高位仍为数据位，所以它们的取值范围不同。
若要查看适合当前计算机的各数据类型的取值范围，可查看文件“limits.h”(通常在编译器相关的目录下)，如下是“limits.h”的部分示例。
#define CHAR_BIT 8 /* number of bits in a char */
#define SCHAR_MIN (-128) /* minimum signed char value */
#define SCHAR_MAX 127 /* maximum signed char value */
#define UCHAR_MAX 0xff /* maximum unsigned char value */
#ifndef _CHAR_UNSIGNED
#define CHAR_MIN SCHAR_MIN /* mimimum char value */
#define CHAR_MAX SCHAR_MAX /* maximum char value */
#else
#define CHAR_MIN 0
#define CHAR_MAX UCHAR_MAX
#endif /* _CHAR_UNSIGNED */
#define MB_LEN_MAX 2 /* max. # bytes in multibyte char */
#define SHRT_MIN (-32768) /* minimum (signed) short value */
#define SHRT_MAX 32767 /* maximum (signed) short value */
#define USHRT_MAX 0xffff /* maximum unsigned short value */
#define INT_MIN (-2147483647 - 1) /* minimum (signed) int value */
#define INT_MAX 2147483647 /* maximum (signed) int value */
#define UINT_MAX 0xffffffff /* maximum unsigned int value */
#define LONG_MIN (-2147483647L - 1) /* minimum (signed) long value */
#define LONG_MAX 2147483647L /* maximum (signed) long value */
#define ULONG_MAX 0xffffffffUL /* maximum unsigned long value */
在嵌入式开发中，经常需要考虑的一点就是可移植性的问题。通常，字符是否为有符号数会带来两难的境地，因此，最佳妥协方案就是把存储于int型变量的值限制在signed int和unsigned int的交集中，这可以获得最大程度上的可移植性，同时又不牺牲效率。
2.整型常量
C语言整型数据一般有十进制整数、八进制整数和十六进制整数三种表达形式。说明如下。
十进制整数的表示与数学上的表示相同，例如：
256,-321,0
八进制整数的表示以数字0开头，例如：
0234表示八进制整数(234)8，所对应的十进制数为 。2×82+3×81+4×80=156。
十六进制整数的表示以0x开头，例如：
0×234表示十六进制整数(234)16。（应当注意的是十六进制数前导字符0x，x前面是数字(0)。
在一个整型数据后面加一个字母L或l(小写)，则认为是long int型量。如342L、0L、78L等，这往往用于函数调用中。如果函数的形参为long int型，则要求实参也为long int型，此时需要用342L作实参。
二、实数（浮点）类型
1.实数（浮点）变量
实型变量又可分为单精度(float)、双精度(double)和长双精度(long double)3种。列出的是常见的32位机中实型家族各数据类型所占的比特数。
要注意的是，这里的有效数字是指包括整数部分+小数部分的全部数字总数。
小数部分所占的位(bit)越多，数的精度就越高；指数部分所占的位数越多，则能表示的数值范围就越大。下面程序就显示了实型变量的有效数字位数。
#include<stdio.h>
int main()
{
float a;
double b;
a = 33333.33333;
b = 33333.333333;
printf(" a = %f , b = %lf \n" , a , b );
return 0;
程序执行结果如下：
a=33333.332031 , b=33333.333333
1
可以看出，由于a为单精度类型，有效数字长度为7位，因此a的小数点后4位并不是原先的数据而由于b为双精度类型，有效数字为16位，因此b的显示结果就是实际b的数值。
2.实型（浮点）常量
在C语言程序设计中，实型数据有以下两种表达形式。
十进制数形式。由正负号、数字和小数点组成。如5.734、一0.273、0.8、一224等都是十进制数形式。
指数形式。如546E+3或546E3都代表546×10 3。字母E（或e）之前必须有数字，E(或e)后面的指数必须为整数。
E8、4.6E+2.7、6e、e、9E7.5都是不合法的指数形式；
5.74E-7、-3E+6是合法的指数形式实型常量。
三.字符类型
1.字符变量
字符变量可以看作是整型变量的一种，它的标识符为“char”，一般占用一个名节(8bit)，它也分为有符号和无符号两种，读者完全可以把它当成一个整型变量。当它用于存储字符常量时，实际上是将该字符的ASCⅡ码值(无符号整数）存储到内存单元中。
实际上，一个整型变量也可以存储一个字符常量，而且也是将该字符的ASCH码值（无符号整数）存储到内存单元中。但由于取名上的不同，字符变量则更多地用于存储字符常量。以下一段小程序显示了字符变量与整型变量实质上是相同的。
#include<stdio.h>
int main()
{
char a,b;
int c,d;
/*赋给字符变量和整型变量相同的整数常量*/
a=c=65;
/*赋给字符变量和整型变量相同的字符常量*/
b=d='a';
/*以字符的形式打印字符变量和整型变量*/
printf("char a=%c,int c = %c", a,c);
/*以整数的形式打印字符变量和整型变量*/
printf("char b=%d,int d=%d\n",b,d);
return 0;
程序执行结果如下：
char a=A,int c=A;
char b=97,int d=97;
由此可见，字符变量和整型变量在内存中存储的内容实质是一样的。
2.字符常量
字符常量是指用单引号括起来的一个字符，如：‘a’，‘5’，‘?’ 等都是字符常量。以下是使用字符常量时容易出错的地方，请读者仔细阅读。
字符常量只能用单引号括起来，不能用双引号或其他括号。
字符常量只能是单个字符，不能是字符串。
字符可以是字符集中任意字符。但数字被定义为字符型之后就不能参与数值运算。如’5’和5是不同的。‘5’是字符常量，不能直接参与运算，而只能以其ASCⅡ码值(053)来参与运算。
除此之外，C语言中还存在一种特殊的字符常量——转义字符。转义字符以反斜线“\”开头，后跟一个或几个字符。转义字符具有特定的含义，不同于字符原有的意义，故称“转义”字符。
例如，在前面各例题printí函数的格式串中用到的“\n”就是一个转义字符，其意义是“回车换行”。转义字符主要用来表示那些用一般字符不便于表示的控制代码。
常见的转义字符以及它们的含义。
‘0’ 的ASCII码 48，‘A’ 的ASCII码 65，‘a’ 的ASCCII码 97
C语言中‘a‘和“a“有什么区别?_嵌入式Linux系统开发的博客-CSDN博客_c语言'a'和“a”
四.枚举类型
在实际问题中，有些变量的取值被限定在一个有限的范围内。例如，一个星期内只有7天，一年只有12个月，一个班每周有6门课程等。如果把这些量说明为整型、字符型或其他类型显然是不妥当的。
为此，C语言提供了一种称为枚举的类型。在枚举类型的定义中列举出所有可能的取值，被定义为该枚举类型的变量取值不能超过定义的范围。
枚举类型是一种基本数据类型，而不是一种构造类型，因为它不能再分解为任何基本类型。
枚举类型定义的一般形式如下。
enum 枚举名
{
枚举值表
};
在枚举值表中应罗列出所有可用值，这些值也称为枚举元素。
例如，定义一个枚举类型和枚举变量如下：
enum colorname
{red,yellow,blue,white,black};
enum colorname color;
变量color是枚举类型enum colorname，它的值只能是red、yellow、blue、white例如
下面的赋值合法：
color=red;
color=white;
而下面的赋值则不合法：
color=green;
color=orange;
关于枚举类型有几点说明：
enum是关键字，标识枚举类型，定义枚举类型必须以enum开头。
在定义枚举类型时花括号中的名字称为枚举元素或枚举常量。它们是程序设计者自己指定的，命名规则与标识符相同。这些名字并无固定的含义，只是一个符号，程序设计者仅仅是为了提高程序的可读性才使用这些名字。
枚举元素不是变量，不能改变其值。如下面这些赋值是不对的：
red=8;yellow=9;
但枚举元素作为常量，它们是有值的。从花括号的第一个元素开始，值分别是0、1、2、3、4，这是系统自动赋给的，可以输出。例如：
printf("%d",blue);
输出的值是2。但是定义枚举类型时不能写成：
enum colorname{0,1,2,3,4};
必须用符号red，yellow，……，或其他标识符。
可以在定义类型时对枚举常量初始化：
enum colornmae{red=3,yellow,blue,white=8,black};
此时，red为3，yellow为4，blue为5，white为8，black为9。因为yellow在red之后，red为3，yellow顺序加一，同理black为9。
④枚举常量可以进行比较。例如：
if(color==red) printf("red");
if(color!=black) printf("it is not black!”);
if(color>white) printf(“it is black!”);
它们是按所代表的整数进行比较的。
⑤一个枚举变量的值只能是这几个枚举常量之一，可以将枚举常量赋给一个枚举变量。但不能将一个整数赋给它。例如：
color=black; //正确
color=5;///错误
⑥枚举常量不是字符串，不能用下面的方法输出字符串”red”。
printf("%s",red);
如果想先检查color的值，若是red，就输出字符串"red”，可以这样：
color=red;
if(color==red)
printf("red");
五.指针类型
由于指针需要篇幅过大，我们后期单独介绍。（第八章也会单独介绍指针有关的知识）
（作者也有自己总结别人文章得出的拙见可以用来参考一下）
运算符
C语言的运算符大全_Chshyz的博客-CSDN博客_c语言运算符
C语言中的运算符大全（内附优先级表）_「已注销」的博客-CSDN博客_c语言运算符号
算术优先级：
(4条消息) C语言的算术优先级_Victor_psl的博客-CSDN博客_c语言算术运算符优先级
语言的i运算符包括单目运算符、双目运算符、三目运算符，优先级如下：
第1优先级：各种括号，如()、[]等、成员运算符 . ；
第2优先级：所有单目运算符，如++、--、!、~等；
第3优先级：乘法运算符*、除法运算符/、求余运算符%；
第4优先级：加法运算符+、减法运算符-；
第5优先级：移位运算符<<、>>；
第6优先级：大于运算符>、大于等于运算符>=、小于运算符<、小于等于运算符<=；
第7优先级：等于运算符==、不等于运算符!=；
第8优先级：按位与运算符&；
第9优先级：按位异或运算符^；
第10优先级：按位或运算符|；
第11优先级：逻辑与运算符&&；
第12优先级：逻辑或运算符||；
第13优先级：三目条件运算符 ?: ；
第14优先级：各种赋值运算符，如=、+=、-=、*=、/= 等；
第15优先级：逗号运算, 。
书上原图：
书上第53页++ --多留意
注意赋值时是从右向左的
赋值运算符的左侧就是一个可修改值的“左值”（left value 简写为lvalue）
b=a B=5
整型数据间的赋值按存储单元中的存储形式直接传送，实型数据之间以及整型与实型之间的赋值，是先转换（类型）后赋值。
数据的输入输出
输入2个整数 num1 和 num2，计算并输出它们的和、差、积、商与余数。
输出两个整数的余数可以用 printf("%d %% %d = %d\n", num1, num2, num1%num2);
输入输出示例：括号内是说明
输入
5 3 (num1=5,num2=3)
输出
5 + 3 = 8
5 - 3 = 2
5 * 3 = 15
5 / 3 = 1
5 % 3 = 2
#include <stdio.h>
int main(void)
{
int num1,num2;
/*---------*/
scanf("%d%d",&num1,&num2);
printf("%d + %d = %d\n",num1,num2,num1+num2);
printf("%d - %d = %d\n",num1,num2,num1-num2);
printf("%d * %d = %d\n",num1,num2,num1*num2);
printf("%d / %d = %d\n",num1,num2,num1/num2);
printf("%d % % %d = %d\n",num1,num2,num1%num2);
return 0;
}
求一元二次方程的根
输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：
输入参数a,b,c，求一元二次方程a*x*x＋b*x＋c＝0的根，结果保留2位小数。
输出使用以下语句：
printf("参数都为零，方程无意义!\n");
printf("a和b为0，c不为0，方程不成立\n");
printf("x = %0.2f\n", -c/b);
printf("x1 = %0.2f\n", (-b+sqrt(d))/(2*a));
printf("x2 = %0.2f\n", (-b-sqrt(d))/(2*a));
printf("x1 = %0.2f+%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
printf("x2 = %0.2f-%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
输入输出示例：括号内为说明
输入：
5 (repeat=5)
0 0 0 (a=0,b=0,c=0)
0 0 1 (a=0,b=0,c=1)
0 2 4 (a=0,b=2,c=4)
2.1 8.9 3.5 (a=2.1,b=8.9,c=3.5)
1 2 3 (a=1,b=2,c=3)
输出：
参数都为零，方程无意义!
a和b为0，c不为0，方程不成立
x = -2.00
x1 = -0.44
x2 = -3.80
x1 = -1.00+1.41i
x2 = -1.00-1.41i
#include <stdio.h>
#include <math.h>
int main(void)
{
int repeat, ri;
double a, b, c, d;
scanf("%d", &repeat);
for(ri = 1; ri <= repeat; ri++){
scanf("%lf%lf%lf", &a, &b, &c);
d=b*b-4*a*c;
if(a==0){
if(b==0){
if(c==0) printf("参数都为零，方程无意义!\n");
else printf("a和b为0，c不为0，方程不成立\n");
}
else printf("x = %0.2f\n", -c/b);
}
else{
if(d>=0){
printf("x1 = %0.2f\n", (-b+sqrt(d))/(2*a));
printf("x2 = %0.2f\n", (-b-sqrt(d))/(2*a));
}
else{
printf("x1 = %0.2f+%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
printf("x2 = %0.2f-%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
}
}
}
}
参考2
#include <stdio.h>
#include <math.h>
int main(void)
{
int repeat, ri;
double a, b, c, d;
scanf("%d", &repeat);
for(ri = 1; ri <= repeat; ri++){
scanf("%lf%lf%lf", &a, &b, &c);
d=b*b-4*a*c;
if(a==0&&b==0&&c==0) printf("参数都为零，方程无意义!\n");
if(a==0&&b==0&&c!=0) printf("a和b为0，c不为0，方程不成立\n");
if(a==0&&b!=0)
printf("x = %0.2f\n", -c/b);
if(a!=0&&d>=0){
printf("x1 = %0.2f\n", (-b+sqrt(d))/(2*a));
printf("x2 = %0.2f\n", (-b-sqrt(d))/(2*a));
}
if(a!=0&&d<0){
printf("x1 = %0.2f+%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
printf("x2 = %0.2f-%0.2fi\n", -b/(2*a), sqrt(-d)/(2*a));
}
}
}
%lf：双精度实数
C语言%7.2d、%-7d、%7.2f、%0.2f的含义和区别
(4条消息) C语言%7.2d、%-7d、%7.2f、%0.2f的含义和区别_云小逸的博客-CSDN博客_c语言中0.2f是什么意思
1.%d是输出整形格式，即int型数据
%-7d也是整形，但是输出的时候是左对齐，最少输出7位，不足7位的右端补空格。
%07d中的d代表：十进制有符号整数
7代表：输出的数字的最大宽度，小于这个宽度的数字前面就补空格，大于将按其实际长度输出
0代表：这里同上面的7一起作用，小于这个宽度的数字前面用0来补
2. %7.2f有，表示输出最少7位浮点数，其中小数占两位
%7.2f中的2表示小数位数为2位，7表示最少输出7位，不足的左端补空格，比如123.4567输出就是空格123.46
%0.2 f也可以写成 %.2f 指保留小数点后两位
(1条消息) C语言 基本输入输出函数_pecuyu的博客-CSDN博客_c语言输入输出
(1条消息) C语言中scanf函数用法详解_沧州刺史的博客-CSDN博客_c语言scanf
字符串函数：
(1条消息) C语言中的getchar（）与putchar（）详解_平凡的世界_的博客-CSDN博客_ch=getchar()
Putchar输出 getchar输入
小结：基本数据类型
关键字：
基本数据类型由11个关键字组成：int、long、short、unsigned、char、
float、double、signed、_Bool、_Complex和_Imaginary。
有符号整型：
151有符号整型可用于表示正整数和负整数。
int ——系统给定的基本整数类型。C语言规定int类型不小于16位。
short或short int ——最大的short类型整数小于或等于最大的int类型整
数。C语言规定short类型至少占16位。
long或long int ——该类型可表示的整数大于或等于最大的int类型整数。
C语言规定long类型至少占32位。
long long或long long int ——该类型可表示的整数大于或等于最大的long
类型整数。Long long类型至少占64位。
一般而言，long类型占用的内存比short类型大，int类型的宽度要么和
long类型相同，要么和short类型相同。例如，旧DOS系统的PC提供16位的
short和int，以及32位的long；Windows 95系统提供16位的short以及32位的int
和long。
无符号整型：
无符号整型只能用于表示零和正整数，因此无符号整型可表示的正整数
比有符号整型的大。在整型类型前加上关键字unsigned表明该类型是无符号
整型：unsignedint、unsigned long、unsigned
short。单独的unsigned相当于
unsignedint。
字符类型：
可打印出来的符号（如A、&和+）都是字符。根据定义，char类型表示
一个字符要占用1字节内存。出于历史原因，1字节通常是8位，但是如果要
表示基本字符集，也可以是16位或更大。
char ——字符类型的关键字。有些编译器使用有符号的char，而有些则
使用无符号的char。在需要时，可在char前面加上关键字signed或unsigned来
指明具体使用哪一种类型。
152布尔类型：
布尔值表示true和false。C语言用1表示true，0表示false。
_Bool ——布尔类型的关键字。布尔类型是无符号 int类型，所占用的空
间只要能储存0或1即可。
实浮点类型：
实浮点类型可表示正浮点数和负浮点数。
float ——系统的基本浮点类型，可精确表示至少6位有效数字。
double ——储存浮点数的范围（可能）更大，能表示比 float 类型更多
的有效数字（至少 10位，通常会更多）和更大的指数。
long
long
——储存浮点数的范围（可能）比double更大，能表示比
double更多的有效数字和更大的指数。
复数和虚数浮点数：
虚数类型是可选的类型。复数的实部和虚部类型都基于实浮点类型来构
成：
float _Complex
double _Complex
long double _Complex
float _Imaginary
double _Imaginary
long long _Imaginary
153小结：如何声明简单变量
1.选择需要的类型。
2.使用有效的字符给变量起一个变量名。
3.按以下格式进行声明：
类型说明符 变量名;
类型说明符由一个或多个关键字组成。下面是一些示例：
int erest;
unsigned short cash;
4.可以同时声明相同类型的多个变量，用逗号分隔各变量名，如下所
示：
char ch, init, ans;
5.在声明的同时还可以初始化变量：
float mass = 6.0E24;
位、字节和字
位、字节和字是描述计算机数据单元或存储单元的术语。这里主要指存
115储单元。
最小的存储单元是位（
bit），可以储存0或1（或者说，位用于设
置“开”或“关”）。虽然1位储存的信息有限，但是计算机中位的数量十分庞
大。位是计算机内存的基本构建块。
字节（
byte）是常用的计算机存储单位。对于几乎所有的机器，1字节
均为8位。这是字节的标准定义，至少在衡量存储单位时是这样（但是，C
语言对此有不同的定义，请参阅本章3.4.3节）。既然1位可以表示0或1，那
么8位字节就有256（
2的8次方）种可能的0、1的组合。通过二进制编码（仅
用0和1便可表示数字），便可表示0～255的整数或一组字符（第15章将详细
讨论二进制编码，如果感兴趣可以现在浏览一下该章的内容）。
字（word）是设计计算机时给定的自然存储单位。对于8位的微型计算
机（如，最初的苹果机）， 1个字长只有8位。从那以后，个人计算机字长
增至16位、32位，直到目前的64位。计算机的字长越大，其数据转移越快，
允许的内存访问也更多。
第三章习题答案：
(1条消息) C程序设计谭浩强第五版课后答案 第三章习题答案_月已满西楼的博客-CSDN博客_c语言程序设计第五版第三单元题目
购房从银行贷了一笔款d,准备每月还款额为p,月利率为r,计算多少月能还清。设d为300 000元,p为6000元,r为1%。对求得的月份取小数点后一位,对第2位按四舍五人处理。
提示:计算还清月数m的公式如下:
可以将公式改写为:
C的库函数中有求对数的函数log10,是求以10为底的对数,log( p )表示log p。
题目解析:
该题的关键主要是利用数学函数库中的log函数进行求解，然后月份要求按照小数点后一位进行四舍五入进行处理，只需要在输出时进行格式控制即可。
代码示例:
#include<stdio.h>
#include <math.h>
int main()
{
float d = 300000, p = 6000, r = 0.01, m;
m = log10(p / (p - d*r)) / log10(1 + r);
printf("m = %3.1f\n", m);
return 0;
}
第三章目录回顾：
3.1顺序程序设计举例37
3.2数据的表现形式及其运算39
3.2.1常量和变量39
3.2.2数据类型42
3.2.3整型数据44
3.2.4字符型数据47
3.2.5浮点型数据49
3.2.6怎样确定常量的类型50
3.3运算符和表达式51
3.3.1C运算符52
3.3.2基本的算术运算符52
3.3.3自增(++)、自减(--)运算符53
3.3.4算术表达式和运算符的优先级与结合性53
3.3.5不同类型数据间的混合运算54
3.3.6强制类型转换运算符55
3.4C语句56
3.4.1C语句的作用和分类56
3.4.2最基本的语句——赋值语句58
3.5数据的输入输出64
3.5.1输入输出举例64
3.5.2有关数据输入输出的概念65
3.5.3用printf函数输出数据67
3.5.4用scanf函数输入数据74
3.5.5字符输入输出函数76
第4章选择结构程序设计
(1条消息) if语句—超详解_蒲公英的吴的博客-CSDN博客_if语句
//多分支
if (表达式1)
语句1;
else if (表达式2)3.
语句2;
else
语句3;
在if语句中又包含一个或多个if语句称为if语句的嵌套（nest）
else总是与它上面最近的未配对的if配对
如何避免不是与自己想要的if配对上了呢？
①此时｛｝限定了内嵌if语句的范围因此else与第一个if配对
If（）
｛
If（）语句1
｝
else 语句2
② 由于有外层的else相隔，内嵌的else不会被误认为和外层的if配对，而只能与内嵌的if配对
if（x<0）
y=-1；
else
if（x==0）y=0；
else y=1；
printf（）；
return 0；
*算术符号优先次序*：
由高到低为：！（非）>算术运算符>关系运算符>&&和||>赋值运算符
Switch语句的用法：
显示五级记分制成绩所对应的百分制成绩区间（使用switch）
输入一个正整数 repeat (0<repeat<10)，做 repeat 次下列运算：
输入五级制成绩(A－E)，输出相应的百分制成绩(0－100)区间，要求使用switch语句。
五级制成绩对应的百分制成绩区间为：A(90-100)、B(80-89)、C(70-79)、D(60-69)和E(0-59),如果输入不正确的成绩，显示"Invalid input"。
输出使用以下语句：
printf("90-100\n");
printf("80-89\n");
printf("70-79\n");
printf("60-69\n");
printf("0-59\n");
printf("Invalid input\n");
输入输出示例：括号内是说明
输入
6ABCDEj (repeat=6，输入的五级成绩分别为A、B、C、D、E和无效的字符j)
输出
90-100
80-89
70-79
60-69
0-59
Invalid input (输入数据不合法)
#include <stdio.h>
int main(void)
{
char ch;
int repeat, ri;
scanf("%d", &repeat);
for(ri = 1; ri <= repeat; ri++){
ch = getchar();
switch(ch){
case'A':
printf("90-100\n");
break;
case'B':
printf("80-89\n");
break;
case'C':
printf("70-79\n");
break;
case'D':
printf("60-69\n");
break;
case'E':
printf("0-59\n");
break;
default:
printf("Invalid input\n");
break;
}
}
return 0;
}
显示水果的价格（使用switch）
查询水果的单价。有4种水果，苹果(apples)、梨(pears)、桔子(oranges)和葡萄(grapes)，单价分别是3.00元/公斤，2.50元/公斤，4.10元/公斤和10.20元/公斤。
在屏幕上显示以下菜单(编号和选项)，用户可以连续查询水果的单价，当查询次数超过5次时，自动退出查询；不到5次时，用户可以选择退出。
当用户输入编号1～4，显示相应水果的单价(保留1位小数)；输入0，退出查询；输入其他编号，显示价格为0。
输入输出示例：括号内是说明
输入
3 (oranges的编号)
0 (退出查询)
输出
[1] apples
[2] pears
[3] oranges
[4] grapes
[0] Exit
price = 4.1
[1] apples
[2] pears
[3] oranges
[4] grapes
[0] Exit
#include <stdio.h>
int main(void)
{
int choice, i;
double price;
for(i = 1; i <= 5; i++){
printf("[1] apples\n");
printf("[2] pears\n");
printf("[3] oranges\n");
printf("[4] grapes\n");
printf("[0] Exit\n");
scanf("%d", &choice);
if(choice == 0)
break;
else{
switch (choice){
case 1: price= 3.00; break;
case 2: price=2.50; break;
case 3: price=4.10; break;
case 4: price=10.20; break;
default: price=0; break;
}
printf("price = %0.1f\n", price);
}
}
}
选择结构典型例题：
(1条消息) C语言程序设计第五版 谭浩强 第四章 课后习题 答案_月已满西楼的博客-CSDN博客_c语言第四章课后题答案
1. 什么是算术运算？什么是关系运算？什么是逻辑运算？
【答案解析】
算术运算：
算术运算即“四则运算”，是加法、减法、乘法、除法、乘方、开方等几种运算的统称。
其中加减为一级运算，乘除为二级运算，乘方、开方为三级运算。在一道算式中，如果有多级运算存在，则应先进行高级运算，再进行低一级的运算。
C语言中的算熟运算符包括：+、-、*、/、++、--、% 等种类。
如果只存在同级运算；则从左至右的顺序进行；如果算式中有括号，则应先算括号里边，再按上述规则进行计算。
示例：$ (1 + 1)^{2} * 4+5 * 3$
解析：
先进行括号内运算1+1，然后进行乘方运算得到结果4.
接下来与4相乘，得到结果16
因为乘法优先级大于加法，因此先进行5*3，得到结果15
最终相加得到结果31
结果：31
关系运算：
关系的基本运算有两类：一类是传统的集合运算（并、差、交等），另一类是专门的关系运算（选择、投影、连接、除法、外连接等），而在C语言中，关系运算通常被认为是比较运算，将两个数值进行比较，判断比较结果是否符合给定的条件。
常见的关系运算符包括：<、<=、>、>=、==、!= 等种类。
其中，前4种关系运算符(<、<=、>、>= )的优先级别相同，后2种(==、!=)也相同。而前4种高于后2种。
例如, > 优先于 == 。而 > 与 < 优先级相同。
并且，关系运算符的优先级低于算术运算符，关系运算符的优先级高于赋值运算符(=)。
逻辑运算：
在逻辑代数中，有与、或、非三种基本逻辑运算。表示逻辑运算的方法有多种，如语句描述、逻辑代数式、真值表、卡诺图等。而在C语言中，逻辑运算通常用于使用逻辑运算符将关系表达式或其它逻辑量连接起来组成逻辑表达式用来测试真假值。
常见的逻辑运算符包括：&&、||、! 等种类
&&： 与是双目运算符，要求有两个运算对象，表示两个运算对象都成立，则结果为真，否则结果为假。
例如：(a<b) && (x>y)，表示(a<b)和(x>y)同时成立则为真。
||：是双目运算符，要求有两个运算对象，表示两个运算对象只要任意一个成立，则结果为真，否则结果为假。
例如：(a<b) && (x>y)，表示(a<b)和(x>y)两个对象中任意一个成立则结果为真。
**!**是单目运算符，只要求有一个运算对象，表示取运算对象反义，运算对象为真则结果为假，运算对象结果为假则结果为真。
例如：!(a>b)，表示(a>b)成立时结果为假，不成立时结果为真。
若在一个逻辑表达式中包含多个逻辑运算符，则优先次序为： ! > && > ||。当然若一个逻辑表达式中包含括号括起来的子逻辑，则优先括号内的子逻辑判断。
示例：
(1>2)||(2>3)&&(4>3) 结果为0
!(1>2)||(2>3)&&(4>3)结果为1
注：&&优先级大于||，((2>3)&&(4>3))无法同时成立，则结果为假，然后与(1>2)结果进行逻辑或运算，两者都为假因此第一次结果为假。 而第二次!优先级最高，先对(1>2)的结果取逻辑非，得到结果为真，因此结果为真。
2. C语言中如何表示“真”和“假”?系统如何判断一个量的“真”和“假”?
答案：
在C语言中逻辑常量只有两个，即0和1，用来表示两个对立的逻辑状态，其中0表示假，1表示真。
逻辑变量与普通代数一样，也可以用字母、符号、数字及其组合成为的逻辑表达式表示。
对于系统来说，判断一个逻辑量的值时，系统会以0作为假，以非0作为真。例如3&&5的值为真，系统给出3&&5的值为1。
3. 写出下面各逻辑表达式的值。设a=3,b=4,c=5。
（1）a + b > c && b == c
（2）a || b + c && b - c
（3）!(a > b) && !c || 1
（4）!(x = a) && (y = b) && 0
（5）!(a + b) + c - 1 && b + c / 2
解题思路：
关系运算符的优先级高于赋值运算符，但是低于算术运算符；
&&表示两边条件同为真则成立，||表示两边条件任意一个为真则成立，!取条件反义。
逻辑运算符优先级： ! > && > ||
有括号优先括号。
有3个整数a, b, c，由键盘输入，输出其中最大的数。
解题思路： 每个数字两两与剩余两个数字进行比较，若比剩下的两个数大则最大，例如：a>b && a>c则a是最大的
答案：
#include <stdio.h>
int main()
{
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (a == b && a == c) {
printf("Three numbers are equal\n");
}else if (a == b && a > c) {
printf("a and b are the largest number\n", a);
}else if (a == c && a > b) {
printf("a and c are the largest number\n", a); //相等的情况不能忘！！！
}else if (b == c && b > a) {
printf("c and b are the largest number\n", a);
}else if (a > b && a > c) {
printf("a=%d is the largest number\n", a);
}else if (b > a && b > c) {
printf("b=%d is the largest number\n", b);
}else {
printf("c=%d is the largest number\n", c);
}
return 0;
}
给出一百分制成绩,
要求输出成绩等级’A’、‘B’、‘C’、‘D’、‘E’。 90分以上为’A’,8089分为’B’,7079分为’C’ ,60~69分为’D’ ,60分以下为’E’。
解题思路： 根据不同的阶段成绩区间作为成绩的判断条件，属于哪个区间则输出对应等级即可
答案：
#include <stdio.h>
int main()
{
int score;
printf("enter score:");
scanf_s("%d", &score);
if (score >= 90) {
printf("A\n");
}else if (score >= 80 && score < 90) {
printf("B\n");
}else if (score >= 70 && score < 80) {
printf("C\n");
}else if (score >= 60 && score < 70) {
printf("D\n");
}else {
printf("E\n");
}
system("pause");
return 0;
}
给一个不多于5位的正整数,
要求:①求出它是几位数;②分别输出每一位数字;③按逆序输出各位数字，例如原数为321,应输出123。
①求出它是几位数;
解题思路： 大于10000就是5位，否则大于1000就是四位，否则大于100是三位…
答案：
#include <stdio.h>
int main()
{
int num;
printf("enter num:");
scanf_s("%d", &num);
if (num > 99999 || num < 0) {
printf("请输入0~99999之间的正数\n");
return -1;
}
if (num >= 10000) {
printf("5\n");
}else if (num >= 1000) {
printf("4\n");
}else if (num >= 100) {
printf("3\n");
}else if (num >= 10) {
printf("2\n");
}else {
printf("1\n");
}
system("pause");
return 0;
}
②分别输出每一位数字;
解题思路： 99999除以10000则输出9；9999除以1000则输出9，…
答案：
#include <stdio.h>
int main()
{
int num;
printf("enter num:");
scanf_s("%d", &num);
if (num > 99999 || num < 0) {
printf("请输入0~99999之间的数字\n");
return -1;
}
if (num / 10000 > 0) {//取出万位数字
printf("%d ", num / 10000);
}
if (num%10000 >= 1000) {//取余10000则可以取出低四位的数据，除以1000则得到千位的数字
printf("%d ", (num % 10000) / 1000);
}
if (num%1000 >= 100) {//取余1000则可以取出低三位的数据，除以100则得到百位的数字
printf("%d ", (num % 1000) / 100);
}
if (num%100 >= 10) {//取余100则可以取出低两位的数据，除以10则得到十位的数字
printf("%d ", (num % 100) / 10);
}
if (num%10 >= 0) {//取余10则取出个位数字
printf("%d ", num % 10);
}
printf("\n");
system("pause");
return 0;
}
③按逆序输出各位数字，例如原数为321,应输出123。
解题思路： 思路与第二题相同，只不过将整个过程逆序即可
答案：
#include <stdio.h>
int main()
{
int num;
printf("enter num:");
scanf_s("%d", &num);
if (num > 99999 || num < 0) {
printf("请输入0~99999之间的数字\n");
return -1;
}
if (num % 10 >= 0) {
printf("%d ", num % 10);
}
if (num % 100 >= 10) {
printf("%d ", (num % 100) / 10);
}
if (num % 1000 >= 100) {
printf("%d ", (num % 1000) / 100);
}
if (num % 10000 >= 1000) {
printf("%d ", (num % 10000) / 1000);
}
if (num / 10000 > 0) {
printf("%d ", num / 10000);
}
printf("\n");
system("pause");
return 0;
}
课后第十题：
企业发放的奖金根据利润提成。利润I低于或等于100000元的,奖金可提成10%；利润高于100000元，低于200000元(100000<I≤200000)时,低于100000元的部分按10%提成,高于100000元的部分,可提成7. 5%；200000<I≤400000时，低于200000元的部分仍按上述办法提成(下同)。高于200000元的部分按5%提成；400000<<I≤600000元时，高于400000元的部分按3%提成；600000<1≤1000000时,高于600000元的部分按1.5%提成；I>1000000时,超过1000000元的部分按1%提成。从键盘输入当月利润I,求应发奖金总数。要求：(1) 使用if语句编写程序。(2) 使用switch语句编写程序。
(1) 使用if语句编写程序。
解题思路： 先将每一档的最大奖金算出来，在某一个区间时，则那小于这一档的奖金加上多出部分的奖金即可，例如：
先列出100000档的奖金是10000，则180000就是10000 + （180000-100000） * 0.075；列出200000档的奖金是第一档加上多出100000部分的7.5%得到17500，则300000就是17500 + （300000-200000）*0.05；
答案：
#include <stdio.h>
int main()
{
double I, salary = 0;
printf("enter performance:");
scanf_s("%lf", &I);
if (I < 0) {
printf("请输入一个正数\n");
system("pause");
return -1;
}
double salary1 = 100000 * 0.1;//10万的奖金
double salary2 = (200000 - 100000) * 0.075 + salary1;//20万的奖金
double salary3 = (400000 - 200000) * 0.05 + salary2;//40万的奖金
double salary4 = (600000 - 400000) * 0.03 + salary3;//60万的奖金
double salary5 = (1000000 - 600000) * 0.015 + salary4;//100万的奖金
if (I <= 100000) {
salary = I * 0.1;//小于100000按10%提成
}else if (I > 100000 && I <= 200000) {
salary = salary1 + (I - 100000) * 0.075;//多出10万的按比例计算，加上10w的奖金
}else if (I > 200000 && I <= 400000) {
salary = salary2 + (I - 200000) * 0.05;//多出20万的按比例计算，加上20w的奖金
}else if (I > 400000 && I <= 600000) {
salary = salary3 + (I - 400000) * 0.03;//多出40万的按比例计算，加上40w的奖金
}else if (I > 600000 && I <= 1000000) {
salary = salary4 + (I - 600000) * 0.015;//多出60万的按比例计算，加上60w的奖金
}else if (I > 1000000){
salary = salary5 + (I - 1000000) * 0.01;//多出100万的按比例计算，加上100w的奖金
}
printf("salary:%f\n", salary);
system("pause");
return 0;
}
(2) 使用switch语句编写程序。
解题思路： 与第一题思路没有太大差别，区别在于switch语句的case子句中需要是一个常量整数，并且switch中若子句中没有break将循序向下执行，直到遇到break才会跳出switch语句，如果这时候将利润除以10w，则得到09的数字，其中0表示小于10w，1表示介于1020w，2、3表示介于2040w，4、5表示介于4060w，6、7、8、9表示介于60~100w，否则就是大于100w
答案：
#include <stdio.h>
int main()
{
double I, salary = 0;
printf("enter performance:");
scanf_s("%lf", &I);
if (I < 0) {
printf("请输入一个正数\n");
system("pause");
return -1;
}
double salary1 = 100000 * 0.1;//大于100000时0~100000的奖金
double salary2 = (200000 - 100000) * 0.075 + salary1;//大于200000时0~20万的奖金
double salary3 = (400000 - 200000) * 0.05 + salary2;//大于400000时0~40万的奖金
double salary4 = (600000 - 400000) * 0.03 + salary3;//大于600000时0~60万的奖金
double salary5 = (1000000 - 600000) * 0.015 + salary4;//大于1000000时0~100万的奖金
int grade = I / 100000;
switch(grade) {
case 0:
salary = I * 0.1; break;
case 1:
salary = salary1 + (I - 100000) * 0.075; break;
case 2://会顺序执行到下一个break处
case 3:
salary = salary2 + (I - 200000) * 0.05; break;
case 4:
case 5:
salary = salary3 + (I - 400000) * 0.03; break;
case 6:
case 7:
case 8:
case 9:
salary = salary4 + (I - 600000) * 0.015; break;
default:
salary = salary5 + (I - 1000000) * 0.01; break;
}
printf("salary:%f\n", salary);
system("pause");
return 0;
}
第四章目录回顾
4.1选择结构和条件判断83
4.2用if语句实现选择结构85
4.2.1用if语句处理选择结构举例85
4.2.2if语句的一般形式87
4.3关系运算符和关系表达式89
4.3.1关系运算符及其优先次序90
4.3.2关系表达式90
4.4逻辑运算符和逻辑表达式90
4.4.1逻辑运算符及其优先次序91
4.4.2逻辑表达式92
4.5条件运算符和条件表达式94
4.6选择结构的嵌套96
4.7用switch语句实现多分支选择结构99
4.8选择结构程序综合举例102
————————————————
版权声明：本文为CSDN博主「时雨h」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/shaozheng0503/article/details/128450216
