二维数组的旋转与翻转（C++）（下（这是仔细讲解））

于 2024-10-07 14:44:39 发布
阅读量547 收藏 5
点赞数 19
分类专栏： C++课程讲解 文章标签： c++ java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjxxlsx/article/details/142740424
版权

一、二维数组旋转与翻转的基本概念（C++）

（一）二维数组旋转的概念

在C++中，二维数组的旋转是指将数组中的元素按照一定的规则进行重新排列，从而实现整个数组或者部分数组在平面上的顺时针或者逆时针旋转。这就好比将一个矩形（以二维数组表示）在平面上绕着某个点进行转动。 例如，对于一个3x3的二维数组（可以看作是一个3行3列的矩阵）：

1 2 3
4 5 6
7 8 9

如果进行顺时针90度旋转后，它将变成：

7 4 1
8 5 2
9 6 3

这里的旋转涉及到元素位置的对应关系的转换。从整体的概念理解，它改变了数组元素的行列关系。在更深入的理解上，这种旋转操作实际上是对数组元素坐标的一种变换操作。设原始数组为A，旋转后的数组为B，以顺时针旋转为例，元素A[i][j]在旋转后将变为B[j][n - 1 - i]（其中n为数组的阶数，这里假设数组是n x n的正方形数组）。这一转换关系是通过分析每个元素在旋转前后的位置得出的。例如，在3x3数组中，A[0][0]（值为1）在顺时针旋转后将位于新数组的B[0][2]位置。这一关系的确定对于编写旋转算法至关重要。同时，旋转还可以分为整体旋转和局部旋转。整体旋转是对整个二维数组进行操作，而局部旋转则是针对数组中的某一部分区域进行旋转操作，例如以某个子矩阵为中心进行旋转1。

（二）二维数组翻转的概念

二维数组的翻转是指将数组沿着某条轴线进行对称变换。这与旋转有所不同，翻转更多的是一种镜像操作。在C++中，常见的翻转方式有水平翻转和垂直翻转。

  1. 水平翻转

    • 对于一个二维数组进行水平翻转，就是将每一行的元素以该行的中心为对称轴进行交换。例如对于以下的3x3二维数组：

    1 2 3
4 5 6
7 8 9
    水平翻转后变为： 
    3 2 1
6 5 4
9 8 7

    从元素的角度来看，对于第i行，A[i][j]将变为A[i][n - 1 - j]（n为该行的元素个数）。

  2. 垂直翻转

    • 垂直翻转则是将每一列的元素以该列的中心为对称轴进行交换。对于上述的3x3二维数组，垂直翻转后将变为：

    7 8 9
4 5 6
1 2 3

    此时，对于第j列，A[i][j]将变为A[n - 1 - i][j]（n为数组的行数）。 这种翻转操作在图像处理、矩阵变换等领域有着广泛的应用，例如在图像的上下颠倒或者左右反转操作中，就可以通过对表示图像像素的二维数组进行垂直或者水平翻转来实现11。

二、二维数组旋转与翻转的实现方法（C++）

（一）二维数组旋转的实现方法

  1. 整体旋转

    • 顺时针旋转

      • 首先要确定旋转的对应关系。以n x n的二维数组为例，对于原始数组A和旋转后的数组B，元素的对应关系为B[i][j]=A[n - 1 - j][i]。在C++中实现时，可以使用嵌套的for循环来遍历数组。外层循环控制行，内层循环控制列。例如：

      #include <iostream>

const int N = 3; 

void rotateClockwise(int A[][N], int B[][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            B[i][j] = A[N - 1 - j][i]; 
        }
    }
}

int main() {
    int A[N][N] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; 
    int B[N][N]; 
    rotateClockwise(A, B); 
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            std::cout << B[i][j] << " "; 
        }
        std::cout << std::endl; 
    }
    return 0; 
}

      • 在这个代码中，rotateClockwise函数实现了将二维数组A顺时针旋转并存储到数组B中的功能。通过双层for循环，按照前面提到的对应关系对每个元素进行赋值。

    • 逆时针旋转

      • 逆时针旋转的对应关系为B[i][j]=A[j][n - 1 - i]。同样使用嵌套的for循环来实现。例如：

      #include <iostream>

