用new创建多维数组时，最后需要用delete，但是我在delete时遇到了麻烦，实在不能再浪费时间了，先mark一下，至少创建多维数组这段是对的
 
 
以int型数组为例，我们知道
 
一维数组  int a[4] ={1,2,3,4};
 
二维数组  int b[3][4] = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4}
 
三维数组  int c[2][3][4] = {1,2};
 

 
 
那么用new方式如何创建呢
 
一维数组有
 
 
int *p1 = new int[4];
 
二维数组有
 
 
int (*p2)[4] = new int[3][4];
 

 
 
三维数组
 
int (*p3)[3][4] = new int[2][3][4];//两维三行四列
 

 
 
同样的四位数组
 
int (*p4)[2][3][4] = new int[1][2][3][4];//不知道怎么叫了
 

 
 
忘了从哪里看到的说： 从二维数组开始，定义并不是写成  int *p2[4]、int * p3[3][4]、...这是因为int * p2[4]表示定义一个数组p2，该数组是int *型，数组内的每个元素都是指向int型的指针。
 

	//step 1定义多维数组

	//int *q1 = new int[4];  //创建一维数组，暂时不用
	//int (*q2)[4] = new int[0][4];//创建二位数组，暂时不用
	int (*p)[3][4] =  new int[2][3][4];//创建三维数组，本文研究的重点，我为了少打字，这个变量我定义成了p,并不是p3
	//int (*p4)[3][4][5] = new int [0][3][4][5];//创建四维数组

	//留个标记，用于
	//存放这些数组的指针，用于验证是否delete时会用到
	int *backup[24];
	int imark = 0;

	//循环将三维数组每个元素均赋值为1
	printf("------初始化得到的二维数组----\n");
	for(int i = 0;i< 2;i++)
	{

		for(int j = 0;j<3;j++)
		{
			for(int k = 0;k<4;k++)
			{
				printf("%d --->",(*(*(p+i)+j)+k));//初始化之前均为0
				printf("%d ",*(*(*(p+i)+j)+k));//这里打印了new出来的三维数组，本层循环最后将每个值赋值成了1


				backup[imark++] = (*(*(p+i)+j)+k);
				*(*(*(p+i)+j)+k) = 1;//这里将每个元素赋值成了1，为的是方便后面delete时对比查看

			}
			printf("\n");
		}

	}

	printf("---------------------\n");//

	//step 2 准备检验

	//前辈说书中讲的，数组的大小在之前的四个字节内存储着，究竟是啥呢，在这里可以打印查看printf("front 4 byte is %d, -->%d\n",&p[0][0][0]-1,(int)*(&p[0][0][0]-1));printf("p[0][0][0] address is %d\n",&p[0][0][0]);printf("p[1][2][3] address is %d\n",&p[1][2][3]);printf("\n");//这里尝试了好多种delete的方式都没有成功？？？╮(╯▽╰)╭
	//第一种尝试，直接删除p数组，这个似乎从原理上很容易否定
	/*
	delete []p;//这种方式发现只删除了new出来的前两个元素

	*/

	//第二种尝试，借用一下保存的指针，用指针一个一个去free
	/*
	for(int i =0;i<24;i++)
	{
	delete backup[i];//用backup中记忆的位置一个一个删除，发现行不通，&backup[i]也行不通
	//delete []backup;//这种也是行不通的，我注解上了，可以试试
	}

	*/

	//第三种尝试，嵌套进入生成的数组，一层一层的去free，然而依然失败，不知道是重复删除了，还是怎么了，感觉是重复删除了
	for(int i = 0;i<2;i++)
	{
		for(int j = 0;j<3;j++)
		{
			delete [] p[i][j];
		}
	delete []p[i];
	}


	//第四种尝试，一个一个删，但依然没有成功,我从大到小，先小到大均试了一次，依然失败，下面写的是从大到小
	/*
	delete p[1][2][3];//不要搞混乱，2*3*4维数组最大值就是这个
	delete p[1][2][3];//不列写了，因为占篇幅，可以肯定的是没成功
	//...
	delete p[0][0][0];
	*/


	//这里面检查是否已经delete了
	for (int i = 0; i < 24; i++) {
		if ((i != 0) && (i % 4 == 0))
		{
			printf("\n");
		}
		printf("[%d]%d--->%d ", i, backup[i], (int) *backup[i]);
	}
	printf("\n");
	return 0;


 

 
 
