打印二维数组——汇总

package Matrix

import (
	"fmt"
	"testing"
)

/*
矩阵处理技巧   矩阵二维数组特殊轨迹变化问题
1. zigzag 打印矩阵
 _                  -
| 1  2  3  4  5  6  |
| 7  8  9  10 11 12 |
| 13 14 15 16 17 18 |
-                  -

A:(0,0)
B:(0,0)
以后每一步 A 先向右走，走到不能再走的时候往下走
B和A 同步走，走到不能再往下走的时候，再往右走


1,2,7, 13,8,3,4,9,14....

2. 转圈打印矩阵

3. 原地旋转正方形矩阵

核心技巧：找到coding上的宏观调度


 */

func printMatrixZigZag(matrix [][]int) {
	Ax, Ay := 0, 0
	Bx, By := 0, 0
	Endx := len(matrix) - 1
	Endy := len(matrix[0]) - 1
	fromUp := false     //是不是从右上往左下打印
	for Ax != Endx + 1 { //终止位置的行号 + 1
		// 告诉你斜线的两端，A,B， 方向告诉你，你去打印
	    printLevel(matrix, Ax, Ay, Bx, By,fromUp)
		if Ay == Endy {
			Ax++
		}
		if Ay != Endy {
			Ay++
		}


		if Bx == Endx {
			By++
		}

		if Bx != Endx {
			Bx++
		}
		fromUp = !fromUp
	}
	fmt.Println()
}

func printLevel(m [][]int, tR,tC, dR, dC int,f bool) {
	if f {
		for tR != dR + 1 {
			fmt.Print(m[tR][tC]," ")
			tR++
			tC--
		}
	}else {
		for dR != tR - 1 {
			fmt.Print(m[dR][dC]," ")
			dR--
			dC++
		}
	}
}

/*
      1    2    3    4
      5    6    7    8
      9    10   11   12
      13   14   15   16 
 */

func TestPrintMatrixZigZag(t *testing.T)  {
	matrix := [][]int{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}
	printMatrixZigZag(matrix)
}



/*
转圈打印矩阵
      1    2    3    4    5
      6    7    8    9    10
      11   12   13   14   15
      16   17   18   19   20



矩阵可以要求不是正方形

1,2,3,4,5,10,15,20,19,18,17,16,11,6,7,8,9,14,13,12
1 2 3 4 5 10 15 20 19 18 17 16 11 6 7 8 9 14 13 12
按层分解
*/

func printEdge(m [][]int, a,b,c,d int)  {
	if a == c {
		for i := b; i <= d; i++ {
			fmt.Print(m[a][i], " ")
		}
	}else if b == d {
		for i := a; i <= c; i++ {
			fmt.Print(m[i][b], " ")
		}
	}else {
		curC := b
		curR := a
		for curC != d {
			fmt.Print(m[a][curC], " ")
			curC++
		}
		for curR != c {
			fmt.Print(m[curR][d], " ")
			curR++
		}
		for curC != b {
			fmt.Print(m[c][curC], " ")
			curC--
		}
		for curR != a {
			fmt.Print(m[curR][b], " ")
			curR--
		}
	}
}

func spiralOrderPrint(matrix [][]int)  {
	tR,tC := 0, 0
	dR := len(matrix) - 1
	dC := len(matrix[0]) - 1
	for tR <= dR && tC <= dC {
		printEdge(matrix,tR,tC,dR,dC)
		tR++
		tC++
		dR--
		dC--
	}
	fmt.Println()
}

func TestSpiralOrderPrint(t *testing.T)  {
	matrix := [][]int{{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20}}
	spiralOrderPrint(matrix)
}




//原地旋转正方形矩阵
func printMatrix(matrix [][]int) {
	print := func(nums [][]int) {
		for _, v := range nums {
			for _, n := range v {
				fmt.Print("\t", n)
			}
			fmt.Println()
		}
		fmt.Println("---------------")
	}



	print(matrix)
	startX ,startY, endX ,endY := 0,0,len(matrix[0]) - 1, len(matrix[0]) - 1
	for startX < endX {
		for i := 0; i < endX-startX; i++ {
			matrix[startX][startY+i], matrix[endX-i][startY], matrix[endX][endY-i],   matrix[startX+i][endY] =
				matrix[endX-i][startY],   matrix[endX][endY-i],   matrix[startX+i][endY], matrix[startX][startY+i]
		}
		startX,startY,endX,endY = startX+1,startY+1,endX-1,endY-1
	}
	print(matrix)
}

func TestPrintMatrix(t *testing.T)  {
	matrix := [][]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}
	printMatrix(matrix)
}