MxN螺旋矩阵(由外向内)

最新推荐文章于 2022-11-23 10:25:54 发布
原创 最新推荐文章于 2022-11-23 10:25:54 发布 · 5k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#面试题 #精选题 #MxN螺旋矩阵 #由外向内

本文介绍如何构建MxN螺旋矩阵及按顺时针方向访问的方法，包括如何计算特定坐标下的值，提供C++代码示例。

问题描述

按顺时针方向构建一个MxN的螺旋矩阵（或按顺时针方向螺旋访问一个MxN的矩阵）：在不构造螺旋矩阵的情况下，给定坐标i、j值求其对应的值f(i, j)。如对11x7 矩阵， f(4, 0) = 29  f(4, 1) = 54 f(4, 3) = 74  f(4, 4) = 61


解析

对MxN矩阵，最先访问最外层的MxN的矩形上的元素，接着再访问里面一层的(M-2)x(N-2)矩形上的元素.最后可能会剩下一些元素，组成一个点或一条线。对第i个矩阵（i=0,1,2.....）,4个顶点的坐标为：

(i,i) ------------------------------(i, n-1-i)

    |                                                    |

    |                                                    |

 (m-1-i)---------------------------(m-1-i,n-1-i)

要访问该矩形上的所有元素，只须用4个for循环，每个循环访问一个点和一边条边上的元素即可。另外，要注意对最终可能剩下的1xK或Kx1矩阵再做个特殊处理。代码：

inline void act(int t) { 
　　printf("%3d ", t); 
}

const int small = col<row?col:row;
const int count = small/2;

for (int i = 0; i < count; ++i) {
    const int C = col-1-i;
    const int R = row-1-i;

    for (int j = i; j < C; ++j)
　　　　　act(arr[i][j]);
    for (int j = i; j < R; ++j) 
　　　　　act(arr[j][C]);
    for (int j = C; j > i; --j) 
　　　　　act(arr[R][j]);
    for (int j = R; j > i; --j) 
　　　　　act(arr[j][i]);
 }

if (small & 1) {
    const int i = count;
    if (row <= col){
　　　　for (int j = i; j < col-i; ++j)
　　　　　　act(arr[i][j]);
    else{
　　　　for (int j = i; j < row-i; ++j) 
　　　　　　act(arr[j][i]);
　　}
}
如果 只是构建螺旋矩阵的话，稍微修改可以实现4个for循环独立： 

const int small = col < row ? col : row;

 const int count = small / 2;

 for (int i = 0; i < count; ++i) {
    const int C = col-1-i;
    const int R = row-1-i;
    const int cc = C-i;
    const int rr = R-i;

    const int s = 2*i*(row+col-2*i)+1;
    for (int j = i, k = s; j < C; ++j) arr[i][j] = k++;
    for (int j = i, k = s+cc; j < R; ++j) arr[j][C] = k++;
    for (int j = C, k = s+cc+rr; j > i; --j) arr[R][j] = k++;
    for (int j = R, k = s + cc * 2 + rr; j > i; --j) arr[j][i] = k++;

 }
 if (small&1) {
    const int i = count;
    int k = 2*i*(row+col-2*i)+1;
    if (row <= col){
       for (int j = i; j <col-i; ++j) arr[i][j] = k++;
    } 
    else{
       for (int j = i; j <row-i; ++j) arr[j][i] = k++;
    } 
 }

关于s的初始值取2*i*(row+col-2*i)+1

由于C++的二维数组是通过一维数组实现的。二维数组的实现一般有下面三种：1)静态分配足够大的数组；2)动态分配一个长为m*n的一维数组；3)动态分配m个长为n的一维数组，并将它们的指针存在一个长为m的一维数组。二维数组的不同实现方法，对函数接口有很大影响。给定坐标直接求值f(x,y);如前面所述，对第i个矩形（i=0, 1, 2 …），4个顶点的坐标为：

(i,i) ------------------------------(i, n-1-i)

    |                                                    |

    |                                                    |

 (m-1-i)---------------------------(m-1-i,n-1-i)

