• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号
登陆 注册

Swift-几种使用数组的数据存储模型

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

在iOS游戏开发中，比如2048游戏。有时会需要存储N×N数组的数据模型（如3×3，4×4等）。这里我们演示了三种实现方式，分别是：一维数组、仿二维数组、自定义二维数组（即矩阵结构）。
功能是根据传入维度初始化数组，同时提供设置值和打印输出所有值的功能，判断数组是否已满（全不为0），以及目前空位的坐标集。 


1，使用一维数组实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import Foundation
class GameModel
{
    var dimension:Int = 0
    var tiles:Array<Int>
     
    init(dimension:Int)
    {
        self.dimension = dimension
        self.tiles = Array<Int>(count:self.dimension*self.dimension, repeatedValue:0)
         
    }
     
    //找出空位置
    func emptyPositions()-> [Int]
    {
         
        var emptytiles = Array<Int>()
        //var index:Int
        for i in 0..<(dimension*dimension)
        {
            if(tiles[i] == 0)
            {
                emptytiles.append(i)
            }
        }
        return emptytiles
    }
     
    //位置是否已满
    func isFull()-> Bool
    {
        if(emptyPositions().count == 0)
        {
            return true
        }
        return false
    }
     
    //输出当前数据模型
    func printTiles()
    {
        println(tiles)
        println("输出数据模型数据")
        var count = tiles.count
        for var i=0; i<count; i++
        {
            if (i+1) % Int(dimension) == 0
            {
                println(tiles[i])
            }
            else
            {
                print("\(tiles[i])\t")
            }
        }
        println("")
         
    }
     
    //如果返回 false ,表示该位置 已经有值
    func setPosition(row:Int, col:Int, value:Int) -> Bool
    {
        assert(row >= 0 && row < dimension)
        assert(col >= 0 && col < dimension)
        //3行4列，即  row=2 , col=3  index=2*4+3 = 11
        //4行4列，即  3*4+3 = 15
        var index = self.dimension * row + col
        var val = tiles[index]
        if(val > 0)
        {
            println("该位置(\(row), \(col))已经有值了")
            return false
        }
        tiles[index] = value
        return true
    }
}


2，使用二维数组实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import Foundation
class GameModelBA
{
    var dimension:Int = 0
    var tiles:Array<Array<Int>>
     
    //由外部来传入维度值
    init(dimension:Int)
    {
        self.dimension = dimension
        self.tiles = Array(count:self.dimension,
            repeatedValue:Array(count:self.dimension, repeatedValue:0))
    }
     
    //找出空位置
    func emptyPositions()-> [Int]
    {
        var emptytiles = Array<Int>()
        //var index:Int
        for row in 0..<self.dimension
        {
            for col in 0..<self.dimension
            {
                if(tiles[row][col] == 0)
                {
                    emptytiles.append(tiles[row][col])
                }
            }
        }
        return emptytiles
    }
     
    //如果返回 false ,表示该位置 已经有值
    func setPosition(row:Int, col:Int, value:Int) -> Bool
    {
        assert(row >= 0 && row < dimension)
        assert(col >= 0 && col < dimension)
         
        var val = tiles[row][col]
        if(val > 0)
        {
            println("该位置(\(row), \(col))已经有值了")
            return false
        }
        printTiles()
        //tiles[row][col] = value
        var rdata = Array(count:self.dimension, repeatedValue:0)
        for i in 0..<self.dimension
        {
            rdata[i] = tiles[row][i]
        }
        rdata[col] = value
        tiles[row] = rdata
        return true
    }
     
    //位置是否已满
    func isFull()-> Bool
    {
        if(emptyPositions().count == 0)
        {
            return true
        }
        return false
    }
     
    //输出当前数据模型
    func printTiles()
    {
        println(tiles)
        println("输出数据模型数据")
        var count = tiles.count
        for row in 0..<self.dimension
        {
            for col in 0..<self.dimension
            {
                print("\(tiles[row][col])\t")
            }
            println("")
        }
        println("")
    }
}


3，使用自定义二维数组（即矩阵结构）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
import Foundation
//自定义矩阵数据结构
struct Matrix {
    let rows: Int, columns: Int
    var grid: [Int]
     
    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        grid = Array(count: rows * columns, repeatedValue: 0)
    }
     
    func indexIsValidForRow(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }
     
    subscript(row: Int, column: Int) -> Int {
        get {
            assert(indexIsValidForRow(row, column: column), "超出范围")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValidForRow(row, column: column), "超出范围")
            grid[(row * columns) + column] = newValue
        }
    }
}
 
class GameModelMatrix
{
    var dimension:Int = 0
    var tiles:Matrix
     
    //由外部来传入维度值
    init(dimension:Int)
    {
        self.dimension = dimension
        self.tiles = Matrix(rows: self.dimension, columns: self.dimension)
    }
     
    //找出空位置
    func emptyPositions()-> [Int]
    {
        var emptytiles = Array<Int>()
        //var index:Int
        for row in 0..<self.dimension
        {
            for col in 0..<self.dimension
            {
                var val = tiles[row,col]
                if(val == 0)
                {
                    emptytiles.append(tiles[row, col])
                }
            }
        }
        return emptytiles
    }
     
    //如果返回 false ,表示该位置已经有值
    func setPosition(row:Int, col:Int, value:Int) -> Bool
    {
        assert(row >= 0 && row < dimension)
        assert(col >= 0 && col < dimension)
         
        var val = tiles[row,col]
        if(val > 0)
        {
            println("该位置(\(row), \(col))已经有值了")
            return false
        }
        printTiles()
        tiles[row, col] = value
        printTiles()
        return true
    }
     
    //位置是否已满
    func isFull()-> Bool
    {
        if(emptyPositions().count == 0)
        {
            return true
        }
        return false
    }
     
    //输出当前数据模型
    func printTiles()
    {
        println(tiles)
        println("输出数据模型数据")
        for row in 0..<self.dimension
        {
            for col in 0..<self.dimension
            {
                print("\(tiles[row, col])\t")
            }
            println("")
        }
        println("")
    }
}

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
[Swift]LeetCode852.山脉数组的峰顶索引|PeakIndexinaMountainArray发布时间：2022-07-13
下一篇：
[Swift]Xcode7设置网络请求权限发布时间：2022-07-13
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap