精华内容
下载资源
问答
  • 二维数组旋转

    2021-01-18 10:00:17
    二维数组旋转 周作业1: 写程序,将一个正方形二维数组旋转90度 //不是说按规律打印,是真的要把数组给旋转 //要求: 尽量不要用新的数组 (尽量减少内存开销) 这个题我可想了好久,第一想法是直接用另一个二维数组把...

    二维数组旋转

    周作业1: 写程序,将一个正方形二维数组旋转90度
    //不是说按规律打印,是真的要把数组给旋转
    //要求: 尽量不要用新的数组 (尽量减少内存开销)

    这个题我可想了好久,第一想法是直接用另一个二维数组把旋转后的数放在新的数组中,但是要求不能用新数组,后来我又想用一个一维数组做暂存数组用来实现每一行每一列的数组交换,如果实现,虽然用了一维数组但比二维数组减少内存开销。但是吧,后来我发现还是不简单,一直没想出来,索性放弃了。一个多小时后写写画画后,我突然发现了光,哈哈哈。上图:

    在这里插入图片描述

    我这里在交换时,只用了一个变量(当然也可以不用,那就内存开销更少了,这里主要是习惯,哈哈)然后,在矩阵进行上下翻转的时候,我用了一个一维数组变量(仅仅是使用了栈内存)来进行翻转。如果不考虑时间复杂度,我个人感觉就就内存开销还是非常小的。

    废话不多说,直接上代码啦:

    public class Test1 {
    	public static void main(String[] args) {
    	int[][] xx=
    	{{1, 2, 3, 4},
    	 {5, 6, 7, 8},
    	 {9, 10,11,12},
    	 {13,14,15,16}
    	};
    	//先展示原二维数组
    	for(int i=0;i<4;i++) {
    		for(int j=0;j<4;j++)
    			System.out.print(xx[i][j]+" ");
    			System.out.println();
    		}
    	
    	//根据对角线交换值
    	for(int i=xx.length-1,k=0;i>0;i--,k++) {
    		for(int j=i-1,h=k+1;j>=0;j--,h++) {
    			int temp=xx[k][j];
    			xx[k][j]=xx[h][i];
    			xx[h][i]=temp;
    		}
    	}
    	System.out.println();
    	//交换完值以后,会发现结果与我们想要的结果上下顺序颠倒了
    	for(int i=0;i<4;i++) {
    	for(int j=0;j<4;j++)
    		System.out.print(xx[i][j]+" ");
    		System.out.println();
    	}
    	
    	//我们把顺序交换成正确的
    	for(int i=xx.length-1,j=0; i>=0&&j<xx.length; i--,j++) {
    	 if(j<i) {
    		 int[] y=xx[i];
    		 xx[i]=xx[j];
    		 xx[j]=y;
    		 
    	 }
    	 else
    		 break;
    	 
    	}
    	
     System.out.println();
     //打印出我们想要的正确的结果
    	for(int i=0;i<4;i++) {
    		for(int j=0;j<4;j++)
    			System.out.print(xx[i][j]+" ");
    			System.out.println();
    		}
    }
    }
    

    在这里插入图片描述

    程序运行,没有毛病!这个方法,自己想的,如果有更好的改进,求大神斧正!

    展开全文
  • 二维数组旋转.zip

    2019-07-02 19:42:19
    给定一个二维数组,用C++实现将二维数组旋转90度,
  • 二维数组旋转的方法

    2021-04-08 14:37:58
    目标:有一个N*N的二维数组,需要将将这个二维数组旋转90度。效果如下图 思路一: 生成一个新的二维数组,然后逐个元素填写数据。最后再覆盖掉原数组。 根据上图,很容易得出坐标关系: 通过逐位遍历,即可...

    目标:有一个N*N的二维数组,需要将将这个二维数组旋转90度。效果如下图

    思路一:

    生成一个新的二维数组,然后逐个元素填写数据。最后再覆盖掉原数组。

    根据上图,很容易得出坐标关系:

    Ba_{i,j} = Aa_{(N-j-1), i} 

    通过逐位遍历,即可完成。

    #python3
    def unit_rotate_1(block_unit):
        list_len = len(block_unit)
    
        #复制一下二维数组
        tmp_unit = [[block_unit[j][i] for i in range(list_len)] for j in range(list_len)]
    
        #直接逐个坐标点替换数据
        for i in range(list_len):
            for j in range(list_len):
                block_unit[i][j] = tmp_unit[list_len - j - 1][i]

    这个方法是最直观简单的,但是缺点是需要拷贝一次二维数组,同时算法复杂度为O(n^{2})

    思路二:

    二维数组在旋转过程中,如下图分圈,数据替换发生在同一圈上。

    如果N为偶数,就有N/2圈。 如果N为基数,就一共有N/2 + 1圈,由于中心点不用替换,所以还是N/2圈

    找到以第一圈为例,找到数据交换规律。

    假如A点坐标是a_{0, j},  则:B点坐标就是a_{j, N-1},  C点坐标就是a_{N-1, N-1-j}, D点坐标就是a_{N-1-j, 0}

    第一圈的数值替换:

    #python3
    
    def unit_rotate_2(block_unit):
        unit_len = len(block_unit)
        for i in range(1):
            line_len = unit_len - i*2
            for j in range(line_len-1):
                tmp = block_unit[0][j]
                block_unit[0][j] = block_unit[line_len-1-j][0]
                block_unit[line_len-1-j][0] = block_unit[line_len-1][line_len-1-j]
                block_unit[line_len-1][line_len-1-j] = block_unit[j][line_len-1]
                block_unit[j][line_len-1] = tmp

    第二圈时,可以看成是坐标系i和j都偏移了1,同时边长N减少2, 第m圈时偏移了m, 边长n=N-m*2.   所以直接在上面柜代码中的坐标位置上加上偏移量即可。

    #python3
    
    def unit_rotate_2(block_unit):
        unit_len = len(block_unit)
        for i in range(int(unit_len/2)):
            line_len = unit_len - i*2
            for j in range(line_len-1):
                tmp = block_unit[0+i][j+i]
                block_unit[0+i][j+i] = block_unit[line_len-1-j+i][0+i]
                block_unit[line_len-1-j+i][0+i] = block_unit[line_len-1+i][line_len-1-j+i]
                block_unit[line_len-1+i][line_len-1-j+i] = block_unit[j+i][line_len-1+i]
                block_unit[j+i][line_len-1+i] = tmp
    

    这种方法时间复杂度同样为O(n^{2}),但是不用进行拷贝


    思路三:

    与思路二一样,也是分每一圈处理。不同的时直接推断出任意坐标点对应的要交换数据的其他三个点坐标。

    假设A点坐标是(i,j),  先推算D的坐标。

    D点的纵坐标与A点的横坐标有关联,关系是两者相等,即 A(i,?) ~~ D(?, i)。

    D点的横坐标与A点的纵坐标有关联,关系是 A(?, j) ~~ D(N-j-1, ?)

    所以D点坐标的之于A点就是   A(i,j) ~~ D(N-j-1, i)

    同样的,C点坐标之于D点坐标与D点之于A点坐标的关系是相同的,B点之于C也是相同的。

    所以,以同样的关系,带入替换

    #python3
    
    def unit_rotate_3(block_unit):
        n = len(block_unit)
        for i in range(int(n/2)):
            for j in range(i, n - i - 1):
                tmp = block_unit[i][j]
                block_unit[i][j] = block_unit[n-j-1][i]
                block_unit[n-j-1][i] = block_unit[n-i-1][n-j-1]
                block_unit[n-i-1][n-j-1] = block_unit[j][n-i-1]
                block_unit[j][n-i-1] = tmp

    这个方法相比方法二比较好理解一些,通过两个点的横纵坐标关系,推出普遍关系,其他点之间直接套用。

    测试代码:

    array_size = 10;
        #生成一个二维数组
        list2 = [[0 for j in range(array_size)] for i in range(array_size)]
        for i in range(len(list2)):
            for j in range(len(list2[i])):
                list2[i][j] = i*len(list2) + j
    
        #旋转前输出一次
        for i in range(len(list2)):
            print(list2[i])
        print("------------")
        
        #旋转
        unit_rotate_1(list2)
        
        #旋转后输出一次
        for i in range(len(list2)):
            print(list2[i])

    输出结果:

    展开全文
  • In a program I'm writing the need to rotate a two-dimensional array came up. Searching for the optimal solution I found this impressive one-liner that does the job:rotated = zip(*original[::-1])I'm us...

    In a program I'm writing the need to rotate a two-dimensional array came up. Searching for the optimal solution I found this impressive one-liner that does the job:

    rotated = zip(*original[::-1])

    I'm using it in my program now and it works as supposed. My problem though, is that I don't understand how it works.

    I'd appreciate if someone could explain how the different functions involved achieves the desired result.

    解决方案

    Consider the following two-dimensional list:

    original = [[1, 2],

    [3, 4]]

    Lets break it down step by step:

    >>> original[::-1] # elements of original are reversed

    [[3, 4], [1, 2]]

    This list is passed into zip() using argument unpacking, so the zip call ends up being the equivalent of this:

    zip([3, 4],

    [1, 2])

    # ^ ^----column 2

    # |-------column 1

    # returns [(3, 1), (4, 2)], which is a original rotated clockwise

    Hopefully the comments make it clear what zip does, it will group elements from each input iterable based on index, or in other words it groups the columns.

    展开全文
  • 二维数组旋转 //对数组顺时针旋转90度,返回数组temp[] public static int[][] convert(int[][] b) { int[][] temp = new int[b[0].length][b.length]; for (int i = 0; i &lt; b.length; i++) {...

    二维数组旋转

        //对数组顺时针旋转90度,返回数组temp[]
        public static int[][] convert(int[][] b) {  
                int[][] temp = new int[b[0].length][b.length];  
                for (int i = 0; i < b.length; i++) {  
                    for (int j = 0; j < b[i].length; j++) {  
                        temp[i][j]=b[b[i].length-j-1][i];  
                    }  
                }  
                return temp;  
            }  
    展开全文
  • 二维数组旋转模板

    2016-07-12 21:46:07
    //二维数组旋转还是挺简单的,只是有些时候容易搞晕了,记录一下//n行m列的矩阵旋转变为m行n列的矩阵 //顺时针 for (int i=0;i;i++){ for(int j=0;j;j++){ tmp[j][n-i-1]=s[i][j]; } } //逆时针 for ...
  • 二维数组旋转90度

    千次阅读 2016-06-13 23:01:22
    二维数组旋转90度,旋转前的位置和旋转后位置的关系是: a[i][j]=a[j][n-1-j]n是数组的列数。 leetcode第48题, Rotate Image就是要我们旋转数组。这有两种思路: 1 按照换算公式,对每个位置进行变换 2 由于...
  • 二维数组旋转90度、180度、270度

    万次阅读 2017-08-09 18:53:53
    图像处理中,很多时候要使用到二维数组旋转。本质上二维数组旋转其实就是坐标的变换,即旋转后的坐标(x,y)需要对应到原有二维数组的坐标点上,取到正确的值即可完成正确的旋转
  • python 二维数组旋转

    2018-03-06 14:45:38
    #编写一个二维数组 data = [[col for col in range(4)] for row in range(4)] #遍历这个二位数组取出其行索引 for row_index in range(len(data)):  #遍历该索引下的一维数组取出其列索引 for col_index in range...
  • /* 2.1.16 Rotate Image You are given an n × n 2D matrix representing an image. Rotate the image by 90 degrees (clockwise)....Follow up: Could you do this in-place?... 4 2 二维数组...
  • day4 二维数组旋转90度

    2017-05-20 17:59:00
    二维数组旋转其实就是数组里面的元素对调的情况;下面有一个4×4的二维数组,[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]],现在要求把二维数组转化为下列形式,[[0, 0, 0, 0], [1, 1, 1, 1], [2, 2...
  • 给定一个n×n的二维矩阵表示一个图像。 将图像旋转 90 度、180度、270度。 示例 1: 给定 matrix = [ [1,2,3], [4,5,6], [7,8,9] ], 原地旋转输入矩阵,使其变为: [ [7,4,1], [8,5,2], [9,6,3]...
  • 关于二维数组旋转90度的算法

    千次阅读 2018-08-29 15:31:36
    import java.util.Scanner; public class E { public static void main(String args[]){ Scanner scanner=new Scanner(System.in); System.out.println(&...输入一个3*3的二维数组:&quot;); int a[][]=n...
  • 面试题:将二维数组旋转90度

    千次阅读 2019-05-18 20:13:25
    1 编程题:请将下面的二维数组进行旋转90度; {11 12 13 14 15 21 22 23 24 25 31 32 33 34 35 41 42 43 44 45} 首先,旋转90度后,x,y的变换规律, (0,0)-->(0,3) (0,1)-->(1,3) (0,2)-->(2,3) (0,3...
  • iteiloylloooJuv OsoTvtnheiterseC
  • 二维数组旋转90度

    2017-10-30 10:42:35
     按顺时针旋转步 1 先按副对角线交换 2 然后水平中线对称交换 代码: void rotate(vector > &matrix) { int rows=matrix.size(); if(rows==0) return; for(int i=0;i;i++){ //副对角线交换
  • 题目: 把一个长宽都为n的二维数组旋转90度 看到过有种讨巧的办法,复杂度低,但是感觉不知道是基于什么思路想出来的,所以我还是在这里记录下我自己的方法,也是很普通的那种。 所以,长度为N, 当前点坐标为(x, ...
  • def diamond_rotate_90(array): return sq_rotate_45(diamond_rotate_45(array))
  • python 实现二维数组旋转90度

    千次阅读 2018-05-28 19:19:53
    # coding:utf8 __author__ = 'bluesli' ...旋转90度后是这样的: [0, 0, 0, 0] [1, 1, 1, 1] [2, 2, 2, 2] [3, 3, 3, 3] 实际上就是沿着对角线交换数字:但是已经交换过了的就不能再交换,所以必须让内层循环从i...
  • 二维数组逆时针旋转90度, 如 1,2,3 4,5,6 7,8,9 变成 3,6,9 2,5,8 1,4,7 但不借助临时数组
  • 二维数组旋转45度

    2013-10-15 10:49:00
    //输出三角的旋转 // for (int i = 0; i ; ++i) // { // for (int j = 0; j ; ++j) // { // printf("%d ",b[i][j]); // } // printf("\n"); // } for (int i = n,rnum = n - 1; i *n - 1; ++i,rnum--) { for ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,326
精华内容 11,330
关键字:

二维数组旋转