对给定的坐标(x,y)，如果它落在某个这类矩形上，显然其所在的矩形编号为：k = min{ x,y,m-1-x,n-1-y};MxN矩阵删除访问第k个矩形前所访问的所有元素后，可得到(m-2*k)*(n-2*k)矩阵，因此已访问的元素个数为：m*n-(m-2*k)*(n-2*k)=2*k*(m+n-2*k)，因而(k,k)对应的值为：T(k) = 2*k*(m+n-2*k)+1.对某个矩形，设点(x, y)到起始点(k,k)的距离d = x-k + y-k = x+y-2*k;① 向右和向下都只是横坐标或纵坐标增加1，这两条边上的点满足f(x, y) = T(k) + d;② 向左和向下都只是横坐标或纵坐标减少1，这两条边上的点满足f(x, y) = T(k+1) - d.如果给定坐标的点(x, y)，不在任何矩形上，则它在一条线上，仍满足f(x, y) = T(k) + d

int getv(int row, int col, int max_row, int max_col){ // row < max_row, col < max_col
    int level, diatancce;
    int start_value, next_vlue;

    level = min(min(row, max_row - 1 - row), min(col, max_col - 1 - col));
    distance = row + col - level * 2;
    start_value = 2 * level * (max_row + max_col - 2 * level) + 1;
 
    if (row == level || col == max_col - 1 - level ||
       (max_col < max_row && level * 2 + 1 == max_col))
           return start_value + distance;
    next_value = start_value + (max_row + max_col - 4 * level - 2) * 2;
    
    return next_value - distance;
}

特别说明

上面的讨论都是基于MxN矩阵的，对于特例NxN矩阵，可以做更多的优化。比如构建螺旋矩阵，如果n为奇数，则矩阵可以拆分为几个矩形加上一个点。前面的条件判断可以优化为：if(small&i) act[count][count];甚至可以调整4个for循环的遍历元素个数（前面代码，每个for循环遍历n-1-2*i个元素，可以调整为：n-2*i，n-1-2*i, n-1-2*i,n-2-2*i）从而达到省略if判断。

代码：

//螺旋矩阵，给定坐标直接求值 
#include<iostream>
#include<algorithm>

using std::min;
using std::cout;

/*
int getv2(int row, int col, int max_row, int max_col){ // row < max_row, col < max_col
    int level,distance;
    int start_value, next_value;
   
    level = min(min(row, max_row - 1 - row), min(col, max_col - 1 - col));
    distance = row + col - level * 2;

    start_value = 2 * level * (max_row + max_col - 2 * level) + 1;

    if (row == level || col == max_col - 1 - level) 
       return(start_value + distance);

    //++level; int next_value = 2 * level * (max_row + max_col - 2 * level) + 1;
    next_value = start_value + (max_row + max_col - 4 * level - 2) * 2;

    if (next_value > max_col * max_row) 
       return(start_value + distance);
    
    return (next_value - distance);
}*/

int getv(int row, int col, int max_row, int max_col){ // row < max_row, col < max_col
    int level = min(min(row, max_row - 1 - row), min(col, max_col - 1 - col));
 int distance = row + col - level * 2;
 int start_value = 2 * level * (max_row + max_col - 2 * level) + 1;
 if (row == level || col == max_col - 1 - level || (max_col < max_row && level * 2 + 1 == max_col))
    return start_value + distance;

 //++level; int next_value = 2 * level * (max_row + max_col - 2 * level) + 1;
 int next_value = start_value + (max_row + max_col - 4 * level - 2) * 2;
 return next_value - distance;

} 

int main( ){
  int test[][2] = {{5, 5}, {5, 7}, {7, 5}, {4, 4}, {4, 6}, {6, 4}};
  const int sz = sizeof(test) / sizeof(test[0]);
  for (int k = 0; k < sz; ++k) {
    int M = test[k][0];
    int N = test[k][1];  

    for (int i = 0; i < M; ++i) {
      for (int j = 0; j < N; ++j)
        cout.width(4), cout << getv(i, j, M, N) << " ";
     cout << "\n";
    }
    cout << "\n";
 }
}

完整的代码

//螺旋矩阵 

#include<iostream>
int counter = 0; 
inline void act(int& t){
 //std::cout.width(3), std::cout << t;
 t = ++::counter;
}

void act_arr(int *arr, int row, int col, int max_col){ //col < max_col
 const int small = col < row ? col : row;
 const int count = small / 2;
 int *p = arr;

 for (int i = 0; i < count; ++i) {
    const int C = col - 1 - 2 * i;
    const int R = row - 1 - 2 * i;
    for (int j = 0; j < C; ++j) act(*p++);
    for (int j = 0; j < R; ++j) act(*p), p += max_col;
    for (int j = 0; j < C; ++j) act(*p--);
    for (int j = 0; j < R; ++j) act(*p), p -= max_col;
    p += max_col + 1;
 }
 if (small & 1) {
    const int i = count;
    if (row <= col) for (int j = 0; j < col - 2 * i; ++j) act(*p++);
    else for (int j = 0; j < row - 2 * i; ++j) act(*p), p += max_col;
 }
} 

