20190805

                                                           // i++与++i，多目运算   if（ ？ ：）  /b  #if 0

数组：属于一种结构数据类型 是一种数据结构
数据类型 名称【整型变量】 使用变量定义数组，则无法被初始化
folat s[10] = {，，，，，，} //{ } 数据可少不可多，多了会越界
未添加数据则默认为随机数 地址小的总是在前，小端排列

	数组的数组名是地址首元素在内存中的地址值       //地址是一个地址值常量
	
数组的越界访问：超过可用的地址访问
				编译器不会报错、报警
	sizeof（a） / sizeof（a[0]）    数组中元素的个数
				
	逆序：
		                                                         交换次数为len/2
	
	
	选择排序算法：                                              每一个合适的位置上放上合适的数    //求极值               //循环相互嵌套
					                                            相互比较  比较次数为（len-1）*len/2         len^2为时间复杂度/
					                                                   算法复杂度（相对而言空间复杂度较低）
					for(i = 0;i < len - 1;++i)
					{
						for(j = i + 1;j < len;++j)
						{
							if(a[i] > a[j])
							{
								int t = a[i];
								a[i] = a[j];
								a[j] = t;
							}
						}
					}			

	冒泡排序算法：                                              两个相邻元素相互比较，小的放前面，大的放后   
							                                             //相互比较次数也为 n*(n-1)/2
					for(j = len - 1;j > 0;--j)                             //倒序
					{  
						for(i = 0;i < j;++i)
						{
							if(a[i] > a[i + 1])
							{
								int t = a[i];
								a[i] = a[i + 1];
								a[i + 1] = t;
							}
						}
					}   
					for (j = 0; j < n - 1; j++)                          //冒泡  正序
                    {    
					    for (i = 0; i < n - 1 - j; i++)                    //每执行一次，最后一个数就确定了位置
                        {
							if(a[i] > a[i + 1])
                            {
                              int t = a[i];
                              a[i] = a[i + 1];
                              a[i + 1] = t;
                            }
                        }
					}
					
					
	插入排序算法：	                                                    //空间复杂度比较高
						for(i = 1;i < len;++i)                           
						{
							j = i;
							t = a[i];
							while(j > 0 && a[j - 1] > t)               //找到最小的，然后排列
								{
								a[j] = a[j - 1];
								--j;
								}
							a[j] = t;
						}                                                  //自插


	二分查找法：       	//注意end的赋值为len-1；
						while(begin <= end)
						{
							mid = (begin + end) / 2;
							if(a[mid] > n)
							{
								end = mid - 1;
							}
							else if(a[mid] < n)
								{
									begin = mid + 1;
								}
								else
								{
									break;
								}
						}

						if(begin <= end)
							{
								printf("found! index = %d, value = %d \n", mid, a[mid]);
							}
						else
							{
								printf("not found!\n");
							}

#if用法:
#if 常量a

…程序段1…
      #else
#if 常量b
　　          …程序段2…
            #else
　　         …程序段3…
　　     #endif

#endif
这里表示，如果常量a为真（非0，随便什么数字，只要不是0），就执行程序段1。当常量a为0，常量b为真时，执行程序段2；
当常量a为0，常量b为0时，执行程序段3；
#if 0 注释代码
#endif if截止
#ifdef 如果定义了标识， 则加入下面的代码
#ifndef 如果没有定义了标识，则加入下面的代码
#if 如果条件成立就加入下面的代码
#else 如果条件不成立就加入下面的代码

转义字符 意义
\b 退格(bs) ，将当前位置移到前一列

\f 换页(ff)，将当前位置移到下页开头

\n 换行(lf) ，将当前位置移到下一行开头

\r 回车(cr) ，将当前位置移到本行开头
\a 响铃(BEL)
\ 代表一个反斜线字符 ‘’
’ 代表一个单引号（撇号）字符
" 代表一个双引号字符
\t 横向跳到下一制表符位置
'\r’是回车，光标回到行首，不换行
'\n’是换行，光标下移一行，不回行首

％d整型输出，％ld长整型输出，

％o以八进制数形式输出整数，

％x以十六进制数形式输出整数，

％u以十进制数输出unsigned型数据(无符号数)。

％c用来输出一个字符，

％s用来输出一个字符串，

％f用来输出实数，以小数形式输出 浮点数是不能定义精度的

％e以指数形式输出实数，

％g根据大小自动选f格式或e格式，且不输出无意义的零

三目运算符，又称条件运算符
格式：a>b?m:n;
功能：判断a>b是否为真，为真执行m，不为真执行n //三目运算，从右向左结合
可理解为： if（a>b）
{
return m;
}
else
{
return n;
}

++i与i++：++i是使用i之前先使i加一.i++是使用i之后再加一

#include"limits.h"
使用INT_MAX == 2147483647
INT_MIN -1
UINT_MAX == 4294967295U
基本的优先级需要记住：
指针最优，单目运算优于双目运算。如正负号。
先算术运算，后移位运算，最后位运算。请特别注意：1 << 3 + 2 & 7等价于 (1 << (3 + 2))&7
逻辑运算最后结合。
同一优先级： ！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符