我目前gdb方式还不会看，另外delete还学得不够深入，再钻进去周末别的也就看不成了，所以得先记下。
 

 
 
另外粘一个别人new三维数组的方法
 

int*** a= new int**[5];
for (int i = 0; i < 5; ++i)
{
     a[i] = new int*[6];
     for (int j = 0; j < 6; ++j)
    {
            a[i][j] = new int[7];
     }
}
for (int i = 0; i < 5; ++i)
{
     for (int j = 0; j < 6; ++j)
     {
           delete[] a[i][j];
     }
     delete[] a[i];
}
delete[] a;

 

 
 
就先到这里吧
 
 

 
 

 转载请注明出处：http://blog.csdn.net/zbf8441372
 
 
闲着也是闲着，就来扯扯淡。
 
昨天在一个大牛的博客（Google搜索“大牛的博客”，第一个就是他）的一篇博文里，看到了四维空间的认知，好奇心驱使就查了些wiki，百科之类，看了些视频下面试着来阐述阐述，加强下自己的理解。
 

 
 
维数类比
 
阿伯特的Flatland里描绘了生活在二维空间的人，在他们眼里，活在三维空间的人就像是神。可以想象，生活在三维空间的人可以看到二维世界里的封闭形状内部的东西。二维世界只有水平方向，他们的生活必须遵从一定的顺序规律，才能区分识别一些东西。那生活在四维世界的人是怎么看我们三维世界的人的呢？你应该会觉得，真的有四维世界吗？四维世界是被数学家证实的，但有人说四维世界的存在就意味着存在平行宇宙，这是推测却没有得到证实。只能说，四维世界是无数个三维世界组成的。如果把第四维看成是时间的话，这点也许更好理解。不过时间只是一种说法，只是闵式空间里的说法。
 
我觉得这第四维是我们无法感知的，就像二维人无法感知我们的第三维——高度。其实，时间这一维也可以是二维世界的第三维。为什么？将一个小人儿画在纸上，是一个二维的图像。在多张纸上画若干个小人儿，再翻动纸张，便跑动起来了，成为了一个三维世界中的人。这样看，二维世界的时间就成为了第三维。所以时间这一维就是一种n+1的说法。
 

 
 
四维图形
 
四维世界是可以由我们三维世界的人认知的，只是需要一些想象力。大家可以看看这里。hypercube是四维中的“立方体”。看了之后就会明白，四条全等的一维直线构成一个二维的正方形，六个全等的正方形拼成一个三维的立方体，八个全等的立方体组成一个四维的超方体，而且他也是可以展开，折叠的。
 
 
真正的超方体应该是动态的：
 
 
两个正方体拼成的，数一数，有16个顶点，32条边（24+8）。四个面共享一个顶点，四条边共享一个顶点，正好是四个相互垂直的维坐标系。每个点由(0,1,0,1)四维表示。wiki上有更多数学性的向量解释。
 
超方体不是最基本的四维图形，最基础的应该是类似四面体那样的四维图形。它由5个点组成，每个面是三角形，可以看看这里的视频，还有四维世界里的球。反正我没怎么看懂四维里的球。
 

 
 
四维世界
 
昨天晚上睡觉前想了好久，如果存在四维世界的话，四维世界是什么样的？里面的物种呢？
 
第一个问题：一维的无数个点组成二维的线和面，二维的无数个线面组成三维的空间，这样推理，四维就应该是三维的无数个空间组成的。点，线，面可以“叠加”，空间怎么“叠加”？将三次元世界缩成点，再拉成线，就是第四次元。所以也许在四维世界里，可以像三维看二维一样，四维可以看到三维世界里任意时间点的人和事，无数个三维空间一旦“叠加”起来，我想象是这样的：举个例子，你自己在某些时刻将分支出几个你自己，走向不同位置，做出不同举动，有点像无数个平行世界。
 
