二维数组的两种遍历方式左右旋转左右逆序上下逆序 (kotlin实现)

Posted 2022-06-02 匆忙拥挤repeat

文章目录

• 代码实现
• 结论
• 参考

---

代码实现

/**
 * desc:    二维数组 左右旋转，行内左右逆序。 上下逆序未实现。
 * author:  stone
 * email:   [e-mail]
 * blog :   https://stone.blog.csdn.net
 * time:    2020/2/29 10:25
 */
class ArrayTest 
    private val random = Random(100)
    inner class Blob(
        var x: Int, //x方向坐标索引
        var y: Int, //y方向坐标索引
        var value: Int,
        var pX: Int = x * 20, //坐标点的x值。如单位间隔20
        var pY: Int = y * 20 //坐标点的y值。如单位间隔20
    )

    fun createArray(row: Int, col: Int) = Array(row)  rowE -> Array(col)  colE -> Blob(rowE, colE, random.nextInt(100))  

    /*
     * 对于二维数组，每个元素是一个一维数组。
     * 双层for循环，外层行、内层列方式遍历； 每输出一行后，换行。
     * 每一行上的元素数量 = col 的值，
     * 每一列上的元素数量 = row 的值。
     *
     * 每输出的一行元素，对应实际问题中的，如图片、棋盘等，表示的是 它们的 一列元素。
     */
    fun dumpArray(array: Array<Array<Blob>>) 
        println("外行，内列，输出一行表示实际一行")
        var mapX: Int
        var mapY: Int
        for (rowIndex in array.indices) 
            for (colIndex in array[rowIndex].indices) 
                mapX = array[rowIndex][colIndex].x
                mapY = array[rowIndex][colIndex].y
                print("$array[mapX][mapY].value($mapX,$mapY) ")