/bin：存放最常用命令；

/boot：启动Linux的核心文件；
　　/dev：设备文件；
　　/etc：存放各种配置文件；
　　/home：用户主目录；
　　/lib：系统最基本的动态链接共享库；
　　/mnt：一般是空的，用来临时挂载别的文件系统；
　　/proc：虚拟目录，是内存的映射；
　　/sbin：系统管理员命令存放目录；
　　/usr：最大的目录，存许应用程序和文件；
/usr/include：系统头文件；

程序列表：
1.九九乘法表
2.打印数组a中所有元素之和
3.打印数组中最大的元素
4.打印数组中第二大的元素
5.打印数组的逆序列
6利用选择排序法排列一组数组，冒泡，插入法，原地插入法，二分法

头文件：声明函数的原型
库文件：包含函数的实现

man ascll 查看ascll表

字符型变成整型 9 == ‘9’ - ‘0’

while ( s[i] ) == while ( s[i] != 0 ) //非零即为真

字符数组：char s[] = {‘H’,‘I’,’\0’}
= {“HI”}
= “HI”
char s[][100] = {“ahkh”,“akhkh”,“agkah”);字符串需要加{}
putchar（s[i]）; //输出字符
puts （s[i]）; //输出字符串 自带换行符
s[i] = getchar( ); //数入字符
gets （s）; //输入字符串

#include <string.h>
size_t strlen(const char *s); //*s 可以用字符数组名代替
strlen(s);
用%u输出比较合适 // %u无符号整形输出
功能：判断字符串长度

char *gets(char *s) // *s 可用字符型数组名代替
gets（s）; // 输入字符串时，大多使用gets函数

#include <string.h>
char *strcpy(char *dest, const char *src); // 后一个往前一个复制粘贴
strcpy (s,ss); //注意目标文件的大小

#include <string.h>
char *strcat(char *dest, const char *src）; //后一个接到前一个后面。
strcat (s,ss); //注意目标文件的大小

#include <string.h>
int strcmp(const char *s1, const char *s2); // 前后两个比较 返回值为int型
strcmp（s1,s2）; //比较运算时无法使用<>运算符

#include <stdio.h>
int scanf(const char *format, …);
scanf(格式控制符，地址列表)
scanf(%d,&a); //如果在%d之间加入任意符号后，输入时也需加入

a 数组的首地址
a[0] 一维数组的数组名，也是a的首地址
a[][4] 只可以省略前一个（）靠近变量名的。就是取第一行第一个元素的值
&a[0] 是第一行的首地址，从数值上将，没问题，只是数据类型上不一样；

程序列表：1.打印一串字符串
2.大小写字母互相转换
3.判断元音字母的个数 //if 两种 +swich case

大致过程：

定义：使用前定义 不能再函数内部定义函数 只能有一次
声明：已经有了声明 不能放在主函数内部
链接：确定一个函数的位置的过程
xxx.dll 库文件 只编译，未链接

#include <assert.h>
void assert(scalar expression); //断言是否为真，为假则崩溃执行
assert(mouth >=1&&<=12)

函数的传递只是值传递
形参不能改变实参，被调函数无法改变主调函数 如果是指针则可以
函数传参的顺序是自右向左传参

驱动程序时，不建议使用递归调用

栈区：就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。
里面的变量通常是局部变量、函数参数等。一般来讲在32位系统下，堆内存可以达到4G的空间
堆区：new分配的内存块，他们的释放编译器不去管。程序结束后，操作系统会自动回收
long pNumber = (long)malloc(sizeof(long) * 1000000)
使用完后，用delete释放
delete[] pNumnber;
文字常量区：里面存放的是常量，不允许修改
代码区：全局变量和静态变量被分配到同一块内存中
自由存储区：由动态内存等分配的内存块，他和堆是十分相似的，不过它是用free（）来结束自己的生命的。

函数调用数组时，实质是调用数组的首地址。

32位系统中，指针占用四个字节
typedef int INT 更改原数据类型。int 为INT //后续可以用INT表示整形
声明新的类型名，代替原有类型名
与#define 有相似的地方

一、标识符必须先定义再使用
二、在同一作用域内，不得声明同一标识符
三、在不同作用域内，声明的同名标识符互不影响。
四、在具有两个或两个以上具有包含关系的作用域内声明的同名标识符，外层标识符在内层不可见

不包括在{}内的就是全局变量

静态生存期：变量的生存区与函数的运行周期相同。全局变量 //会以位模式清零
函数内部定义的static int i;静态局部变量 //static 在函数调用结束后不消失，保留原值
动态生存期：程序中可以多次创作与销毁 //不会以位模式清零

exrtern int 只声明 ，不定义，不应该对其初始化操作
register 寄存器变量无法取地址，只是建议放在寄存器中
const 只读不写
static int g_t = 10 ;（函数前/全局变量前加static）只能在本.c中使用。无法被其他使用