void act_arr(int* arr[], int row, int col){
 const int small = col < row ? col : row;
 const int count = small / 2;
 for (int i = 0; i < count; ++i) {
    const int C = col - 1 - i;
    const int R = row - 1 - i;
    for (int j = i; j < C; ++j) act(arr[i][j]);
    for (int j = i; j < R; ++j) act(arr[j][C]);
    for (int j = C; j > i; --j) act(arr[R][j]);
    for (int j = R; j > i; --j) act(arr[j][i]);
 }

 if (small & 1) {
    const int i = count;
    if (row <= col) for (int j = i; j < col - i; ++j) act(arr[i][j]);
    else for (int j = i; j < row - i; ++j) act(arr[j][i]);
 }
}

void act_arr_2(int* arr[], int row, int col){
 const int small = col < row ? col : row;
 const int count = small / 2;
 for (int i = 0; i < count; ++i) {
    const int C = col - 1 - i;
    const int R = row - 1 - i;
    const int cc = C - i;
    const int rr = R - i;
    const int s = 2 * i * (row + col - 2 * i) + 1;
    for (int j = i, k = s; j < C; ++j) arr[i][j] = k++;
    for (int j = i, k = s + cc; j < R; ++j) arr[j][C] = k++;
    for (int j = C, k = s + cc + rr; j > i; --j) arr[R][j] = k++;
    for (int j = R, k = s + cc * 2 + rr; j > i; --j) arr[j][i] = k++;
 }
if (small & 1) {
    const int i = count;
    int k = 2 * i * (row + col - 2 * i) + 1;
    if (row <= col) for (int j = i; j < col - i; ++j) arr[i][j] = k++;
    else for (int j = i; j < row - i; ++j) arr[j][i] = k++;
 }
}

void print_arr(int *arr, int row, int col, int max_col){ //col < max_col
 for (int i = 0, *q = arr; i < row; ++i, q += max_col) {
    for (int *p = q; p < q + col; ++p)
     std::cout.width(4), std::cout << *p;
    std::cout << "\n";
 }
 std::cout << "\n";
}

void print_arr(int* a[], int row, int col){ //col < max_col
 for (int i = 0; i < row; ++i) {
    for (int j = 0; j < col; ++j)
     std::cout.width(4), std::cout << a[i][j];
    std::cout << "\n"; 

 } 
 std::cout << "\n";
}

void test_1(){
 const int M = 25;
 const int N = 25;
 int a[M][N];

 int test[][2] = {{5, 5}, {5, 7}, {7, 5}, {4, 4}, {4, 6}, {6, 4}};
 const int sz = sizeof(test) / sizeof(test[0]);
 std::cout << "Test 1:\n";

 for (int i = 0; i < sz; ++i) {
    int row = test[i][0];
    int col = test[i][1];
    if (row < 0 || row > M) row = 3;
    if (col < 0 || col > N) col = 3;

    ::counter = 0;
    act_arr(&a[0][0], row, col, N);
    print_arr(&a[0][0], row, col, N);
 }
}

void test_2(){

 int test[][2] = {{5, 5}, {5, 7}, {7, 5}, {4, 4}, {4, 6}, {6, 4}};

 const int sz = sizeof(test) / sizeof(test[0]);
 std::cout << "Test 2:\n";
 for (int i = 0; i < sz; ++i) {
    int row = test[i][0];
    int col = test[i][1]; 

    int **arr = new int*[row];
    for (int i = 0; i < row; ++i) arr[i] = new int[col];
    ::counter = 0;

    act_arr(arr, row, col);
    print_arr(arr, row, col);
    for (int i = 0; i < row; ++i) delete[] arr[i];
    delete[] arr; 

 }
}

int main( ){
    test_1();
    test_2();
}

C语言经典NXN螺旋矩阵(由外向内)代码

