北京征集网站建设,揭阳高端网站建设价格,wordpress多久被收录,网站网页制作机构程序片段(01):01.杨辉三角.c 内容概要:杨辉三角 #include stdio.h
#include stdlib.h#define N 10//01.杨辉三角:
// 1.图形转换:将标准杨辉三角采用标准数组进行模拟
// 2.确定标准数组的图形描述关系:
// (1).数组当中第一列的所有元素以及正对角线的… 程序片段(01):01.杨辉三角.c 内容概要:杨辉三角 #include stdio.h
#include stdlib.h#define N 10//01.杨辉三角:
// 1.图形转换:将标准杨辉三角采用标准数组进行模拟
// 2.确定标准数组的图形描述关系:
// (1).数组当中第一列的所有元素以及正对角线的所有元素都为1
// (2).数组当中的其它元素等于上一行左一列
// 3.数组模拟杨辉三角的诀窍!
// 将整个杨辉三角向左倾斜成为标准的二维数组
int main01(void)
{int intArrArr[N][N] { 0 };for (int i 0; i N; i){for (int j 0; j i; j){if (0 j || i j)intArrArr[i][j] 1;else//核心代码intArrArr[i][j] intArrArr[i - 1][j - 1] intArrArr[i - 1][j];}}//模拟杨辉三角的标准数组打印方式for (int i 0; i N; i){for (int j 0; j i; j){printf(%4d, intArrArr[i][j]);}printf(\n);}//杨辉三角打印方式for (int i 0; i N; i){//1910*4/2-1-i*2printf(%*c, 19 - i*2, \0);//printf();当中的*表示预订宽度,scanf();当中的*表示忽略宽度for (int j 0; j i; j){printf(%4d, intArrArr[i][j]);}printf(\n);}system(pause);
} 程序片段(02):01.Array.c02.二维数组实战.c03.二维数组转置.c 内容概要:02.二维数组本质 ///01.Array.c
#include stdio.h
#include stdlib.h//01.二维数组本质:
// 1.二维数组的数组名本质:
// 就是整个二维数组的首个数组元素首地址
// 2.二维数组当中的数组元素和行元素区分:
// 就二维数组整体而言:
// 每个数组元素都只是一个数组元素
// 每个行元素当中包含有多个数组元素
// 就一维数组整体而言:
// 每个数组元素都只是一个行元素
// 注意事项:
// 1.所有数组的存储方式都是采取线程存储:
// 存储特点:连续类型相同
// 2.所有线性存储方式的数据结构都可以采取
// 线性方式进行顺序规律的初始化方式初始
// 3.二维数组也是采取的静态初始初始化方式
// 也就是长度必须采用常量进行标识
// 4.数组的静态初始化特点:
// (1).一个大括号代表一个维度
// (2).只要存在前置元素初始化,那么后面的所有数组元素
// 都会默认进行初始化为0的操作
// (前置:必须从首个数组元素开始,否则不会出现连续默认初始化为0的现象)
int main01(void)
{int intArrArr[3][4] { { 1, 2 }, { 3, 4 }, { 5, 6 } };for (int i 0; i 3; i){for (int j 0; j 4; j){//%p%#x(将数值以16进制以及携带进制标识的方式进行打印)//intArrArr[i][j]与intArr[i]j等价的原因:intArrArr[i]表示的是二维数组当中每个一维数组的首个元素的地址(也就是每个一维数组的地址)printf(%2d,%p,%p, intArrArr[i][j], intArrArr[i][j], intArrArr[i] j);}printf(\n);}//对二维数组的不同看待方式会有不同的效果!// 将二维数组看做为一维数组的处理方式,// 那么以一维数组的数组元素获取方式,就是在获取每个数组元素的首地址printf(%p,%p,%p \n, intArrArr[0], intArrArr[1], intArrArr[2]);system(pause);
} ///02.二维数组实战.c
#include stdio.h
#include stdlib.h#define N 10
int intArrArr[N][N];
//01.不引入任何变量实现二维矩阵数组的标准数据规律化赋值方式:
// 表达式:intArrArr[i][j]i*N1j;//从1开始进行的规律化赋值
int main02(void)
{for (int i 0; i N; i){for (int j 0; j N; j){printf(%3d, intArrArr[i][j] i * N j 1);//举行数组赋值的规律表达式(不引入任何其他变量)}printf(\n);}system(pause);
}//02.二维数组当中的特殊数据统计方式:
// sumA:表示统计所有
// sumB:统计每行
// sumC:统计每列
// sumD:统计正斜线
// sumE:统计反斜线
int main03(void)
{int sumA 0;int sumD 0;int sumE 0;for (int i 0; i N; i){//表示行int sumB 0;for (int j 0; j N; j){//表示列printf(%4d, intArrArr[i][j] i*N 1 j);sumA intArrArr[i][j];sumB intArrArr[i][j];//if (i j)// sumD intArrArr[i][j];if (i j N - 1)sumE intArrArr[i][j];}printf(sumB %d \n, sumB);sumD intArrArr[i][i];printf(\n);}printf(\n\n);for (int j 0; j N; j){//表示列int sumC 0;for (int i 0; i N; i){//表示行sumC intArrArr[i][j];}printf(sumC %d \n, sumC);}system(pause);
} ///03.二维数组转置.c
#include stdio.h
#include stdlib.h//01.对数组的各种转置操作:
// 1.转置:正转置,翻转置,翻页转置
// 相当于对二维平面的任意操作特点
// 2.转置规律分析:
// 就是直接将带转置的图形与
// 转置之后的结果进行对比分析
// 快速得出二维数组的转置规律
//02.翻页转置效果总结:
// 1.待转置数组与转置后数组特点:
// 待转置数组:intArrArrA[N1][N2];
// 转置后数组:intArrArrB[N2][N1];
// 2.转置效果分类:转置线翻页点
// 反斜线转置:intArrArrA[j][i]
// 上翻页:intArrArrB[i][j]
// 下翻页:intArrArrB[N2-1-i][N1-1-j]
// 正斜线转置:intArrArrA[N1-1-j][N2-1-j]
// 上翻页:intArrArrB[i][j]
// 下翻页:intArrArrB[N2-1-i][N1-1-j]
// 规律:先确定转置线,再确定翻页点
int main04(void)
{ /*//待转置数组1 2 3 04 5 0 136 7 8 9//正常打印待转置数组*/int intArrArrA[3][4] { { 1, 2, 3 }, { 4, 5, 0, 13 }, { 6, 7, 8, 9 } };int intArrArrB[4][3] { 0 };for (int i 0; i 3; i){for (int j 0; j 4; j){//待转置数组printf(%3d, intArrArrA[i][j]);}printf(\n);}printf(\n);//1 4 6//2 5 7//反斜线转置//3 0 8//0 13 9//特点:反斜线以左下角下翻页:for (int i 0; i 4; i){for (int j 0; j 3; j){//转置后数组:正确打印方式intArrArrB[j][i];printf(%3d, intArrArrB[i][j] intArrArrA[j][i]);//以左下角为翻页点,反斜线为转置线,作为翻页转置效果}printf(\n);}printf(intArrArrB[i][j]--intArrArrA[j][i] \n\n);//特点:反斜线以左下角上翻页for (int i 0; i 4; i){for (int j 0; j 3; j) {//转置后数组:逆向接收方式intArrArrB[j][i];printf(%3d, intArrArrB[3 - i][2 - j] intArrArrA[j][i]);//以右上角为翻页点,反斜线为转置线,作为翻页转置效果}printf(\n);}printf(intArrArrB[3-i][2-j]intArrArrA[j][i] \n\n);//总结:翻页转置的效果相似,都是以斜对角线为基准进行转置,一个正向翻页,一个逆向翻页//9 13 0//8 0 3//正斜线转置//7 5 2//6 4 1for (int i 0; i 4; i){for (int j 0; j 3; j){printf(%3d, intArrArrB[i][j] intArrArrA[2 - j][3 - i]);} printf(\n);}printf(intArrArrB[i][j]intArrArrB[2-j][3-i] \n\n);for (int i 0; i 4; i){for (int j 0; j 3; j){printf(%3d, intArrArrB[3 - i][2 - j] intArrArrA[2 - j][3 - i]);}printf(\n);}printf(intArrArrB[3-i][2-j]intArrArrB[2-j][3-i] \n\n);system(pause);
}#define row 2
#define column 3
//02.翻页转置规律大总结:
// 先确定转置线,再确定翻页点
int main05(void)
{int intArrArrA[row][column] { 1, 2, 3, 4, 5, 6 };printf(原样输出: \n);for (int i 0; i row; i){for (int j 0; j column; j){printf(%2d, intArrArrA[i][j]);}printf(\n);}printf(\n);int intArrArrB[column][row] { 0 };printf(以反斜线为转置线,以左下角为翻页点,进行翻页转置! \n);for (int i 0; i column; i){for (int j 0; j row; j){printf(%2d, intArrArrB[i][j] intArrArrA[j][i]);}printf(\n);}printf(\n);printf(以反斜线作为转置线,以右上角作为翻页点,进行翻页转置! \n);for (int i 0; i column; i){for (int j 0; j row; j){printf(%2d, intArrArrB[column - 1 - i][row - 1 - j] intArrArrA[j][i]);}printf(\n);}printf(\n);printf(以正斜线作为转置线,以右下角作为翻页点,进行翻页转置! \n);for (int i 0; i column; i){for (int j 0; j row; j){printf(%2d, intArrArrB[i][j] intArrArrA[row - 1 - j][column - 1 - i]);}printf(\n);}printf(\n);printf(以正斜线作为转置线,以左上角作为翻页点,进行翻页转置! \n);for (int i 0; i column; i){for (int j 0; j row; j){printf(%2d, intArrArrB[column - 1 - i][row - 1 - j] intArrArrA[row - 1 - j][column - 1 - i]);}printf(\n);}printf(\n);system(pause);
} 程序片段(03):03.Time.c 内容概要:高维数组 #include stdio.h
#include stdlib.h//01.二维数组的初始化方式:
// 奥数技巧:线性初始化方式
// 注:凡是线性存储的数据结构都存在着线性的初始化方式
//02.线性初始化的规律总结:
// 1.采用一个循环结构控制循环次数(实质就是数组当中所含元素的个数)
// 2.操控数组的时候规律:
// intArrArr[变化慢的][变化快的] i 1;
// 变化慢的:求模最低维数
// 变化快的:取余最低维数
// i1:使得线性初始化值为1,2,3...(能够避免不必要的修改循环控制变量的值)
// 注:%p%#X的打印实质等价
int main01(void)
{//A 0 1 2 3//0 00 01 02 03//1 10 11 12 13//2 20 21 22 23//3 30 31 32 33int intArrArr[3][4] { 0 };for (int i 0; i 12; i){intArrArr[12 / 4][12 % 4] i 1;//二维数组的线性初始化方式}printf(%p \n, intArrArr);//printf(%#X \n, intArrArr);system(pause);
}//03.三维数组的线性初始化总结:
// 1.三维数组组成分析:
// 本质:三维数组的具体模型--立体结构(六个方向:上,下,左,右,前,后)
// 特点:intArrArr[z][x][y];
// z:代表立体结构纵坐标--这是由二维到三维的转变维度
// x:代表平面结构x坐标
// y:代表平面结构y坐标
// 2.三维数组的线性初始化方式详解:
// intArrArrArr[z][x][y];
// for (int i 0; i z*x*y; i)
// intArrArrArr[i / (x*y)][i % (x*y) / y][i % (x*y) % y] i 1;
// i / (x*y):代表当前索引所指向的立体结构(第几层)
// i % (x*y) / y:代表当前索引所指向的立体结构的(不完全面)的第几行
// i % (x*y) % y:代表当前索引所指向的立体结构的(不完全面)的第几列
// 注:
// 1.凡是数据结构为线性的存储结构,那么前置元素只要初始化为0,后置存储便会
// 默认初始化为0(尤其是数组的初始化特点)
// 2.数组通性特点:
// 元素类型一致,连续内存存储[数组都是以线性内存结果进行的数据存储,因此才可以进行线性初始化赋值操作]
// 3.内层优化技巧:
// 能够减少不必要的运算过程就应当尽量减少
// 比如:三维数组的初始化技巧,不必要使用三层循环结构,减少不不要的两层循环结构,采用一层结构进行搞定
int main02(void)
{int intArrArrArr[3][4][5] { 0 };intArrArrArr[0][0][0] 0;intArrArrArr[1][0][0] 20;//intArrArrArr[1][2][0]30;intArrArrArr[1][2][3]33;intArrArrArr[2][0][0] 40;printf(%p \n, intArrArrArr);//三维数组的首地址for (int i 0; i 60; i){//intArrArrArr[60 / 20][60 % 20 / 5][60 % 20 % 5] i;//性能优化操作--游戏开发当中,少一层循环结构,多提升一些效率intArrArrArr[i / (4 * 5)][i % (4 * 5) / 5][i % (4 * 5) % 5] i;//0,1,2--0,1,2,3--0,1,2,3,4}//intArrArrArr[i][j][k]--程序性能优化:能够减少的循环层数就一定要进行相应的减少//intArrArrArr[(i*j*k)/(j*k)][(i*j*k)%(j*k)/k][(i*j*k)%(j*k)%k]system(pause);
}//04.从0维数组到N维数组的推导过程:
// 0维数组:就是一个变量
// 实质:点
// 1维数组:就是一个一维数组
// 实质:线
// 2维数组:就是一个二维数组
// 实质:面
// 3维数组:就是一个三维数组
// 实质:立体
// 4维数组:就是一个四维数组
// 实质:立体时间
// 5维数组:就是一个五维数组
// 实质:立体时间质量
// 6维数组:就是一个六维数组
// 实质:立体时间质量能量
// n维数组:就是一个N维数组
// 实质:(n-1)维基础条件第n维的条件
//05.数组线性初始化特点:
// 从第一层第一面第一个点开始进行逐个点的初始化
// 从下层不断的往上层
// 从一个面不断的往另外一个面
// 从一个点不断的往一个点
int main03(void)
{int intArrArrArr[2][3][4] { 0 };int num 0;for (int z 0; z 2; z)//层结构(包含面){//遍历2个平面for (int x 0; x 3; x)//面结构(包含行){//遍历3个行数for (int y 0; y 4; y)//线结构(包含点){//遍历4个列数printf(%3d, %p, intArrArrArr[z][x][y] num, intArrArrArr[z][x][y]);}printf(\n);}printf(\n\n);}system(pause);
} 程序片段(04):01.Fun.c 内容概要:数组与函数 #include stdio.h
#include stdlib.h//01.数组作为函数参数进行传递的特殊性质:
// 数组作为函数的参数传递,会自动退化为指针,目的就是为了传递地址[数组--指针--地址]
// 注:
// 1.目的是为了节省资源,避免不必要的内存拷贝动作,提升程序性能(直接采用指针操作原始数据)
// 2.数组名作为实参,就是指向首个数组元素的指针,数组名没有作为参数,就是表示整个数组的类型
void testArrName(int intArr[10])//地址:数组是例外,数组传递的是指针,也就是地址,数组没有副本机制
{printf(%p \n, intArr);intArr[3] 1000;printf(sizeof(intArr) %d \n, sizeof(intArr));//这里的实质就是求取地址这个整数所占用的内存字节数int intArrTest[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };printf(sizeof(intArrTest) %d \n, sizeof(intArrTest));//数组没有用作函数实参进行传递,就是数据实际大小
}int main01(void)
{int intArr[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };printf(%p \n, intArr);testArrName(intArr);for (int i 0; i 10; i){printf(%d \n, intArr[i]);}system(pause);
} 程序片段(05):01.枚举数组.c 内容概要:数组与枚举常量 #include stdio.h
#include stdlib.henum person{ 吴伟, lzq, zb, yc, 李波 };//0,1,2,3...默认匹配的整数形式
double yanZhiBiao[5] { 97.9, 93.9, 88.9, 60.9, 98.9 };//01.枚举数组的特点:枚举数组结合使用(类似于查表法的使用)
// 让枚举数据具备一定的比较特性
// 查表法:已知一个索引,在已经存在的对应表当中进行数据查询
int main01(void)
{//让枚举数据具备一定的比较特性for (enum person people 吴伟; people 李波; people){printf(%lf \n, yanZhiBiao[people]);}system(pause);
} 程序片段(06):01.命名.c 内容概要:起名工具 #include stdio.h
#include stdlib.h
#include time.h
#include locale.h//01.知识要点:
// 1.随机数生成方式
// 2.查表法的应用
// 先定义表体内容,
// 再定义查询内容
int main01(void)
{//time_t te;//定义时间类型//unsigned int seed (unsigned int)time(te);//获取随机数种子//srand(seed);//种植随机数种子srand((unsigned int)time(NULL));//种植随机数种子//int passLength rand() % 10 6;//6~15:密码长度//2个字儿,3个字儿的密码生成,定住姓氏,随机名字char passChr[10] { A, B, C, D, E, F, G, H, I, J };//for (int i 0; i passLength; i)//{// int num rand() % 10;//随机获取组成密码的单个字符// printf(%c, passChr[num]);//}for (int i 0; i rand() % 10 6; i){printf(%c, passChr[rand() % 10]);}printf(\n);system(pause);
}//02.查表法很重要!
int main02(void)
{setlocale(LC_ALL, zh-CN);wchar_t wcharS[8] { L龙, L虎, L大, L伟, L天, L桂, L三, L财 };//putwchar(wcharS[0]);putwchar(L吴);srand((unsigned int)time(NULL));for (int i 0; i rand() % 2 1; i){putwchar(wcharS[rand() % 8]);}system(pause);
} 程序片段(07):01.洗牌.c 内容概要:07.洗牌 #include stdio.h
#include stdlib.h
#include time.h//01.洗牌算法透析:
// 原理:让任何一张牌有机会与其后面的任意一张牌进行交换
// int randNum 0;
// for (int i 0; i 53; i)//只需要让倒数第二张牌和倒数第一张牌有交换几率就行了,倒数第一张牌没有后续的交换概率
// {//由于最大索引为53--然而前面已经保证了从后面一张牌开始--因此需要1X能够等于53--rand()%(53-i)--极限推理法
// randNum i 1 rand() % (53 - i);//(i1)保证绝对不会发生本体交换特点a;rand()%(53-i)保证随机数合理,(53-i)防止出界
// }
int main01(void)
{int intArr[54] { 0 };printf(洗牌之前:\n);for (int i 0; i 54; i){printf(%3d, intArr[i] i 1);}printf(\n\n);srand((unsigned int)(time(NULL)));//种植随机数种子for (int i 0; i 53; i)//少一次:为了避免最后一次没有交换对象{int num i 1 rand() % (53 - i);intArr[i] intArr[i] ^ intArr[num];intArr[num] intArr[i] ^ intArr[num];intArr[i] intArr[i] ^ intArr[num];}printf(洗牌之后:\n);for (int i 0; i 54; i){printf(%3d,intArr[i]);}system(pause);
} 转载于:https://www.cnblogs.com/niulanshan/p/6174614.html
