[Swift]多維數組的表示和存儲：N維數組映射到一維數組(一一對應)！

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公眾號：山青詠芝（shanqingyongzhi）
➤博客園地址：山青詠芝（https://www.cnblogs.com/strengthen/ ）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9844577.html 
➤如果鏈接不是山青詠芝的博客園地址，則可能是爬取作者的文章。
➤原文已修改更新！強烈建議點擊原文地址閱讀！支持作者！支持原創！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

數組：有序的元素序列。 若將有限個類型相同的變量的集合命名，那么這個名稱為數組名。組成數組的各個變量稱為數組的分量，也稱為數組的元素，有時也稱為下標變量。用於區分數組的各個元素的數字編號稱為下標。數組是在程序設計中，為了處理方便， 把具有相同類型的若干元素按無序的形式組織起來的一種形式。這些無序排列的同類數據元素的集合稱為數組。數組是用於儲存多個相同類型數據的集合。

二維數組：本質上是以數組作為數組元素的數組，即“數組的數組”。二維數組又稱為矩陣，行列數相等的矩陣稱為方陣。

　　對稱矩陣：a[i][j] = a[j][i]

　　對角矩陣：n階方陣主對角線外都是零元素

三維數組：指維數為三的數組結構。三維數組是最常見的多維數組，由於其可以用來描述三維空間中的位置或狀態而被廣泛使用。

定義二維數組

//方式1
var arr1 = [[Int]]()
print(arr1)
//Print []

//方式2
var arr2 = Array<Array<Int>>()
print(arr2)
//Print []

//方式3：定義3列4行的二維數組，元素初始化為0
var arr3 = [[Int]](repeating: [Int](repeating: 0, count: 3), count: 4)
print(arr3)
//Print [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

二維數組的遍歷

//遍歷行
for row in arr3 
{
    print(row)
    //Print [0, 0, 0]
    //遍歷列
    for col in row
    {
        //從左到右，從上到下進行遍歷
        print(col)
        //Print 0
    }
}

定義三維數組

//方式1
var arr1 = [[[Int]]]()
print(arr1)
//Print []

//方式2
var arr2 = Array<Array<Array<Int>>>()
print(arr2)
//Print []

//方式3：定義三維數組，元素初始化為0，由內往外
var arr3 = [[[Int]]](repeating: [[Int]](repeating: [Int](repeating: 0, count: 2), count: 3), count: 4)
print(arr3)
//2個元素的一維數組，3個元素的二維數組，4個元素的三位數組
/*
[
    [
        [0, 0], [0, 0], [0, 0]
    ],
    [
        [0, 0], [0, 0], [0, 0]
    ],
    [
        [0, 0], [0, 0], [0, 0]
    ],
    [
        [0, 0], [0, 0], [0, 0]
    ]
]
*/

三維數組的遍歷

//遍歷高height
for height in arr3 
{
    print(height)
    //Print [[0, 0], [0, 0], [0, 0]]
    //遍歷長depth
    for depth in height
    {
        print(depth)
        //Print [0, 0]
        //遍歷寬width
        for width in depth
        {
            print(width)
            //Print 0
        }
    }
}

使用函數來創建多維數組

//num:元素個數
//value:元素初始值
func dimension<T>(_ num: Int, _ value: T) -> [T] {
  return [T](repeating: value, count: num)
}

示例代碼：

//用嵌套的方式創建多維數組
//創建一維數組
let arr1 = dimension(1,0)
print(arr1)
//Print [0]

//創建二維數組
let arr2 = dimension(2,arr1)
//即：let arr2 = dimension(2,dimension(1,0))
print(arr2)
//Print [[0], [0]]

//創建三維數組
let arr3 = dimension(3,arr2)
//即：let arr3 = dimension(3,dimension(2,dimension(1,0)))
print(arr3)
//Print [[[0], [0]], [[0], [0]], [[0], [0]]]

//創建四維數組
let arr4 = dimension(4,arr3)
//即：let arr4 = dimension(4,dimension(3,dimension(2,dimension(1,0))))
print(arr4)
//Print [[[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]]]

