目录
一 数组
数组：相同类型数据的线性集合。数组的下表以0开始计算，最大长度为数组个数-1 。
一维数组：数组里面的每一个元素类型均相同，然后内存地址连续，数组的每一个元素从0开始编号。
int main()
{
//定义一个数组为qq，指定长度为12个
int qq[12], index;
for (index = 0; index < 11; index++) {
scanf("%d", &qq[index]); //逐个输入手机号
}
//输出手机号
printf("手机号是 \n");
for ( index = 0; index < 11; index++)
{
printf("%d", qq[index]);
}
return 0;
}
一维数组的3种初始化方式：
int a[3] = { 1,3,2 };//指定数组长度并把每个位置都赋值
int b[] = { 3,4,4,5 };//不指定数组长度，自动依据当前元素大小计算数组长度
int c[10] = { 12,44 };//指定数组长度，但是只把部分位置赋值，其余位置默认以0填充
二维数组：特殊的一维数组，每一个数组元素都是一个数组。
二维数组的四种初始化方式：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define PI 3.1415
int main()
{
int a[2][2] = { 1,3,2 ,3};//指定数组长度并把每个位置都赋值；
int b[][2] = { 3,4,4,5 };//为每个数组赋值，省略行下标，指明列下标；
int c[2][2] = { {12,44 },{33,22} };//分行给数组元素赋值
int d[2][2];
a[0][0] = 12; //直接对数组元素赋值
a[0][1] = 19;
//遍历数组
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 2; j++)
{
printf("%d ,", a[i][j]);
}
}
return 0;
}
字符数组
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define PI 3.1415
int main()
{
char a[5]; //定义字符数组
//字符数组的几种初始化方式
a[0] = 'a';
a[1] = 'b'; //引用数组元素并给其赋值
char b[2] = { 's','s' };//逐个字符赋值给每个数组元素
char c[] = { 'q','q' };//定义数组的同时给其初始化
char d[] = { "hello" };//利用字符串赋值
//字符数组的输入和输出可以使用两种格式字符： "%c" ,"%s"
printf("%s", d); //若使用字符串给字符数组赋初值的话，可以直接使用
//若是使用数组的形式给字符数组赋值的话，那么则需要用循环的形式来遍历字符。
for (int i = 0; i < 2; i++)
{
printf("%c", b[i]);
}
//注意： 字符数组在内存中，编译系统会自动给字符数组的末尾加一个标志符号 "\0" ，所以其字符的实际长度是包含结尾标志的。
//计算字符数组的长度
int length = 0; //记录数组长度
int index; //跟踪数组下标
for (index = 0; index < a[index] != '\0'; index++)
{
length++;
}
printf("字符数组的长度是: %d ", length);
return 0;
}数组的排序算法
数组是一组有序数据的组合，这里的有序是指在内存中的连续有序，不是数组元素本身的有序。
1，选择法排序
原理：每次在待排序数组中查找最大或最小的数组元素，将其值与最前面没有进行过排序的数组元素的值互换。由大到小排序应查找最大值，由小到大排序则应查找最小值。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define PI 3.1415
int main()
{
int i, j;
int a[5]; //存储用户输入的数据
int temp;//表示最小的数组元素
int pos;//表示元素的位置
printf("请输入5个数字，为数组的元素赋值：/n");
for (int i = 0; i < 5; i++)
{
printf("a[%d]=", i);
scanf("%d", &a[i]);
}
//使用选择排序法对数组元素从小到大排序
for (int i = 0; i < 4; i++) //表示前4个数组元素
{
temp = a[i];//假设当前元素为最小值
pos = i;//记录最小元素的位置
for ( j = i+1; j < 5; j++) //设置内层循环为5，表示剩下的未排序数组元素部分
{
if (a[j] < temp) { //如果后续的元素中有比前面设定的最小值还小
temp = a[j]; //重新设定最小值
pos = j;//修正最小元素的位置
}
}
//将最小的数组元素和当前排序次数对应的数组元素互换
a[pos] = a[i];
a[i] = temp;
}
//输出数组排序结果
printf("排序结果如下: \n");
for (int i = 0; i < 5; i++)
{
printf("%d \t", a[i]); //用制表符分割打印后的数组
}
return 0;
}- 冒泡排序法
原理：每次比较数组中相邻的两个数组元素的值，将较小的数排在较大的数前面，可实现数组元素从小到大排序； 每次将较大的数排在较小的数前面，可实现数组从大到小排序。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
int i, j;
int a[5]; //存储用户输入的数据
int temp=0;//表示最小的数组元素
printf("请输入5个数字，为数组的元素赋值：\n");
for (int i = 0; i < 5; i++)
{
printf("a[%d]=", i);
scanf("%d", &a[i]);
}
//输出数组未排序前的结果
printf("排序结果如下: \n");
for (int i = 0; i < 5; i++)
{
printf("%d \t", a[i]); //用制表符分割打印后的数组
}
//使用冒泡排序法对数组元素从小到大排序
for (int i = 0; i < 5; i++) //表示后4个数组元素
{
for ( j = 4; j >=i; j--) //表示从最后一个元素开始向前循环
{
if (a[j] < a[j-1]) { //如果后一个数大于前一个数
//交换两个数组元素的值，如同冒泡
temp = a[j - 1];
a[j - 1] = a[j];
a[j] = temp;
}
}
}
//输出数组排序结果
printf("排序结果如下: \n");
for (int i = 0; i < 5; i++)
{
printf("%d \t", a[i]); //用制表符分割打印后的数组
}
return 0;
}3,交换法排序
原理：将每一位数与其后的所有数一一比较，如果发现符合条件的数据，则交换数据。
首先，用第一个数依次与其后的所有数进行比较，如果存在比其值大（小）的数，则交换这两个数，
继续向后比较其他数直至最后一个数。然后再使用第二个数与其后面的数进行比较，如果存在比其值大（小）的数，则交换这两个数。继续向后比较其他数，直至最后一个数比较完成。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
int i, j;
int a[5]; //存储用户输入的数据
int temp=0;//表示最小的数组元素
printf("请输入5个数字，为数组的元素赋值：\n");
for (int i = 0; i < 5; i++)
{
printf("a[%d]=", i);
scanf("%d", &a[i]);
}
//输出数组未排序前的结果
printf("未排序的结果如下: \n");
for (int i = 0; i < 5; i++)
{
printf("%d \t", a[i]); //用制表符分割打印后的数组
}
printf("\n");
//使用交换法对数组元素从小到大排序
for (int i = 0; i < 4; i++) //表示前4个数组元素
{
for ( j = i+1; j <5; j++) //表示后面的待比较数组元素
{
if (a[j] < a[i]) { //如果后一个数比前一个数小
temp = a[i]; //交换两个数组元素的值，使小数前移
a[i] = a[j];
a[j] = temp;
}}}
//输出数组排序结果
printf("排序后的结果如下: \n");
for (int i = 0; i < 5; i++)
{
printf("%d \t", a[i]); //用制表符分割打印后的数组
}
return 0;
}4,插入法排序
原理：抽出一个数据，在前面的数据中寻找相应的位置插入，然后继续下一个数据，直到完成排序。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
int i, j;
int a[5]; //存储用户输入的数据
int temp=0;//表示最小的数组元素
int pos;
printf("请输入5个数字，为数组的元素赋值：\n");
for (int i = 0; i < 5; i++)
{
printf("a[%d]=", i);
scanf("%d", &a[i]);
}
//输出数组未排序前的结果
printf("未排序的结果如下: \n");
for (int i = 0; i < 5; i++)
{
printf("%d \t", a[i]); //用制表符分割打印后的数组
}
printf("\n");
//使用插入法对数组元素从小到大排序
for (int i = 0; i < 5; i++) //表示后4个数组元素
{
temp = a[i];//设置插入值
pos = i - 1;
while ((pos>=0) && (temp<a[pos])) //内层循环，寻找插入值的位置
{
a[pos + 1] = a[pos]; //插入数值
pos--;
}
a[pos + 1] = temp;
}
//输出数组排序结果
printf("排序后的结果如下: \n");
for (int i = 0; i < 5; i++)
{
printf("%d \t", a[i]); //用制表符分割打印后的数组
}
return 0;
}5,折半法排序（快速排序）
原理：选择一个中间值（在程序中使用数组中间元素的值），然后把比中间值小的元素放在左边，比中间值大的元素放在右边（具体的实现是从两边查找，找到一对后进行交换），然后再对左右两边分别递归使用折半法排序过程。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void CelerityRun(int left, int right, int Array[]);//申明折半查找法函数
int main()
{
int a[5]; //存储用户输入的数据
printf("请输入5个数字，为数组的元素赋值：\n");
for (int i = 0; i < 5; i++)
{
printf("a[%d]=", i);
scanf("%d", &a[i]);
}
//输出数组未排序前的结果
printf("未排序的结果如下: \n");
for (int i = 0; i < 5; i++)
{
printf("%d \t", a[i]); //用制表符分割打印后的数组
}
printf("\n");
//使用折半法对数组元素从小到大排序
CelerityRun(0, 4, a);
//输出数组排序结果
printf("排序后的结果如下: \n");
for (int i = 0; i < 5; i++)
{
printf("%d \t", a[i]); //用制表符分割打印后的数组
}
return 0;
}
//定义函数实现
void CelerityRun(int left, int right, int Array[]) {
int i, j, middle, temp; //变量的含义是：i, j记录下标、middle中间值、temp记录临时变量，left, right记录左右元素
i = left;
j = right;
middle = Array[(left + right) / 2];//求中间值
do
{
while ((Array[i] < middle) && (i < right))//从左查找小于中间值的数
i++;
while ((Array[j] > middle) && (j > left))//从右查找大于中间值的数
j--;
if (i<=j)//如果找到一对值
{
temp = Array[i];//交换两个值
Array[i] = Array[j];
Array[j] = temp;
i++;
j--;
}
} while (i<=j);
//如果两边的下标交错，就停止（完成一次）
if (left<j)
{
CelerityRun(left, j, Array);//递归左半边
}
if (right >i)
{
CelerityRun(i, right, Array);//递归右半边
}
}排序算法的比较：
- 选择法排序：简单，容易实现，适用于数量较小的排序；
- 冒泡法排序：相对稳定的排序方法，当待排序列有序时，效果比较好。
- 交换法排序：正序时最快，逆序时最慢，排序有序数据时效果最好。
- 插入法排序：原始数据基本有序，具有较快的运算速度。
- 折半法排序：n越大，速度越快。
数组的应用
1，反转字符串
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
int i;
char a[7] = { "hello!" }; //定义源字符串
char b[7] = { 0 };//定义存储反转后的字符串
int size = sizeof(a);//计算源字符串长度
//循环读取字符
for (int i = 0; i < 6; i++)
{
b[size - i - 2] = a[i]; //源字符串倒序存入反转字符串中
}
printf("输出源字符串: %s \n", a);
printf("反转后的字符串: %s \n", b);
return 0;
}
2, 输出系统日期和时间
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<time.h>
int main()
{
struct tm *sysTime;
time_t nowTime;
time(&nowTime);//获取系统时间
sysTime = localtime(&nowTime);//转换为系统时间
printf("系统日期: %d-%d-%d \n", 1900+sysTime->tm_year,sysTime->tm_mon+1,sysTime->tm_mday);
printf("系统时间: %d:%d:%d \n", sysTime->tm_hour,sysTime->tm_min,sysTime->tm_sec);
return 0;
}
字符串的加密和解密
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main()
{
int result = 1;
int i;
int count = 0;
char Text[128] = {'\0'}; //定义一个明文字符串
char PassWord[128] = {'\0'}; //定义一个秘文字符串
while (1)//始终保持输入状态
{
if (result==1) //如果用户输入1，则加密密文
{
printf("请输入要加密的明文：\n");//输出提示信息
scanf("%s", &Text);
count = strlen(Text); //获取字符串的长度
for ( i = 0; i < count; i++)
{
PassWord[i] = Text[i] + i + 5; //设置加密字符
}
PassWord[i] = '\0';//设置字符串结束标记
printf("加密后的密文是：%s \n", PassWord);
}
else if (result==2) //如果用户输入2，解密字符串
{
count = strlen(Text); //获取字符串的长度
for (i = 0; i < count; i++)
{
Text[i] = PassWord[i] -i - 5; //设置解密字符
}
Text[i] = '\0';//设置字符串结束标记
printf("解密后的明文是：%s \n", Text);
}
else if (result==3) //如果用户输入3，则退出系统
{
break;
}
else
{
printf("请输入命令符：\n");
}
printf("输入1加密明文，输入2解密密文，输入3退出系统 \n");
printf("请输入命令符：\n");
scanf("%d", &result);
}
return 0;
}二 函数
函数是程序的基本单元，函数中包含着程序的可执行代码。通常一个程序由函数来实现子程序，再由子程序实现模块功能，各个模块功能构成程序。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int sum(int a,int b); //申明函数,并且有两个形参a和b
int sum(int a,int b) { //定义函数，其基本构成为： 返回值类型 函数名称 （函数参数或者为空）{ 函数体 }
return a + b; //return的作用有： 退出函数并返回程序的调用处； 返回一个值供主调函数使用。
}
//定义一个内部函数：该函数只能被所在的源文件使用，内部函数又称为静态函数
//内部函数定义
static int add(int a, int b) { return a + b; }
int main()
{
//调用函数时，填入实参传递给函数
int result = sum(12, 334);
printf("%d \n", result);
/*
* 可作为函数参数的类型有：
基本类型：int,double,float, char,
数组元素：数组名称[下标]，这中方式和普通的参数传递差不多
数组名称：这种方式传递的是数组中第一个元素的地址，
*
*
* 函数的嵌套调用： 在一个函数中调用另外一个函数
* 函数的递归调用： 函数自身调用自身的写法
*/
return 0;
}
外部函数的使用步骤：
1，先在demo.c源文件中定义函数 Add
#include<stdio.h>
//定义一个外部函数：可以被其他源文件调用的函数
extern int Add(int a, int b) { return a + b + 100; }
在Demo2.c中使用
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
extern int Add(int a, int b);//使用外部文件定义的函数，首先需要声明
int main()
{
printf("%d", Add(12,222));
return 0;
}
局部变量和全局变量
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//全局变量： 定义在所有函数外部的变量，全局变量不属于某个函数，而是属于整个源文件
int a = 1000;
//使用extern关键字修饰全局变量，使其他源文件也能够使用该变量
extern int b = 122;
int main()
{
//当发生局部变量重名时，内层作用域中的变量将屏蔽外层作用域中的同名变量，直到结束内层作用域为止。
int a = 10;//a为局部变量，自己距离自己最近的大括号内有效（在main函数的大括号内有效）
return 0;
}
函数应用
数学函数
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h> //数学计算函数头文件
int main()
{
int intABS = abs(-12); //求一个负数的绝对值
int intLabs= labs(-1223434L); //求一个长整型数的绝对值
int intFlabs = fabs(-234.22);//求实型数的绝对值
int intSin = sin(0.5);//求解正弦
int intCos = cos(0.4);//求解余弦
int intTan = tan(0.8);//求解正切
printf("%d, %d, %d , %d, %d, %d", intABS, intLabs, intFlabs, intSin, intCos, intTan);
return 0;
}
字符函数
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<ctype.h> //字符函数头文件
int main()
{
char c = 'h';
int alpha = isalpha(c);//判断该字符是否是字母，如果是则返回非0值
int Digit = isdigit(c);//判断该字符是否是数字，如果是则返回非0值
int num = isalnum(c);//判断是否是字母或者数字，如果是则返回非0值
printf("%d, %d, %d ", alpha, Digit, num);
return 0;
}
字符串处理函数
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h> //字符串处理头文件
int main()
{
char a[10] = { "hello" };
char b[10] = {};
strcpy(a, b);//将符串a复制到字符串b中
strcat(a, b);//将字符串a连接到字符串b的末尾
strcmp(a, b);//比较两个字符串，若相同返回0，若a>b返回值为正数，若a<b返回值则为负数
strupr(a);//小写转换为大写
strlwr(b);//将大写转换为小写
strlen(a);//获取字符串的长度
return 0;
}