第二个问题：基于上面这样的四维世界，我认为四维世界的物种肯定不是人。二维世界里的生物可以成为人吗？他们连高度都没有，只是一种物种。类似，人只是存在于三维世界的物种。我想象，三维世界的一个人的生命历程将成为四维世界的一个物种，四维物种可以直接看到这个历程中每个时间点发生的所有事，也就是说，我们的时间组成了第四维，到四维世界里不再是时间，而变成了一种存在，一种可以观察，测量的存在，就像二维的时间变成三维的高度一样。
 

 
 
更高维的世界
 
知乎里有人简单明了说到了十维。第零次元：点，第一次元：线，第二次元：面，第三次元：立体。将三次元世界缩成点。第四次元：时间（三次元世界拉成线），第五次元：所有时间轴分支的可能性（三次元世界构成的面），第六次元：在时间轴平面上跳跃的可能性（三次元世界构成的立体），即空间在所有的时间点所组成的「无限宇宙」。将无限宇宙缩成点。第七次元：其它可能和我们世界规则完全不同的的宇宙（无限宇宙拉成线），第八次元：所有和我们世界规则不同的宇宙的集合（无限宇宙构成的面），第九次元：在完全不同的宇宙间跳跃的可能性（无限宇宙组成的立体）。将第九次元缩成点。第十次元：将所有可能的宇宙集合成一个点看待，就是第十次元了。因为所有可能的宇宙都已经算在里头了，自然更高次元是不可能。
 
 

 
 
总之好像很有趣的样子，我承认脑子最好使的都去搞数学了。所以计算机里数学好的看上去就很虎！
 

 
 

 

 
数组
 
一、数组的概念
二、一维数组的定义与引用
1.一维数组定义
注意事项
常见错误
扩展：一维数组在内存中的存放
   
2.一维数组的引用
注意事项
   
3.一维数组的初始化
初始化赋值
动态赋值
  
  
三、二维数组的定义和引用
1.二维数组的定义
2.二维数组的引用和初始化
  
四、数组的应用：二分法

 
一、数组的概念
 
有如下几组数据：
 
学生的学习成绩
银行的账单
一行文字
 
这些数据的特点是：
 
具有相同的数据类型；
使用过程中需要保留原始数据 。
 
C语言为这类数据，提供了一种构造数据类型——数组。
 
在程序设计中，为了处理方便，把具有相同类型的若干变量按有序的形式组织起来，这些按序排列的同类数据元素的集合称为数组。
 在C语言中，数组属于构造数据类型；
 数组元素有序不是指元素大小顺序，而是位置顺序。
 
简而言之，数组就是具有相同类型的数据组成的序列，是一个有序集合。
 数组中的每一个数据称为数组元素，也称为下标变量，即每个元素由其所在的位置序号（即数组元素的下标）来区分。
 用数组名与下标可以用统一的方式来处理数组中的所有元素，从而方便地实现处理一批具有相同性质的数据的问题。
 
一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型，因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等类别。
 
二、一维数组的定义与引用
 
1.一维数组定义
 
在C语言中使用数组必须先进行定义。
 一维数组的定义方式为：
 
类型说明符 数组名[常量表达式];
 
例如int a[10]定义了一个整型数组，数组名为a，此数组有10个元素，10个元素都是整型变量。
 
注意事项
 
（1）类型说明符是任一种基本数据类型或构造数据类型，对于同一个数组，其所有元素的数据类型都是相同的。
 
（2）数组名是用户定义的数组标识符，书写规则应符合标识符的书写规定。
 
（3）方括号中的常量表达式表示数据元素的个数，也称为数组的长度。
 
（4）允许在同一个类型说明中，说明多个数组和多个变量。
 例如int a, b, c, d, k1[10], k2[20];。
 
（5）a[10]表示a数组有10个元素，下标从0开始，这10个元素是a[0]、a[1]、…、a[9]。
 因此，不存在数组元素a[10]。
 
