The solution to LeetCode problem, https://leetcode.com/problems/symmetric-tree/

symmetric-tree.swift

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init() { self.val = 0; self.left = nil; self.right = nil; }
 *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
 *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
 *         self.val = val
 *         self.left = left
 *         self.right = right
 *     }
 * }
 */

class Queue<T> {
    private var array = [T]()
    
    func enque(_ val: T) {
        array.append(val)
    }
    
    func deque() -> T? {
        if isEmpty() { return nil }
        let temp = array[0]
        array.remove(at: 0)
        return temp
    }
    
    func popBack() -> T? {
        if isEmpty() { return nil }
        let temp = array.last!
        array.removeLast()
        return temp
    }
    
    
    func count() -> Int {
        return array.count
    }
    
    func isEmpty() -> Bool {
        return array.count == 0
    }
}

class Solution {
    func isSymmetric(_ root: TreeNode?) -> Bool {
        if root == nil { true }
        if root!.left == nil && root!.right == nil { return true }
        if root!.left == nil || root!.right == nil { return false }
        
        
        let queue = Queue<TreeNode>()
        let layers = Queue<Int>()
        queue.enque(root!)
        layers.enque(root!.val)
        var lastLayer = 0
        var lastArray = [Int?]()
        
        while queue.isEmpty() == false {
            let node = queue.deque()!
            let layer = layers.deque()!
            
            if lastLayer != layer {
                lastLayer = layer
                
                if !isSymArray(lastArray) {
                    return false
                }
                
                lastArray = [Int?]()
            }
            
            if node.left != nil {
                queue.enque(node.left!)
                layers.enque(layer+1)
                lastArray.append(node.left!.val)
            }
            else {
                lastArray.append(nil)
            }
            
            if node.right != nil {
                queue.enque(node.right!)
                layers.enque(layer+1)
                lastArray.append(node.right!.val)
            }
            else {
                lastArray.append(nil)
            }
        }
        
        return true
    }
    
    private func isSymArray(_ array: [Int?]) -> Bool {
        if array.count < 2 { return true }
        var front = 0
        var back = array.count - 1
        
        while front <= back {
            if array[front] != array[back] {
                return false
            }
            
            front += 1
            back -= 1
        }
        
        return true
    }
}