const int N = 3; 

void rotateCounterClockwise(int A[][N], int B[][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            B[i][j] = A[j][N - 1 - i]; 
        }
    }
}

int main() {
    int A[N][N] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; 
    int B[N][N]; 
    rotateCounterClockwise(A, B); 
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            std::cout << B[i][j] << " "; 
        }
        std::cout << std::endl; 
    }
    return 0; 
}

  2. 局部旋转

    • 对于局部旋转，需要先确定要旋转的区域。假设要以(x,y)为中心，对一个2r + 1阶的子矩阵进行旋转。首先要将坐标转换为以子矩阵左上角为基准的相对坐标。然后按照整体旋转的思路确定对应关系。例如，对于顺时针局部旋转，在相对坐标下的对应关系为B[i][j]=A[2r - j][i]（这里假设子矩阵的边长为2r+1）。在C++实现中，除了双层for循环遍历子矩阵区域外，还需要注意边界条件的处理，确保不会访问到数组越界的元素。

（二）二维数组翻转的实现方法

  1. 水平翻转

    • 要实现二维数组的水平翻转，可以使用嵌套的for循环。外层循环遍历每一行，内层循环对每一行的元素进行交换。例如，对于一个m x n的二维数组A，以下是实现水平翻转的代码片段：

    #include <iostream>

const int M = 3; 
const int N = 3; 

void horizontalFlip(int A[][N]) {
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N / 2; j++) {
            int temp = A[i][j]; 
            A[i][j] = A[i][N - 1 - j]; 
            A[i][N - 1 - j] = temp; 
        }
    }
}

int main() {
    int A[M][N] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; 
    horizontalFlip(A); 
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            std::cout << A[i][j] << " "; 
        }
        std::cout << std::endl; 
    }
    return 0; 
}

    • 在这个代码中，horizontalFlip函数通过交换每一行的对称元素实现了水平翻转。内层循环只需要遍历到列数的一半，因为每次交换是成对进行的。

  2. 垂直翻转

    • 垂直翻转的实现类似，只是交换的是列元素。外层循环遍历列，内层循环对每列的元素进行交换。例如：

    #include <iostream>

const int M = 3; 
const int N = 3; 

void verticalFlip(int A[][N]) {
    for (int j = 0; j < N; j++) {
        for (int i = 0; i < M / 2; i++) {
            int temp = A[i][j]; 
            A[i][j] = A[M - 1 - i][j]; 
            A[M - 1 - i][j] = temp; 
        }
    }
}

int main() {
    int A[M][N] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; 
    verticalFlip(A); 
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            std::cout << A[i][j] << " "; 
        }
        std::cout << std::endl; 
    }
    return 0; 
}

    • 这里的verticalFlip函数通过交换每列的对称元素实现了垂直翻转。内层循环只需要遍历到行数的一半8。

三、二维数组旋转与翻转的示例代码（C++）

（一）二维数组旋转示例代码

  1. 整体顺时针旋转示例

    • 以下是一个更完整的整体顺时针旋转二维数组的示例代码，包括了输入数组的初始化和结果的输出：

    #include <iostream>

const int MAX_SIZE = 100; 

// 顺时针旋转函数
void rotateClockwise(int arr[][MAX_SIZE], int n) {
    int rotated[MAX_SIZE][MAX_SIZE]; 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            rotated[i][j] = arr[n - 1 - j][i]; 
        }
    }
    // 输出旋转后的数组
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            std::cout << rotated[i][j] << " "; 
        }
        std::cout << std::endl; 
    }
}

int main() {
    int n; 
    std::cout << "请输入二维数组的阶数: "; 
    std::cin >> n; 
    int arr[MAX_SIZE][MAX_SIZE]; 
    std::cout << "请输入二维数组的元素: "; 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            std::cin >> arr[i][j]; 
        }
    }
    rotateClockwise(arr, n); 
    return 0; 
}

    • 在这个示例中，首先通过用户输入获取二维数组的阶数和元素，然后调用rotateClockwise函数进行顺时针旋转，并输出旋转后的数组。

  2. 整体逆时针旋转示例

    • 下面是整体逆时针旋转的示例代码：

    #include <iostream>