（6）C语言不允许对数组的大小作动态定义，即数组的大小不依赖于程序运行过程中变量的值，因为在编译的时候就要为数组预留空间，所以在编写代码的时候不能通过变量来定义数组的大小。
 例如，下面这样定义数组是不行的：
 
int n;
scanf("%d"，&n);  /* 在程序中临时输入数组的大小 */        
int a[n];
 
常见错误
 
float a[0];     	/* 数组大小为0没有意义 */
int b(2)(3);  		/* 不能使用圆括号 */
int k, a[k];  		/* 不能用变量说明数组大小 */
 
正确示意如下：
 
int a[10];                  // 声明整型数组a，有10个元素。
float b[10],c[20];          // 声明实型数组b，有10个元素，实型数组c，有20个元素。
char ch[20];                // 声明字符数组ch，有20个元素。
 
扩展：一维数组在内存中的存放
 
定义一个一维数组int mark[100];，其在内存中地存放原理如下：
 
 
2.一维数组的引用
 
数组元素是组成数组的基本单元，也是一种变量，其标识方法为数组名后跟一个下标，下标表示了元素在数组中的顺序号。
 引用数组元素的一般形式为数组名[下标]，下标可以是整型常量或整型表达式。
 例如:
 
a[0] = a[5] + a[7] - a[2*3];
a[i+j];
a[i++];
 
这些都是合法的数组元素引用。
 
注意事项
 
（1）数组元素通常也称为下标变量，必须先定义数组，才能使用下标变量。
 在C语言中只能逐个地使用下标变量，而不能一次引用整个数组。
 例如，输出有10个元素的数组必须使用循环语句逐个输出，示意如下：
 
#include <stdio.h>

int main(){
	int i, a[10];
	for(i = 0;i < 10; i++){
		a[i] = i;
	}
	for(i = 9;i >= 0;i--){
		printf("%d ", a[i]);
	}
	
	return 0;
} 
 
打印：
 
9 8 7 6 5 4 3 2 1 0
 
不能用一个语句输出整个数组，printf("%d",a);写法是错误的。
 
（2）定义数组时用到的数组名[常量表达式]和引用数组元素时用到的数组名[下标]是有区别的。
 例如∶
 
int a[10];          	/* 定义数组长度为10 */
t = a[6];             	/* 引用a数组中序号为6的元素，此时6不代表数组长度 */
 
显然，两者的含义是不一样的。
 
3.一维数组的初始化
 
给数组赋值的方法除了用赋值语句对数组元素逐个赋值外，还可采用初始化赋值和动态赋值的方法。
 数组初始化赋值是指在数组定义时给数组元素赋初值。
 数组初始化是在编译阶段进行的，这样将减少运行时间，提高效率；
 之前用赋值语句或输入语句也可给数组素指定初值，是在运行时完成。
 
初始化赋值
 
初始化赋值的一般形式为：
 
类型说明符 数组名[常量表达式] = {值, 值, …, 值};
 
具体的实现方法有以下几种：
 （1）在定义数组时对数组元素赋以初值。
 例如int a［10］= {0，1，2，3，4，5，6，7，8，9};，将数组元素的初值依次放在一对大括号内。
 经过上面的定义和初始化之后，得到a[0] = 0，a[1] = 1，…，a[9] = 9。
 
测试如下：
 
#include <stdio.h>

int main(){
	int i, a[10] = {0, 1, 2, 3, 4, 5, 6, 7 ,8 ,9};
	for(i = 9;i >= 0;i--){
		printf("%d ", a[i]);
	}
	
	return 0;
}
 
与之前的效果是一样的。
 
（2）可以只给一部分元素赋值。
 例如int a[10] = {0，1，2，3，4};定义a数组有10个元素，但大括号内只提供5个初值，这表示只给前面5个元素赋初值，后5个元素值为0。
 
测试如下：
 
#include <stdio.h>

int main(){
	int i, a[10] = {0, 1, 2, 3, 4};
    for(i = 9;i >= 0;i--){
        printf("%d ", a[i]);
    }
	
	return 0;
}
 
打印：
 
0 0 0 0 0 4 3 2 1 0
 
显然，未定义的元素默认为0。
 
（3）如果想要使一个数组中全部元素值为0，可以写成int a[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};或int a[10] = {0};。
 
（4）在对全部数组元素赋初值时，由于数据的个数已经确定，因此可以不指定数组长度。
 例如int a[5] = {1, 2, 3, 4, 5};也可以写成int a[] = {1, 2, 3, 4, 5};。
 
在第二种写法中，大括号中有5个数，系统就会据此自动定义a数组的长度为5。
 如果数组长度与提供初值的个数不相同，则数组长度不能省略。
 例如，想定义数组长度为10，就不能省略数组长度的定义，而必须写成int a[10] = {1, 2, 3, 4, 5}; 只初始化前5个元素，后5个元素为0。
 
数组初始化与未初始化比较测试如下：
 
#include <stdio.h>

int main(){
	int i, a[5] = {3, 4, 5}, b[5];
	printf("Array a is:\n");
	for(i = 0;i < 5;i++){
		printf("%8d", a[i]);
	}
	printf("\nArray b is:\n");
	for(i = 0;i < 5;i++){
		printf("%8d", b[i]);
	}
	
	return 0;
}
 
打印：
 
Array a is:
       3       4       5       0       0
Array b is:
      -1      -1 4236709       0       1
 
显然，b数组未赋值，所以打印出了很乱、看不出规律的值。
 
动态赋值
 
动态赋值的方法示例如下：
 
#include <stdio.h>

int main(){
	int i, max, a[10];
	printf("Input 10 numbers:\n");
	for(i = 0;i < 10;i++){
		scanf("%d", &a[i]);
	}
	max = a[0];
	for(i = 1;i < 10;i++){
		if(a[i] > max){
			max = a[i];
		}
	}
	printf("max=%d", max);
	
	return 0;
}
 
打印：
 
Input 10 numbers:
13
46
70
95
73
25
62
78
54
9
max=95
 
显然，在输入10个数给数组赋值后，打印出了最大值。
 
练习：
 利用数组来求解Fibonacci数列前20个数。
 代码如下：
 
#include <stdio.h>

int main(){
	int i;
	int a[20] = {1, 1};
	for(i = 2;i < 20;i++){
		a[i] = a[i - 1] + a[i - 2];
	}
	
	for(i = 0;i < 20;i++){
		printf("%6d", a[i]);
		if(i % 5 == 4){
			printf("\n");
		}
	}
	
	return 0;
}
 
打印：
 
     1     1     2     3     5
     8    13    21    34    55
    89   144   233   377   610
   987  1597  2584  4181  6765
 
练习：
 用冒泡法(起泡法)对10个数排序(由小到大)。
 代码如下：
 
#include <stdio.h>