//N阶螺旋矩阵
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int N,i,j,n,num=1;
    int a[10][10]={0};
    printf("输入你要输出的几阶中断:");
    scanf("%d",&N);
    
     for(n=0;n<=N/2;n++)
     {
         for(j=n;j<=N-n-1;j++)
         a[n][j]=num++;
         
         for(i=n+1;i<N-n-1;i++)
         a[i][N-n-1]=num++;
         
         for(j=N-n-1;j>n;j--)
         a[N-n-1][j]=num++;
         
         for(i=N-n-1;i>n;i--)
         a[i][n]=num++;
     }    
     //输出螺旋矩阵 
     for(i=0;i<N;i++)
     {
         for(j=0;j<N;j++)
         printf("%2d ",a[i][j]);
     
         printf("\n");
      }    
     
     system("pause");
     return 0;
}

思路是这样的，刚开始很容易想到顺时针赋值，如下图为5阶：分为四个方向顺时针赋值。每个方向负责相同数量的元素。

但这样，后来发现当N为基数时，最中心一个数不能被赋值。 所以改为还是顺时针赋值，只是->方向多负责一个元素，右| 方向少负责一个元素

输出结果为：

　

====================================================================
转载请注明出处：http://blog.csdn.net/utimes/article/details/8779143
====================================================================
螺旋矩阵 （M*N） 由外向内输入 完整注释
05-29
实现由外向内螺旋矩阵的操作 矩阵大小为M*N 实现方法为递归调用 有完整注释，看起来比较轻松
输出任意n*m阶的螺旋矩阵
04-23
如输入n=3,m=4,则输出 1 2 3 4 10 11 12 5 9 8 7 6 输入n=4，m=5，则输出 1 2 3 4 5 14 15 16 17 6 13 20 19 18 7 12 11 10 9 8 输入n=4，m=4，则输出 1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7
MxN阶螺旋矩阵
cool_navy2011的专栏
09-21 1587
闲的无聊翻到老早的草稿纸上有乱画的螺旋矩阵的算法，虽然已过了纠结算法的时候，写出来打发时间吧，短短五十行代码，么想到也耗了一下午时间。 算法部分不过一个switch，有效语句不过十几行。变量名注释都很清楚，有需要的可以瞧瞧。也瞧过网上其他人的，太复杂，没耐心看完。 /////////////////////////////////////////////////////////////////
构造螺旋矩阵 n*m
还我笑颜
09-16 1357
构造n * m的螺旋矩阵 讲解：https://wenku.baidu.com/view/7253dc78a26925c52cc5bff4.htm #include <bits/stdc++.h> using namespace std; int getnum(int n, int m, int x, int y) { int lev = min(min(x, n - 1 - ...
螺旋格式输出数据
weixin_34320724的博客
05-25 282
问题：(问答题) 编程输出以下格式的数据。    When i=0 1 When i=1 7   8   96   1   25   4   3 When i=2 21  22  23  24  2520    7    8    9  1019    6    1    2  1118    5    4    3  1217  16  15  14  13   1、Python： ...
剑指offer - 矩阵从外到里遍历
qq_22498427的博客
03-09 320
题目描述 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10. 输入为n*m矩阵，返回一个list 思路： 一开始想用递归来着，结果发现递归没法解决矩阵行列 长度不想等的...
matlab_3d彩色条形图的源代码，为MxN矩阵中的每个条形创建具有任意颜色的三维条形图
05-22
在MATLAB中，3D彩色条形图是一种用于可视化MxN矩阵数据的有效方式，它允许用户通过颜色和高度来直观地理解数据的分布。这种图表类型尤其适用于展示多维数据，例如在地理信息系统、科学计算或数据分析中。本文将深入...
matlab创建一个mxn空矩阵
04-30
在MATLAB中，可以使用以下语法创建一个mxn空矩阵： ```matlab A = zeros(m,n); ``` 这将创建一个mxn大小的矩阵A，其中所有元素都为0。您还可以使用`ones`函数来创建所有元素都为1的矩阵，如下所示： ```matlab B ...
6个MxN的矩阵怎么构建成一个MxNx3的矩阵MTALB程序
05-05
2. 将原始的6个MxN的矩阵按照一定的规则填充到MT中，使得MT的第三维中的第1个矩阵对应原始矩阵中的第1个矩阵，第3维中的第2个矩阵对应原始矩阵中的第2个矩阵，以此类推。 具体实现可以参考以下MATLAB代码： ```...
求 N* M阶螺旋矩阵
qq_40298768的博客
12-02 1225
问题描述 按顺时针方向构建一个MxN的螺旋矩阵（或按顺时针方向螺旋访问一个N* M的矩阵）例如：N=4， M=5时 1 2 3 4 5 14 15 16 17 6 13 20 19 18 7 12 11 10 9 8 思路 从[1, 0]开始，按照→，↓，←，↑4个方向， 判断该点的值是否为0， 若为0，依则填入count++（初值为...
由外向内的螺旋矩阵
buluMrCai的博客
10-29 579
#include #include using namespace std; int main() {     while(1)     {         int n;         cout         cin >> n;         int a[n][n];         int circle = n - 1 , col = -1 , row
常考数据结构与算法:螺旋矩阵m*n
m0_37564426的博客
03-17 832
题目描述 给定一个m x n大小的矩阵（m行，n列），按螺旋的顺序返回矩阵中的所有元素。 解题思路： 使用计算输出的方法，先处理上面一行，再处理右面一列，再处理下面一行，再处理左边一列，这是一个处理流程，一直这样操作，直到所有的元素都处理完成。 示例: 输入 [[1,2,3],[4,5,6],[7,8,9]] 返回值 [1,2,3,6,9,8,7,4,5] import java.util.ArrayList; public class SpiralOrderMe { ..
由内到外的螺旋矩阵
wy530247936的专栏
03-17 1454
思路： 红线方程y=x，绿线方程y=-x+4，4为矩形边长。 两条直线将区域分为四个部分，划分好每个区域的边界值，每个区域的坐标变化规律有四种，x++，y++，x--，y--，接下来仔细分析就能得到算法： void SpiralArray(int size, int** ar) {        int a=size/2*2+1;//保证
54. 螺旋矩阵
pkgray的专栏
08-02 456
 给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。 示例 1: 输入: [  [ 1, 2, 3 ],  [ 4, 5, 6 ],  [ 7, 8, 9 ] ] 输出: [1,2,3,6,9,8,7,4,5] 示例 2: 输入: [   [1, 2, 3, 4],   [5, 6, 7, 8],   [9,10,11,12] ] 输出:...
螺旋矩阵n * m的规律
northsky0307的博客
04-18 924
思路：将矩阵分成嵌套的很多个圈；这样每一个圈的相对位置的值都和第一个位置的值有关系。分别求出每一个圈的第一个位置就好啦！ #include<bits/stdc++.h> using namespace std; #define pb emplace_back #define mp make_pair #define eps 1e-8 typedef long long ll; c...
mxn插头_如何设置Eufy智能插头
09-16 275
mxn插头There are plenty of smart plugs out on the market, but if you want a decently cheap option that’s reliable, Eufy’s Smart Plug and Smart Plug Miniare worth checking out. Here’s how to set them up...
英文版线性代数笔记1
karshey的博客
12-04 2618
是一个给自己期中复习做的笔记。 第二课 关于矩阵 mxn的矩阵，是m行n列； 先行后列，如A2，1 就是3； 单位矩阵： 关于向量 向量：有序有限的一列数字； 定义： 了解列向量，横向量，零向量。 向量可以是一组解。 关于单位向量 只有一个1，其他都是0；哪里是1，下标就是几。 向量的四则运算 加： 标量乘以向量： 第三课 高斯消元计算器 计算器网址 Euclidean Plane（欧几里得平面） 定义： 运算： 关于norm范数： 范数的性质： 类比高中学的向量。 第四
MxN螺旋矩阵(由内向外)
松子茶的专栏
04-12 7669
问题描述按顺时针方向构建一个m * n的螺旋矩阵（或按顺时针方向螺旋访问一个m * n的矩阵）：在不构造螺旋矩阵的情况下，给定坐标i、j值求其对应的值f(i, j)。如对6 * 6矩阵， f(2, 0) =19  f(2, 1) = 6。 编程实现输出这个矩阵问题,我是采用模拟进行构造的，可以看到从1开始的方向变化始终是 right->down->
3. 布线问题
qq_44651930的博客
11-23 1637
印刷电路板将布线区域划分成n*m个方格阵列，精确的电路布线问题要求确定连接方格a的中点到方格b的中点的最短布线问题。为了避免线路相交，已布了线的方格做了封锁标记，其他线路不允许穿过被封锁的方格。然后输入n行，每行m个数，0或1，表示电路板的封锁情况，1表示电路封锁。第二行包括两个数，row1，col1，表示起始点的行号和列号。第三行包括两个数，row2，col2，表示目标点的行号和列号。第一行包括两个数，n，m表示电路板是一个n*m的方格阵列。步在起始点，输出到达目标点的步数）【输出形式】输出只有一行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值