//                print("$array[mapX][mapY].value($mapX,$mapY)[$array[mapX][mapY].pX, $array[mapX][mapY].pY] ")
            
            println()
        
        println()
    

    /*
     * 对于二维数组，每个元素是一个一维数组。
     * 双层for循环，外层列、内层行方式遍历； 每输出一行后，换行。
     * 每一行上的元素数量 = row 的值，  行上的元素 = dumpArray(array) 列上的元素。
     * 每一列上的元素数量 = col 的值，  列上的元素 = dumpArray(array) 行上的元素。
     *
     * 每输出的一行元素，对应实际问题中的，如图片、棋盘等，表示的是 它们的 一行元素。
     *
     * 两种方式，均可以将 二维数组的每个元素遍历到。
     * 本函数的输出，看起来像是 dumpArray 函数输出 右(顺时针)旋转了90度，并且左右逆向了
     */
    fun dumpArray2(array: Array<Array<Blob>>, row: Int, col: Int) 
        println("外列，内行，输出一行表示实际一列")
        var mapX: Int
        var mapY: Int
        for (colIndex in 0 until col) 
            for (rowIndex in 0 until row) 
                mapX = array[rowIndex][colIndex].x
                mapY = array[rowIndex][colIndex].y
                print("$array[mapX][mapY].value($mapX,$mapY) ")
            
            println()
        
        println()
    

    /*
     * dumpArray输出，直接 右(顺时针)旋转90度。
     * 新的第一行数据是 0(3,0) 0(2,0) 0(1,0) 0(0,0)  ， 与原第一列的数据 0(0,0) 0(1,0) 0(2,0) 0(3,0)  左右逆向了
     *
     * 结果，x横向递减，y纵向递增
     */
    fun dumpArrayRotateClockwise(array: Array<Array<Blob>>, row: Int, col: Int) 
        println("对外行，内列，顺时针旋转90度，与 '对外列，内行，左右逆序' 结果一样。编号 A")
        var mapX: Int
        var mapY: Int
        for (colIndex in 0 until col) 
            for (rowIndex in 0 until row) 
                mapX = array[row - 1 - rowIndex][colIndex].x
                mapY = array[rowIndex][colIndex].y
                print("$array[mapX][mapY].value($mapX,$mapY) ")
            
            println()
        
        println()
    

    /*
     * dumpArray输出，直接 左(逆时针)旋转90度。
     * 新的第一行数据是 0(0,4) 0(1,4) 0(2,4) 0(3,4)  ， 与原最后一列的数据 相同
     *
     * 结果，x横向递增，y纵向递减
     */
    fun dumpArrayRotateAnticlockwise(array: Array<Array<Blob>>, row: Int, col: Int) 
        println("对外行，内列，逆时针旋转90度，与 '外列，内行 上下逆序' 结果一样。编号 D")
        var mapX: Int
        var mapY: Int
        for (colIndex in 0 until col) 
            for (rowIndex in 0 until row) 
                mapX = array[rowIndex][rowIndex].y
                mapY = array[rowIndex][col - 1 - colIndex].y
                print("$array[mapX][mapY].value($mapX,$mapY) ")
            
            println()
        
        println()
    

    fun dumpArray2RotateClockwise(array: Array<Array<Blob>>, row: Int, col: Int) 
        println("对外列，内行，顺时针旋转90度, 与 '对外行，内列，左右逆序' 结果一样。编号 B")
        var mapX: Int
        var mapY: Int
        for (rowIndex in 0 until row) 
            for (colIndex in 0 until col) 
                mapX = array[rowIndex][rowIndex].y
                mapY = array[rowIndex][col - 1 - colIndex].y
                print("$array[mapX][mapY].value($mapX,$mapY) ")
            
            println()
        
        println()
    

    /*
     * 第一行变成 0(3,0) 0(3,1) 0(3,2) 0(3,3) 0(3,4)
     */
    fun dumpArray2RotateAnticlockwise(array: Array<Array<Blob>>, row: Int, col: Int) 
        println("对外列，内行，逆时针旋转90度，与 '对外行，内列 上下逆序' 结果一样。编号 C")
        var mapX: Int
        var mapY: Int
        for (rowIndex in 0 until row) 
            for (colIndex in 0 until col) 
                mapX = array[row - 1 - rowIndex][rowIndex].x
                mapY = array[row - 1 - rowIndex][colIndex].y
                print("$array[mapX][mapY].value($mapX,$mapY) ")
            
            println()
        
        println()
    

    fun dumpArrayReverseRc(array: Array<Array<Blob>>, row: Int, col: Int) 
        println("对外行，内列，左右逆序，与 '对外列，内行，顺时针旋转90度' 结果一样。编号 B")
        var mapX: Int
        var mapY: Int
        for (rowIndex in 0 until row) 
            for (colIndex in 0 until col) 
                mapX = array[rowIndex][rowIndex].y
                mapY = array[rowIndex][col - 1 - colIndex].y
                print("$array[mapX][mapY].value($mapX,$mapY) ")
            
            println()
        
        println()
    

    fun dumpArray2ReverseCr(array: Array<Array<Blob>>, row: Int, col: Int) 
        println("对外列，内行，左右逆序，与 `对外行，内列，顺时针旋转90度` 结果一样。编号 A")
        var mapX: Int
        var mapY: Int
        for (colIndex in 0 until col) 
            for (rowIndex in 0 until row) 
                mapX = array[row - 1 - rowIndex][colIndex].x
                mapY = array[rowIndex][colIndex].y
                print("$array[mapX][mapY].value($mapX,$mapY) ")
            
            println()
        
        println()
    


fun main() 
    val instance = ArrayTest()
    val row = 4
    val col = 5
    val ary = instance.createArray(row, col)
    println("size=$ary.size")
    instance.dumpArray(ary)
    instance.dumpArray2(ary, row, col)
    instance.dumpArrayRotateClockwise(ary, row, col)
    instance.dumpArrayRotateAnticlockwise(ary, row, col)
    instance.dumpArray2RotateClockwise(ary, row, col)
    instance.dumpArray2RotateAnticlockwise(ary, row, col)
    instance.dumpArrayReverseRc(ary, row, col)
    instance.dumpArray2ReverseCr(ary, row, col)

输出

size=4
外行，内列，输出一行表示实际一行
93(0,0) 82(0,1) 41(0,2) 20(0,3) 46(0,4) 
13(1,0) 24(1,1) 23(1,2) 27(1,3) 27(1,4) 
7(2,0) 32(2,1) 86(2,2) 49(2,3) 2(2,4) 
72(3,0) 48(3,1) 32(3,2) 76(3,3) 31(3,4) 