const int MAX_SIZE = 100; 

// 逆时针旋转函数
void rotateCounterClockwise(int arr[][MAX_SIZE], int n) {
    int rotated[MAX_SIZE][MAX_SIZE]; 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            rotated[i][j] = arr[j][n - 1 - i]; 
        }
    }
    // 输出旋转后的数组
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            std::cout << rotated[i][j] << " "; 
        }
        std::cout << std::endl; 
    }
}

int main() {
    int n; 
    std::cout << "请输入二维数组的阶数: "; 
    std::cin >> n; 
    int arr[MAX_SIZE][MAX_SIZE]; 
    std::cout << "请输入二维数组的元素: "; 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            std::cin >> arr[i][j]; 
        }
    }
    rotateCounterClockwise(arr, n); 
    return 0; 
}

    • 这个代码与顺时针旋转的代码结构类似，只是在rotateCounterClockwise函数中，元素的赋值按照逆时针旋转的对应关系进行。

  3. 局部顺时针旋转示例

    • 假设要对以(x,y)为中心的3x3子矩阵进行顺时针旋转（这里假设整个二维数组足够大），以下是示例代码：

    #include <iostream>

const int MAX_SIZE = 100; 

// 局部顺时针旋转函数
void localRotateClockwise(int arr[][MAX_SIZE], int x, int y) {
    int rotated[3][3]; 
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            rotated[i][j] = arr[x + 2 - j][y + i]; 
        }
    }
    // 将旋转后的子矩阵放回原数组
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            arr[x + i][y + j] = rotated[i][j]; 
        }
    }
}

int main() {
    int arr[MAX_SIZE][MAX_SIZE]; 
    // 这里简单初始化一个示例数组
    arr[0][0]=1; arr[0][1]=2; arr[0][2]=3; arr[0][3]=4; 
    arr[1][0]=5; arr[1][1]=6; arr[1][2]=7; arr[1][3]=8; 
    arr[2][0]=9; arr[2][1]=10; arr[2][2]=11; arr[2][3]=12; 
    arr[3][0]=13; arr[3][1]=14; arr[3][2]=15; arr[3][3]=16; 
    int x = 1; 
    int y = 1; 
    localRotateClockwise(arr, x, y); 
    // 输出旋转后的数组
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            std::cout << arr[i][j] << " "; 
        }
        std::cout << std::endl; 
    }
    return 0; 
}

    • 在这个代码中，localRotateClockwise函数首先对指定的3x3子矩阵进行顺时针旋转，将结果存储在临时数组rotated中，然后再将旋转后的子矩阵放回原数组中。

（二）二维数组翻转示例代码

  1. 水平翻转示例

    • 以下是一个完整的水平翻转二维数组的示例代码：

    #include <iostream>

const int MAX_ROWS = 100; 
const int MAX_COLS = 100; 

// 水平翻转函数
void horizontalFlip(int arr[][MAX_COLS], int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols / 2; j++) {
            int temp = arr[i][j]; 
            arr[i][j] = arr[i][cols - 1 - j]; 
            arr[i][cols - 1 - j] = temp; 
        }
    }
    // 输出翻转后的数组
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            std::cout << arr[i][j] << " "; 
        }
        std::cout << std::endl; 
    }
}

int main() {
    int rows, cols; 
    std::cout << "请输入二维数组的行数和列数: "; 
    std::cin >> rows >> cols; 
    int arr[MAX_ROWS][MAX_COLS]; 
    std::cout << "请输入二维数组的元素: "; 
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            std::cin >> arr[i][j]; 
        }
    }
    horizontalFlip(arr, rows, cols);

    制作不易，点个赞吧┭┮﹏┭┮

