精华内容
下载资源
问答
  • 在三维二次混沌系统的基础上增加个含控制信号的状态变量,组成个新的非自治超混沌四维二次系统。该系统的基本动力学特性的变化主要依赖于控制信号频率的改变。通过系统的Lyapunov指数谱、分岔图及数值仿真表明,在...
  • 提出了四维二次超混沌系统,通过Lyapunov指数计算验证了系统的混沌特性,并给出了系统的硬件实现电路.系统的Matlab仿真波形与所设计电路的Muhisim仿真波形完全一致,证明了系统的可实现性.并且利用该混沌信号...
  • 针对Poisson方程Dirichlet边值问题,首先建立了四维投影型插值算子,并应用它得到了正规剖分下四维张量积二次矩形有限元的弱估计,在此基础上,结合四维离散Green函数的估计,研究四维张量积二次矩形有限元解及梯度...
  • 用new创建多维数组时,最后需要用delete,但是我在delete时遇到了麻烦,实在不能再浪费...一维数组 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] = {

    用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;


    就先到这里吧



    展开全文
  • 认知四维空间

    千次阅读 2012-08-12 21:30:42
    昨天在个大牛的博客(Google搜索“大牛的博客”,第个就是他)的篇博文里,看到了四维空间的认知,好奇心驱使就查了些wiki,百科之类,看了些视频下面试着来阐述阐述,加强下自己的理解。 维数类比 ...

     转载请注明出处:http://blog.csdn.net/zbf8441372

    闲着也是闲着,就来扯扯淡。

    昨天在一个大牛的博客(Google搜索“大牛的博客”,第一个就是他)的一篇博文里,看到了四维空间的认知,好奇心驱使就查了些wiki,百科之类,看了些视频下面试着来阐述阐述,加强下自己的理解。


    维数类比

    阿伯特的Flatland里描绘了生活在二维空间的人,在他们眼里,活在三维空间的人就像是神。可以想象,生活在三维空间的人可以看到二维世界里的封闭形状内部的东西。二维世界只有水平方向,他们的生活必须遵从一定的顺序规律,才能区分识别一些东西。那生活在四维世界的人是怎么看我们三维世界的人的呢?你应该会觉得,真的有四维世界吗?四维世界是被数学家证实的,但有人说四维世界的存在就意味着存在平行宇宙,这是推测却没有得到证实。只能说,四维世界是无数个三维世界组成的。如果把第四维看成是时间的话,这点也许更好理解。不过时间只是一种说法,只是闵式空间里的说法。

    我觉得这第四维是我们无法感知的,就像二维人无法感知我们的第三维——高度。其实,时间这一维也可以是二维世界的第三维。为什么?将一个小人儿画在纸上,是一个二维的图像。在多张纸上画若干个小人儿,再翻动纸张,便跑动起来了,成为了一个三维世界中的人。这样看,二维世界的时间就成为了第三维。所以时间这一维就是一种n+1的说法。


    四维图形

    四维世界是可以由我们三维世界的人认知的,只是需要一些想象力。大家可以看看这里。hypercube是四维中的“立方体”。看了之后就会明白,四条全等的一维直线构成一个二维的正方形,六个全等的正方形拼成一个三维的立方体,八个全等的立方体组成一个四维的超方体,而且他也是可以展开,折叠的。

    真正的超方体应该是动态的:

    两个正方体拼成的,数一数,有16个顶点,32条边(24+8)。四个面共享一个顶点,四条边共享一个顶点,正好是四个相互垂直的维坐标系。每个点由(0,1,0,1)四维表示。wiki上有更多数学性的向量解释。

    超方体不是最基本的四维图形,最基础的应该是类似四面体那样的四维图形。它由5个点组成,每个面是三角形,可以看看这里的视频,还有四维世界里的球。反正我没怎么看懂四维里的球。


    四维世界

    昨天晚上睡觉前想了好久,如果存在四维世界的话,四维世界是什么样的?里面的物种呢?

    第一个问题:一维的无数个点组成二维的线和面,二维的无数个线面组成三维的空间,这样推理,四维就应该是三维的无数个空间组成的。点,线,面可以“叠加”,空间怎么“叠加”?将三次元世界缩成点,再拉成线,就是第四次元。所以也许在四维世界里,可以像三维看二维一样,四维可以看到三维世界里任意时间点的人和事,无数个三维空间一旦“叠加”起来,我想象是这样的:举个例子,你自己在某些时刻将分支出几个你自己,走向不同位置,做出不同举动,有点像无数个平行世界。

    第二个问题:基于上面这样的四维世界,我认为四维世界的物种肯定不是人。二维世界里的生物可以成为人吗?他们连高度都没有,只是一种物种。类似,人只是存在于三维世界的物种。我想象,三维世界的一个人的生命历程将成为四维世界的一个物种,四维物种可以直接看到这个历程中每个时间点发生的所有事,也就是说,我们的时间组成了第四维,到四维世界里不再是时间,而变成了一种存在,一种可以观察,测量的存在,就像二维的时间变成三维的高度一样。


    更高维的世界

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


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



    展开全文
  • C语言入门系列之6.一维和二维数组

    千次阅读 2020-04-27 10:18:31
    二维数组的定义格式为类型说明符 数组名[常量表达式][常量表达式];,可理解为元素是一维数组的一维数组;引用形式是数组名[下标][下标],可以有多种方式进行初始化。利用二分法查找数据可以大大加快查询速率;内存...

    一、数组的概念

    有如下几组数据:

    • 学生的学习成绩
    • 银行的账单
    • 一行文字

    这些数据的特点是:

    • 具有相同的数据类型
    • 使用过程中需要保留原始数据 。

    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}};,存放如下:
    二维数组的初始化-方式三1
    int a[3][4] = {1, 5, 9}是给a数组的第一个子数组a[0]的前3个元素赋值,与前者不一样。

    也可以对各行中的某一或某些元素赋初值。
    int a[3][4]={{1}, {0, 6}, {0, 0, 11}};,存放如下:
    二维数组的初始化-方式三2

    还可以只对某几行元素赋初值。
    int a[4][4]={{1}, {5, 6}};,存放如下:
    二维数组的初始化-方式三3

    (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
    从键盘上输入一个数,判定该数是否在数组中,若在,输出所在序号。
    实现思路:

    1. 设low、mid和high三个变量,分别指示数列中的起始元素、中间元素与最后一个元素位置,其初始值为low=0,high=9,mid=4,判断mid指示的数是否为所求,mid指示的数是23,不是要找的80,须继续进行查找。
    2. 确定新的查找区间。因为80大于23,所以查找范围可以缩小为23后面的数,新的查找区间为[56 80 100 110 115],low、mid、high分别指向新区间的开始、中间与最后一个数。实际上high不变,将low(low=mid+1)指向56,mid (mid=(low+high)/2)指向100,还不是要找的80,仍须继续查找。
    3. 上一步中,所找数80比mid指示的100小,可知新的查找区间为[56 80],low不变,mid与high的值作相应修改。mid指示的数为56,还要继续查找。
    4. 根据上一步的结果,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
    
    

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

    展开全文
  • 矩阵运算—四维空间

    千次阅读 2018-02-24 11:06:46
    原文地址:矩阵运算—四维空间4D向量是由3D坐标(x,y,z)坐标w组成,写作(x,y,z,w)。在3D世界中为什么需要3D的齐坐标呢?简单地说明一下,在维空间中的条线段上取一点x,然后我们想转移x的位置,那...

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

    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的值来控制向量的意义

    展开全文
  • 走进四维空间-我们如何理解时空

    千次阅读 多人点赞 2019-02-14 20:33:15
    张飞鸟,性子很燥,养不过夜的,我感觉疯子就是张飞鸟,天天骂骂咧咧的,而且还会摔倒… 大年初三看了《流浪地球》,非常...同时开个脑洞,如果宇宙是四维的,三体人会不会就是学会脱水的地球人呢?只不过三体人...
  • 《走进四维空间-我们如何理解时空》:*** https://blog.csdn.net/dog250/article/details/87252892 感觉有点太主观了,决定趁着周末再整理一下。 这是万幸的周末,家里的女人们都去闲逛了,只剩下我,安安,还有嘟狗
  • 计算机图形学里面对于四维坐标的描述并不是非常容易理解,看到这篇文章基本把齐坐标及其作用讲清楚了,学习一下! 4D向量是由3D坐标(x,y,z)坐标w组成,写作(x,y,z,w)。 在3D世界中为什么需要3D的齐...
  • 庞大的数据复杂的计算过程给用户带来了极大的不便,MATLAB自产生之日起就具有方便的数据可视化功能,新版本中更是做出了很大的改进完善,本文基于MATLABR2015b通过实例来展示绘制维、三维和四维以及图形编辑与...
  • 我们证明了由纯二次作用给定的四维尺度不变重力存在个临界条件
  • 画圆为方这是维的办法解决维的几何问题,金字塔是三维的,但表达的是球体的扩大缩小,是动态的意图,这就需要四维来解读。图表是用代表的方法解读几何结果,螺旋比圆高明,是因为它把圆的路线动态起来了,增加了...
  • “ 我们曾经仰望浩瀚的星空,思考自身的存在。”——《 星际穿越 》今天我们来聊聊维度。...大家有没想过,我们所处的宇宙,其实是个多维宇宙。但可惜的是人类仅仅只是三生物...
  • 一维数组和二维数组前缀

    千次阅读 2017-09-27 20:47:22
    原创地址如下 http://blog.csdn.net/XT_NOI/article/details/72666275 (一维数组) ...一维前缀维护是种基础的小算法,该算法用我们所熟知的数列求和方式优化我们的某些查询操作,是种动态规划的思
  • 四维空间的人类

    2012-12-21 10:38:59
    From:果壳网_小小序 ...么可以确定这些科幻小说的人肯定在四维的空间内部。假设我们在这样的个空间。 那么可以产生一些很神奇的事情。而且很多科幻或者现实的“很神奇”的事情都可以得到 解释。
  • 这是笔者对于自然日情况下均线参数的四维全息的定义。 这样定义的缘由是什么呢?是针对如下这样的数学拟合现实。 这是用傅立叶函数分解的方式拟合的上证指数的段行情。上图中的白线是自然日的36天均线。而下图中...
  • 人类作为三维物体可以理解四维时空(三个空间维度和一个时间维度)但无法认识以及存在于四维空间,因为人类属于第三个空间维度生物。通常所说时间是第四维四维时空下的时间维度。四维空间的第四维指与x,...
  • 步,我们利用一些有趣的通量组合重写了四维标量势,我们将其称为新的广义通量轨道。 在调用了几个非平凡的辛关系之后,在第步中,我们进一步将标量势的所有部分重新排列为个完全“辛式公式”,其中仅涉及辛...
  • 前缀二维前缀与差分的小总结

    万次阅读 多人点赞 2018-08-17 16:21:35
    在了解二维前缀之前,我们首先需要了解一下什么是前缀。 如果我给你串长度为n的数列a1,a2,a3......an,再给出m个询问,每次询问给出L,R两个数,要求给出区间[L,R]里的数的,你会怎么做,若是没有了解过前缀...
  • "Funct_Bezier.m" 个函数,用于评估绘制给定个控制点间隔的 2D 三贝塞尔曲线。 利用霍纳规则进行高效计算。 给出了个简单的测试程序“TestCubicBezier.m”
  • 本实例介绍应用二维静磁场求解器(Magnetostatic Solver)对台三相极永磁同步电机进行建模,求解后处理。 创建2D工程 1. 点击PROJECTS创建个新的工程。 2. 在出现的窗口点击New, 显示窗口如下: ...
  • 切实感受四维空间

    2006-02-01 14:01:00
     我跟一些人描述过四维空间。但个由八个全等立方体拼接组成的广义空间确实让活在三维世界的人难以想像。正如生活在维空间里的人无法想像在个扁平的面里怎么可能存在六个全等正方形互相拼接组成的立体形状...
  • 例如,架飞机由机翼、机尾、机身、发动机其他部分组成,每部分又可描述成第级组合体,如此等等,在层次结构中逐层往下描述。因此,该飞机可用那些部件及附属于每个部件的“建模”变换来描述,这些变换指出...
  • 矩阵运算------四维空间

    万次阅读 2009-03-06 18:43:00
    4D向量是由3D坐标(x,y,z)坐标w组成,写作(x,y,z,w)。在3D世界中为什么需要3D的齐坐标呢?简单地说明一下,在一维空间中的条线段上取一点x,然后我们想...同样地,在二维空间中,某图形如果不使用二维的齐
  • 自我消遣之:四维权限管理模型

    万次阅读 热门讨论 2004-08-24 17:25:00
    原谅我自己取了什么“四维权限管理模型”“访问控制矩阵(ACM)”这样难听的名字,还多少有故弄玄虚之嫌,但我在半年前只有这样的见识。 1、访问控制矩阵(ACM)说明:任意对系统使用者产生价值的用例中的操作均在...
  • 这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入段漂亮的代码片生成个适合你的列表创建个表格设定内容居中、居左、...
  • 因此,实际上变换坐标位置仅需完成4乘法4加法。一旦把单个矩阵连接起来计算出复合矩阵的元素值,这就是任何变换序列所需计算的最大数目。假如没有合并,那么每次都要使用个单独的变换,则计算的数目将大大...
  • 通过对二次Hamilton系统的四参数的开折,得到个保证系统存在极限环的四维参数区域,区域的部分边界为庞加莱分枝、同宿环分枝、异宿环分枝、鞍结点分枝.
  • 二维数组和二维指针

    千次阅读 2016-01-01 15:54:52
    二维数组和二维指针 题号 题目 答案 解析 1 以下程序的输出结果是______。 main() { int i,x[3][3]={9,8,7,6,5,4,3,2,1},*p=&x[1][1];  for(i=0;i } A、52   ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 190,509
精华内容 76,203
关键字:

一次四维和二次四维的区别