//創建五維數組
let arr5 = dimension(5,arr4)
//即：arr5 = dimension(5,dimension(4,dimension(3,dimension(2,dimension(1,0)))))
print(arr5)
//Print [[[[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]]], [[[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]]], [[[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]]], [[[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]]], [[[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]], [[[0], [0]], [[0], [0]], [[0], [0]]]]]

//......

使用函數嵌套的方法創建多維數組有一個很大的缺陷：無法明確維度所代表的意義。

所以，可以考慮使用一維數組存儲多維數組的數據。

創建一個Array2D類，用一維數組存儲二維數組的數據。

此時我們只需關注“列”和“行”的數值，細節交由Array2D來處理，這就是將原始數據類型包裝成包裝器類型或結構體的優點。

二維數組A[rows][columns]放到一維數組B中的對應公式:

兩種方式 ：

（1）、按行遍歷 

A[i][j] = B[ i + j * rows ]

（2）、按列遍歷

A[i][j] = B[ i * columns + j ]

public struct Array2D<T> {
    //列數
    public let columns:Int 
    //行數
    public let rows:Int 
    fileprivate var array: [T]
    
    //初始化
    public init(columns: Int, rows: Int, initialValue: T) {
        self.columns = columns
        self.rows = rows
        array = .init(repeating: initialValue, count: rows*columns)
    }
    
    //subscript函數可以檢索數組中的值
    public subscript(column: Int, row: Int) -> T {
        //讀取
        get {
             //先決條件
            precondition(column <= columns, "Column \(column) Index is out of range. Array<T>(columns: \(columns), rows:\(rows))")
            precondition(row <= rows, "Row \(row) Index is out of range. Array<T>(columns: \(columns), rows:\(rows))")
            return array[row * columns + column]
            //或 return array[row + column * rows]
        }
        //寫入
        set {
             //先決條件
            precondition(column <= columns, "Column \(column) Index is out of range. Array<T>(columns: \(columns), rows:\(rows))")
            precondition(row <= rows, "Row \(row) Index is out of range. Array<T>(columns: \(columns), rows:\(rows))")
            array[row * columns + column] = newValue
            //或 array[row + column * rows] = newValue
        }
    }
}

示例代碼：

// 創建一個二維數組的實例
var arr2D = Array2D(columns: 2, rows:3, initialValue: 0)
print(arr2D)
//Print Array2D<Int>(columns: 2, rows: 3, array: [0, 0, 0, 0, 0, 0])

//subscript函數可以檢索數組中的元素值
let num = arr2D[1, 1]
print(num)
//Print 0

//給數組中的元素賦值
arr2D[1, 1] = 88
print(arr2D[1, 1])
//Print 88

創建一個Array3D類，用一維數組存儲三維維數組的數據。

此時我們只需關注“長”、“寬”和“高”的數值，細節交由Array3D來處理，這就是將原始數據類型包裝成包裝器類型或結構體的優點。

三維數組A[widths][depths][heights]放到一維數組B中的對應公式:
A[i][j][k] = B[ ( i - 1 ) * ( depths * heights ) + ( j - 1 ) * heights + k ]

public struct Array3D<T> {
    //寬
    public let widths:Int
    //長
    public let depths:Int
    //高
    public let heights:Int
    fileprivate var array: [T]
    
    //初始化
    public init(widths: Int, depths: Int, heights: Int, initialValue: T) {
        self.widths = widths
        self.depths = depths
        self.heights = heights
        array = .init(repeating: initialValue, count: widths * depths * heights)
    }
    
    //subscript函數可以檢索數組中的值
    public subscript(width: Int, depth: Int, height: Int) -> T {
        //讀取
        get {
            //先決條件
            precondition(width <= widths, "Width \(width) Index is out of range. Array<T>(widths: \(widths), depths:\(depths), heights:\(heights))")
            precondition(depth <= depths, "Depth \(depth) Index is out of range. Array<T>(widths: \(widths), depths:\(depths), heights:\(heights))")
            precondition(height <= heights, "Height \(height) Index is out of range. Array<T>(widths: \(widths), depths:\(depths), heights:\(heights))")
            return array[(width - 1) * (depths * heights) + (depth - 1) * heights + height]
        }
        //寫入
        set {
             //先決條件
            precondition(width <= widths, "Width \(width) Index is out of range. Array<T>(widths: \(widths), depths:\(depths), heights:\(heights))")
            precondition(depth <= depths, "Depth \(depth) Index is out of range. Array<T>(widths: \(widths), depths:\(depths), heights:\(heights))")
            precondition(height <= heights, "Height \(height) Index is out of range. Array<T>(widths: \(widths), depths:\(depths), heights:\(heights))")
            array[(width - 1) * (depths * heights) + (depth - 1) * heights + height] = newValue
        }
    }
}