JNA调用C++动态库，传入二维数组，通过C++返回二维数组，java调用C++完整案例
01-15
在Java编程中，有时我们需要与C++...总之，JNA提供了灵活的方式让Java与C++库进行交互，但在处理复杂数据类型如二维数组时需要注意内存布局和数据转换。在实际项目中，应确保充分测试，保证在不同平台上都能正确运行。
C++关于信息学竞赛 二维数组23个源文件试题 供初学者练习
06-06
C++关于信息学竞赛 二维数组23个源文件试题 供初学者练习 #include using namespace std; main() { int a[6][6],max,max_y,min,min_x; for(int i=1;i;i++) for(int j=1;j;j++) cin>>a[i][j]; for(int i...
python 二维数组90度旋转的方法
09-19
在Python编程中，二维数组（也称为矩阵）的90度旋转是一个常见的操作，尤其在图像处理、数据变换和算法实现中。本篇文章将详细解释如何实现Python二维数组的90度顺时针旋转。 首先，我们要理解二维数组在Python中的...
c++二维数组ppt资源
01-30
C++二维数组PPT资源 C++二维数组是数组的一种扩展形式，相比一维数组，它可以存储更多的数据，并且提供了更多的操作方式。二维数组的定义和使用与一维数组类似，但它具有更多的维度和灵活性。 二维数组的定义 二...
c++ 二级指针与二维数组之间值操作
04-18
二维数组在C++中本质上是一级指针的数组，每个元素又是一个一级指针，指向一维字符数组。因此，二级指针可以用来直接访问和修改这些一维数组的内容。下面将详细解释这个过程： 1. **二级指针的声明**： 在C++中，...
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 161
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
【C语言】数据类型和变量
2302_76713442的博客
10-06 1014
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 954
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C - Separated Lunch
m0_74304371的博客
10-05 236
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 410
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
【C++】类与对象基础概念解析
A Charmer 的博客
10-03 1363
在 C++ 编程中，类与对象是核心概念之一，它们为程序设计提供了一种强大而灵活的方式来组织代码和管理数据。理解类与对象的基础概念对于掌握 C++ 编程至关重要。
06.C/C++内存管理
2402_82670467的博客
09-29 1088
在这里C++的内存管理相较于C作出了许多升级，下面我们就来了解一下。我们先来看一下下面的问题，温习一下C的内存分布 在 C/C++中，内存主要分为以下几个部分： 一、栈（Stack） 1. 存储内容： - 局部变量：函数内部声明的非静态变量。 - 函数参数：传递给函数的参数。 - 函数调用信息：如返回地址等。 2. 特点： - 先进后出（LIFO）的数据结构。 - 内存由编译器自动管理，当函数被调用时分配空间，函数返回时自动释放。 - 空间相对较小，通常几兆字节。 二、堆（Heap）
【C++】STL--vector
2301_78724721的博客
10-03 812
/类模板只能实例化//初始化10个1//遍历i++)//范围for。
【C++打怪之路Lv5】-- 类和对象（下）
Sweeney_001的博客
09-29 1055
类和对象(下)：初始化列表，explicit关键字、static成员、友元、内部类、匿名对象
C++的STL标准模版库容器--list类
最新发布
2401_82376751的博客
10-06 753
较为详细得讲述容器list类的各项功能与实现
C++：STL（四）之vector的基本介绍与使用方式|容器接口
白乐天_ξ( ✿＞◡❛)的博客
09-28 1220
本文主要是介绍vector容器以及接口的使用方式，和string类的那一节相似！
[C++][程序退出]详细讲解
SnowK博客
09-30 3583
[C++][程序退出]详细讲解
第九章---for循环及在STL的应用(vector\map\set\list\for_each)、嵌套while、while 统一输出、do-while
T-ang.的博客
09-29 1458
在C++中，循环语句用于重复执行一段代码，直到指定的条件不再满足。C++ 提供了几种循环机制，下面将详细讲解每种循环语句的用法和特点。
(C语言贪吃蛇)13.实现贪吃蛇四方向的移动
Botwo的博客
10-03 497
实现贪吃蛇四方向走位
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值