int main(){
	int i, j;
	int a[10];
	for(i = 0;i < 10;i++){
		scanf("%d", &a[i]);
	}
	
	for(i = 9;i >= 1;i--){
		for(j = 0;j < i;j++){
			int temp;
			if(a[j] > a[j + 1]){
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
	printf("The sorted nubers:\n");
	for(i = 0;i < 10;i++){
		printf("%d ", a[i]);
	}
	
	return 0;
}
 
打印：
 
12 37 65 43 97 82 120 63 9 17
The sorted nubers:
9 12 17 37 43 63 65 82 97 120
 
显然，最后得到的就是已经排好序的数组。
 
三、二维数组的定义和引用
 
1.二维数组的定义
 
二维数组定义的一般形式为：
 
类型说明符 数组名[常量表达式][常量表达式];
 
例如:定义a为3X4 (3行4列)的数组，b为5X10(5行10列)的数组，如下:
 
float a[3][4], b[5][10];
 
不能写成
 
float a[3, 4], b[5, 10];
 
二维数组可理解为元素是一维数组的一维数组，例如int a[3][4];理解如下：
 
 多维数组的定义：
 例如float a[2][3][4];。
 
二维数组在内存中的存放方式示意如下：
 
 
三维数组在内存中的存放方式示意如下：
 
 
2.二维数组的引用和初始化
 
引用数组元素的表示形式：
 
数组名[下标][下标]
 
其中，下标可以是整型常量或整型表达式。
 如
 
int a[4][3], i=2, j=1;
a[2][3];
a[i][j];
a[i+1][2*j-1];
 
但a[i, j]就是错误的。
 
初始化数组的形式为：
 
数据类型 数组名[常量表达式1][常量表达式2] = {初始化数据};
 
有4种方法对二维数组初始化：
 （1）直接分行给二维数组赋初值。
 如int a[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};。
 
（2）可以将所有数据写在一个大括号内，按数组排列的顺序对各元素赋初值。
 如int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};。
 
（3）可以对部分元素赋初值。
 如int a[3][4]={{1}, {5}, {9}};，存放如下：
 
 而int a[3][4] = {1, 5, 9}是给a数组的第一个子数组a[0]的前3个元素赋值，与前者不一样。
 
也可以对各行中的某一或某些元素赋初值。
 如int a[3][4]={{1}, {0, 6}, {0, 0, 11}};，存放如下：
 
 
还可以只对某几行元素赋初值。
 如int a[4][4]={{1}, {5, 6}};，存放如下：
 
 
（4）如果对全部元素都赋初值，则定义数组时对第一维的长度可以不指定，但第二维的长度不能省。
 如，int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};等价于int a[][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};。
 
在定义时也可以只对部分元素赋初值而省略第一维的长度，但应分行赋初值。
 如int a[][4] ={{0, 0, 3}, {}, {0, 10}};，存放如下：
 
 
练习：
 如下图，一个学习小组有5个人，每个人有三门课的考试成绩。将各个数据保存到二维数组a[5][3]中，并求全组分科的平均成绩和总平均成绩。
 
 
代码如下：
 
#include <stdio.h>

int main(){
	int i, j;
	double savg[3];
	int a[5][3] = {{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87 ,90}, {76, 77, 85}};
	for(i = 0;i < 3;i++){
		int sum = 0;
		for(j = 0;j < 5;j++){
			sum += a[j][i];
		}
		savg[i] = sum / 5.0;
	}
	int tavg = 0;
	for(i=0;i<3;i++){
		printf("Average Grade:%.2f\n", savg[i]);
		tavg += savg[i];
	}
	printf("Total AVerage Grade is:%.2f", tavg / 3.0);
	
	return 0;
}
 
打印：
 
Average Grade:72.20
Average Grade:73.40
Average Grade:81.60
Total AVerage Grade is:75.33
 
练习：
 将一个二维数组行和列元素互换，存到另一个二维数组中。
 例如，将数组a[2][3]转化为数组b[3][2]如下：
 
 
代码：
 
#include <stdio.h>

int main(){
	int i, j;
	int a[5][3] = {{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87 ,90}, {76, 77, 85}}, b[3][5];
	printf("Array A:\n");
	for(i = 0;i < 3;i++){
		for(j = 0;j < 5;j++){
			printf("%4d", a[j][i]);
			b[i][j] = a[j][i];
		}
		printf("\n");
	}
	printf("Arary B:\n");
	for(i = 0;i < 5;i++){
		for(j = 0;j < 3;j++){
			printf("%4d", b[j][i]);
		}
		printf("\n");
	}
	
	return 0;
}
 
打印：
 
Array A:
  80  61  59  85  76
  75  65  63  87  77
  92  71  70  90  85
Arary B:
  80  75  92
  61  65  71
  59  63  70
  85  87  90
  76  77  85

 
练习：
 有一个矩阵，要求编写程序求出其中最大的元素，以及其所在的行号和列号。
 代码如下：
 
#include <stdio.h>

int main(){
	int i, j, row = 0, column = 0, max = 0;
	int a[5][3] = {{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87 ,90}, {76, 77, 85}};
	max = a[0][0];
	for(i = 0;i < 3;i++){
		for(j = 0;j < 5;j++){
			if(a[j][i] > max){
				max = a[j][i];
				row = j;
				column = i;
			}
		}
	}
	printf("Max=%d, in row %d column %d", max, row, column);
	
	return 0;
}
 
打印：
 
Max=92, in row 0 column 2
 
练习：
 从键盘上输入9个整数，(对照九宫格的形式，输入三行，每行输入三个数) 保存在二维数组中，按数组原来位置输出第一行和第一列的所有元素。
 如果数组如下：
 
 
则输出为：
 
 
代码如下：
 
#include <stdio.h>

int main(){
	int i, j, a[3][3];
	for(i = 0;i<3;i++){
		for(j = 0;j<3;j++){
			printf("a[%d][%d] = ", i, j);
			scanf("%d", &a[i][j]);
		}
	}
	for(i=0;i<3;i++){
		for(j=0;j<3;j++){
			if(i == 1 || j == 1){
				printf("%-6d", a[i][j]);
			}
			else{
				printf("%-6c", ' ');
			}
		}
		printf("\n");
	}
	
	return 0;
}
 
打印：
 
a[0][0] = 12
a[0][1] = 34
a[0][2] = 56
a[1][0] = 78
a[1][1] = 90
a[1][2] = 98
a[2][0] = 76
a[2][1] = 54
a[2][2] = 43
      34
78    90    98
      54

 
四、数组的应用：二分法
 
利用数组进行数据查找——二分法（也叫折半查找法）：
 适应情况：
 在一批有序数据中查找某数；
 基本思想：
 选定这批数中居中间位置的一个数与所查数比较，看是否为所找之数，若不是，利用数据的有序性，可以决定所找的数是在选定数之前还是在之后，从而很快可以将查找范围缩小一半。以同样的方法在选定的区域中进行查找，每次都会将查找范围缩小一半，从而较快地找到目的数。
 
练习：
 假设在数组a中的数据是按由小到大顺序排列的：
 -12 0 6 16 23 56 80 100 110 115。
 从键盘上输入一个数，判定该数是否在数组中，若在，输出所在序号。
 实现思路：
 
设low、mid和high三个变量，分别指示数列中的起始元素、中间元素与最后一个元素位置，其初始值为low=0,high=9,mid=4，判断mid指示的数是否为所求，mid指示的数是23，不是要找的80，须继续进行查找。
确定新的查找区间。因为80大于23，所以查找范围可以缩小为23后面的数，新的查找区间为[56 80 100 110 115]，low、mid、high分别指向新区间的开始、中间与最后一个数。实际上high不变，将low（low=mid+1）指向56，mid （mid=(low+high)/2）指向100，还不是要找的80，仍须继续查找。
上一步中，所找数80比mid指示的100小，可知新的查找区间为[56 80]，low不变，mid与high的值作相应修改。mid指示的数为56，还要继续查找。
根据上一步的结果，80大于mid指示的数56，可确定新的查找区间为[80]，此时，low与high都指向80，mid亦指向80，即找到了80，到此为止，查找过程完成。
 
注意：
 若在查找过程中，出现low > high的情况，则说明序列中没有该数，亦结束查找过程。
 
代码如下：
 
#include <stdio.h>
#define M 10

int main(){
	static int a[M] = {-12, 0, 6, 16, 23, 56, 80, 100, 110, 115};		// 定义静态变量 
	int n, low = 0, mid, high = M - 1, found = 0;
	printf("Input a number to be searched:\n");
	scanf("%d", &n);
	while(low <= high){
		mid = (low + high) / 2;
		if( n== a[mid]){
			found = 1;
			break;
		}
		else if(n > a[mid]){
			low = mid + 1;
		}
		else{
			high = mid - 1;
		}
	}
	if(found == 1){
		printf("The number %d is found, and the index is %d\n", n, mid);
	}
	else{
		printf("The number %d is not found\n", n);
	}
	
	return 0;
}
 
打印：
 
Input a number to be searched:
80
The number 80 is found, and the index is 6

 
可以看到，在程序中定义了一个静态变量；
 C程序在编译时，普通变量存放在栈区，static关键字会使变量存放在data区。
 
补充知识——内存分为四大区：
 
code区
 写的代码存放的地方。
data区
 常量、字符串和static声明的变量存放的地方，特点是不会改变，整个程序结束之后才会释放。
stack区
 普通变量存放的地方，函数调用完成后就会释放。
heap区
 malloc函数定义，由开发者自己分配。
 
还可以进一步优化：
 如果输入的数大于最大的数或小于最小的数，说明这个有序序列中不存在要寻找的数，可以直接不用循环查找，改进如下：
 
#include <stdio.h>
#define M 10

int main(){
	static int a[M] = {-12, 0, 6, 16, 23, 56, 80, 100, 110, 115};
	int n, low = 0, mid, high = M - 1, found = 0;
	printf("Input a number to be searched:\n");
	scanf("%d", &n);
	if(n < a[0] || n > a[M - 1]){
		while(low <= high){
			mid = (low + high) / 2;
			if( n== a[mid]){
				found = 1;
				break;
			}
			else if(n > a[mid]){
				low = mid + 1;
			}
			else{
				high = mid - 1;
			}
		}
		if(found == 1){
			printf("The number %d is found, and the index is %d\n", n, mid);
		}
		else{
			printf("The number %d is not found\n", n);
		}
	}
	else{
		printf("Illegal Input!!!");	
	}
	
	return 0;
}
 
打印：
 
Input a number to be searched:
a
Illegal Input!!!
 
显然，此时可以识别非法输入。
 也可以改进如下：
 
#include <stdio.h>
#define M 10

int main(){
	static int a[M] = {-12, 0, 6, 16, 23, 56, 80, 100, 110, 115};
	int n, low = 0, mid, high = M - 1, found = 0;
	printf("Input a number to be searched:\n");
	scanf("%d", &n);
	while(scanf("%d", &n) != 1){
		printf("Illegal Input!!\nPlease Input Again!!\n");
		getchar();
	}
	while(low <= high){
		mid = (low + high) / 2;
		if( n== a[mid]){
			found = 1;
			break;
		}
		else if(n > a[mid]){
			low = mid + 1;
		}
		else{
			high = mid - 1;
		}
	}
	if(found == 1){
		printf("The number %d is found, and the index is %d\n", n, mid);
	}
	else{
		printf("The number %d is not found\n", n);
	}
	
	return 0;
}
 
打印：
 
Input a number to be searched:
a
Illegal Input!!
Please Input Again!!
bc
Illegal Input!!
Please Input Again!!
Illegal Input!!
Please Input Again!!
12
The number 12 is not found

 
显然，此时如果输入有误，会提示再输入，直到输入合法，再向下执行并判断。

原文地址：矩阵运算—四维齐次空间

4D向量是由3D坐标(x,y,z)和齐次坐标w组成，写作(x,y,z,w)。
在3D世界中为什么需要3D的齐次坐标呢？简单地说明一下，在一维空间中的一条线段上取一点x，然后我们想转移x的位置，那我们应该是x'=x+k，但我们能使用一维的矩阵来表示这变换吗？不能，因为此时一维的矩阵只能让x点伸缩。但如果变成了一维的齐次空间[k 1]就很容易地做到。同样地，在二维空间中，某一图形如果不使用二维的齐次坐标，则只能旋转和伸缩，确不能平移。
     因此，我们在3D坐标中使用齐次坐标，是为了物体在矩阵变换中，除了伸缩旋转，还能够平移，如下运算：
 
既然了解了使用齐次坐标的意义，我们下一步就要了解一下齐次坐标w是什么意义。设w=1，此时相当于我们把3D的坐标平移搬去了w=1的平面上，4D空间的点投影到w=1平面上，齐次坐标映射的3D坐标是（x/w,y/w,z/w），也就是（x,y,z）。（x,y,z）在齐次空间中有无数多个点与之对应。所有点的形式是（kx,ky,kz,k），其轨迹是通过齐次空间原点的“直线”（其实每个点相当于3D的坐标世界）。
 
当w=0时，有很大的意义，可解释为无穷远的“点”，其意义是描述方向。这也是平移变换的开关，当w=0时，

此时不能平移变换了。这个现象是非常有用的，因为有些向量代表“位置”，应当平移，而有些向量代表“方向”，如表面的法向量，不应该平移。从几何意义上说，能将第一类数据当作"点"，第二类数据当作"向量"。可以通过设置w的值来控制向量的意义。