示例代碼：

// 創建一個三維數組的實例
var arr3D = Array3D(widths: 2, depths: 3, heights: 4, initialValue: 0)
print(arr3D)
//Print Array3D<Int>(widths: 2, depths: 3, heights: 4, array: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

//subscript函數可以檢索數組中的元素值
let num = arr3D[1, 1, 1]
print(num)
//Print 0

//給數組中的元素賦值
arr3D[1, 1, 1] = 88
print(arr3D[1, 1, 1])
//Print 88

四維維數組A[a][b][c][d]放到一維數組B中的對應公式:

A[i][j][k][w] = B[(i - 1) * (b * c * d) + (j - 1) * (c * d) + (k - 1) * d + w]

歸納演繹......

N維數組映射到一維數組

由此及彼，由表及里，歸納總結，創建一個Dim類，用一維數組存儲n維數組的數據，

此時我們只需關注每一個維度的數值，細節交由Dim來處理，這就是將原始數據類型包裝成包裝器類型或結構體的優點。

深入思考：

(1)、多維度中各維度所表示意義的順序可以任意確定，確定維度順序之后，就按照既定的維度順序進行對一維數組進行讀寫。

(2)、如同二維數組中可以按照行遍歷或者按照列遍歷一樣。多維數組也可以任意確定多維數組中下標i、j、k、w、...的順序。

下標順序確定之后就不可變更，根據下標順序得出對應公式，公式從上文中請歸納，就按照既定的下標順序進行對一維數組進行讀寫。

public struct Dim<T> {
    //用一個數組來接收維度信息
    //元素個數為維度
    //元素數值為對應維度的具體數量
    public let dimension:[Int]
    fileprivate var array:[T]
    //只能初始化一次
    public let product:Int
    //數組信息
    public let arrayInfo:String
    
    //初始化
    public init(dimension:[Int], initialValue: T) {
        self.dimension = dimension
        //數組各元素求積reduce(1)
        //用於一維數組保存多維數組的信息
        self.product = dimension.reduce(1) {$0 * $1}
        //初始化數組
        array = .init(repeating: initialValue, count: product)
        //初始化維度信息
        var str:String = " Array<T>("
        for i in 0...(dimension.count - 1)
        {
           str += String(i + 1) + "Dimension: \(dimension[i])," 
        }
        //刪除最后一個字符串‘，’
        str.remove(at: str.index(before: str.endIndex))
        str += ")"
        arrayInfo = str
    }
    
    //subscript函數可以檢索數組中的值
    //T?：讀取時如果輸入的維度不等於原維度則返回nil
    //取值需使用強制解包
    public subscript(_ numbers: Int...) -> T? {
        //讀取
        get 
        {
            //判斷元素個數是否等於維度數組個數
            if numbers.count == dimension.count
            {
                for i in 0...(dimension.count - 1)
                {
                    //先決條件
                    precondition( numbers[i] <= dimension[i], "\(String(i + 1))Dimension:\(numbers[i]) Index is out of range. " + arrayInfo)
                }
                return array[getIndex(numbers)]
            }
            return nil
        }
        
        //寫入
        set 
        {
            //判斷元素個數是否等於維度數組個數
            if numbers.count == dimension.count
            {
                for i in 0...(dimension.count - 1)
                {
                    //先決條件
                    precondition( numbers[i] <= dimension[i], "\(String(i + 1))Dimension:\(numbers[i]) Index is out of range. " + arrayInfo)
                }                
                array[getIndex(numbers)] = newValue!
            }
        }
        
    }
    //求解多維數組的元素在一維數組中的索引
    private func getIndex(_ dim: [Int]) -> Int
    {
        var sum:Int = 0
        for index in 0...(dim.count - 1)
        {
           sum += (dim[index] - 1) * getProduct(index)
        }
        return sum 
    }
    //求部分元素的積
    private func getProduct(_ index:Int) -> Int
    {
        //數組各元素求積
        var accumulate:Int = 1
        //加1
        var front:Int = index + 1
        let real:Int = dimension.count - 1
        if real > front
        {
            let arr:[Int] = [Int](dimension[front...real])
            if arr.count != 0
            {
                //數組各元素求積reduce(1)
                accumulate = arr.reduce(1){$0 * $1}
            }
        }
        return accumulate
    }
}