外列，内行，输出一行表示实际一列
93(0,0) 13(1,0) 7(2,0) 72(3,0) 
82(0,1) 24(1,1) 32(2,1) 48(3,1) 
41(0,2) 23(1,2) 86(2,2) 32(3,2) 
20(0,3) 27(1,3) 49(2,3) 76(3,3) 
46(0,4) 27(1,4) 2(2,4) 31(3,4) 

对外行，内列，顺时针旋转90度，与 '对外列，内行，左右逆序' 结果一样。编号 A
72(3,0) 7(2,0) 13(1,0) 93(0,0) 
48(3,1) 32(2,1) 24(1,1) 82(0,1) 
32(3,2) 86(2,2) 23(1,2) 41(0,2) 
76(3,3) 49(2,3) 27(1,3) 20(0,3) 
31(3,4) 2(2,4) 27(1,4) 46(0,4) 

对外行，内列，逆时针旋转90度，与 '外列，内行 上下逆序' 结果一样。编号 D
46(0,4) 27(1,4) 2(2,4) 31(3,4) 
20(0,3) 27(1,3) 49(2,3) 76(3,3) 
41(0,2) 23(1,2) 86(2,2) 32(3,2) 
82(0,1) 24(1,1) 32(2,1) 48(3,1) 
93(0,0) 13(1,0) 7(2,0) 72(3,0) 

对外列，内行，顺时针旋转90度, 与 '对外行，内列，左右逆序' 结果一样。编号 B
46(0,4) 20(0,3) 41(0,2) 82(0,1) 93(0,0) 
27(1,4) 27(1,3) 23(1,2) 24(1,1) 13(1,0) 
2(2,4) 49(2,3) 86(2,2) 32(2,1) 7(2,0) 
31(3,4) 76(3,3) 32(3,2) 48(3,1) 72(3,0) 

对外列，内行，逆时针旋转90度，与 '对外行，内列 上下逆序' 结果一样。编号 C
72(3,0) 48(3,1) 32(3,2) 76(3,3) 31(3,4) 
7(2,0) 32(2,1) 86(2,2) 49(2,3) 2(2,4) 
13(1,0) 24(1,1) 23(1,2) 27(1,3) 27(1,4) 
93(0,0) 82(0,1) 41(0,2) 20(0,3) 46(0,4) 

对外行，内列，左右逆序，与 '对外列，内行，顺时针旋转90度' 结果一样。编号 B
46(0,4) 20(0,3) 41(0,2) 82(0,1) 93(0,0) 
27(1,4) 27(1,3) 23(1,2) 24(1,1) 13(1,0) 
2(2,4) 49(2,3) 86(2,2) 32(2,1) 7(2,0) 
31(3,4) 76(3,3) 32(3,2) 48(3,1) 72(3,0) 

对外列，内行，左右逆序，与 `对外行，内列，顺时针旋转90度` 结果一样。编号 A
72(3,0) 7(2,0) 13(1,0) 93(0,0) 
48(3,1) 32(2,1) 24(1,1) 82(0,1) 
32(3,2) 86(2,2) 23(1,2) 41(0,2) 
76(3,3) 49(2,3) 27(1,3) 20(0,3) 
31(3,4) 2(2,4) 27(1,4) 46(0,4) 

上下逆序的实现省略了，通过观察，它们的结果应该和两种遍历方式的 逆时针/左 旋转 一样。

---

结论

• 外行，内列，遍历，输出一行表示实际(描述的对象的)一行
• 外列，内行，遍历，输出一行表示实际(描述的对象的)一列
• 对外行，内列，顺时针/右 旋转90度，与 ‘对外列，内行，左右逆序’ 结果一样
• 对外行，内列，逆时针/左 旋转90度，与 ‘外列，内行 上下逆序’ 结果一样
• 对外列，内行，顺时针/右 旋转90度, 与 ‘对外行，内列，左右逆序’ 结果一样
• 对外列，内行，逆时针/左 旋转90度，与 ‘对外行，内列 上下逆序’ 结果一样

---

参考

kotlin之二维数组的翻转思路和实现