Dim類，用一維數組存儲n維數組的數據，示例：

// 創建一維數組的實例
var arr1 = Dim(dimension:[3], initialValue: 1)
print(arr1)
//Print Dim<Int>(dimension: [3], array: [1, 1, 1], product: 3, arrayInfo: " Array<T>(1Dimension: 3)")
// 創建二維數組的實例
var arr2 = Dim(dimension:[1,2], initialValue: 2)
print(arr2)
//Print Dim<Int>(dimension: [1, 2], array: [2, 2], product: 2, arrayInfo: " Array<T>(1Dimension: 1,2Dimension: 2)")
// 創建三維數組的實例
var arr3 = Dim(dimension:[1,2,3], initialValue: 3)
print(arr3)
//Print Dim<Int>(dimension: [1, 2, 3], array: [3, 3, 3, 3, 3, 3], product: 6, arrayInfo: " Array<T>(1Dimension: 1,2Dimension: 2,3Dimension: 3)")
// 創建四維數組的實例
var arr4 = Dim(dimension:[1,2,3,4], initialValue: 4)
print(arr4)
//Print Dim<Int>(dimension: [1, 2, 3, 4], array: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], product: 24, arrayInfo: " Array<T>(1Dimension: 1,2Dimension: 2,3Dimension: 3,4Dimension: 4)")
// 創建五維數組的實例
var arr5 = Dim(dimension:[1,2,3,4,5], initialValue: 5)
print(arr5)
//Print Dim<Int>(dimension: [1, 2, 3, 4, 5], array: [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], product: 120, arrayInfo: " Array<T>(1Dimension: 1,2Dimension: 2,3Dimension: 3,4Dimension: 4,5Dimension: 5)")
//......

//subscript函數可以檢索數組中的元素值，Optional為可選類型
//一維數組
arr1[2] = 11
print(arr1)
//Print Dim<Int>(dimension: [3], array: [1, 11, 1], product: 3, arrayInfo: " Array<T>(1Dimension: 3)")
let num1 = arr1[1]
print(num1)
//Print Optional(1)
//二維數組
arr2[1,2] = 22
print(arr2)
//Print  Dim<Int>(dimension: [1, 2], array: [2, 22], product: 2, arrayInfo: " Array<T>(1Dimension: 1,2Dimension: 2)")
let num2 = arr2[1,1]
print(num2)
//Print Optional(22)
//三維數組
arr3[1,1,1] = 33
print(arr3)
//Print Dim<Int>(dimension: [1, 2, 3], array: [33, 3, 3, 3, 3, 3], product: 6, arrayInfo: " Array<T>(1Dimension: 1,2Dimension: 2,3Dimension: 3)")
let num3 = arr3[1,1,1]
print(num3)
//Print Optional(33)
//四維數組
arr4[1,1,1,1] = 44
print(arr4)
//Print Dim<Int>(dimension: [1, 2, 3, 4], array: [44, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], product: 24, arrayInfo: " Array<T>(1Dimension: 1,2Dimension: 2,3Dimension: 3,4Dimension: 4)")
let num4 = arr4[1,1,1,1]
print(num4)
//Print Optional(44)
//五維數組
arr5[1,1,1,1,1] = 55
print(arr5)
//Print Dim<Int>(dimension: [1, 2, 3, 4, 5], array: [55, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], product: 120, arrayInfo: " Array<T>(1Dimension: 1,2Dimension: 2,3Dimension: 3,4Dimension: 4,5Dimension: 5)")
let num5 = arr5[1,1,1,1,1]
print(num5)
//Print Optional(55)
//......