Talking is cheap, show the codes.

层序遍历进行翻转二叉树

swift code

class TreeNode {

    var left: TreeNode?

    var right: TreeNode?

    var element: Int?

}

func invertBinaryTree(tempNode: TreeNode?) -> TreeNode? {

    guard let node = tempNode else {
        return tempNode
    }

    var queue = Array<TreeNode>()

    queue.append(node)

    while (queue.count > 0) {

        guard let node = queue.popLast() else { //本次可强制解包 因为queue.count > 0 已经保证数组一定一定有值，且整个过程不存在异步删除元素
            break
        }

        let temp = node.left

        node.left = node.right
        node.right = temp

        if let leftNode = node.left {
            queue.append(leftNode)
        }

        if let rightNode = node.right {
            queue.append(rightNode)
        }
    }

    return node    
}

快速排序

func quickSort(baseTo tempArr: inout Array<Int>, maxLenth: Int, begin : Int, end: Int) {

    var i: Int
    var j: Int
    
    if begin < end {
        
        i = begin + 1
        j = end
        
        //本次while循环，目的是确保 中间位置 左边的元素 一定小于 右边的元素
        while i < j {
            
            if tempArr[i] > tempArr[begin] { //i位置的元素大于基准值，进行以下交换
                        
                //此次交换 确保了当前j的值一定大于选定的设定值，且一定在基准值 （选定的某个元素一般选定初始值）的右侧
                let temp = tempArr[i]
                tempArr[i] = tempArr[j]
                tempArr[j] = temp
                
                //已经确保了j位置的值大于基准值，所以下一步还进行arr【i】和j-1位置元素的值比较
                j -= 1
                
                
            } else { //否则，就是i位置的元素小于基准值，对i元素进行+1操作
                
                i += 1
                
            }
                                    
        }
        
        //为了防止i位置的值以及i前面的几个值和 基准值 都相等，所以要找到小于基准值的最大位置，然后进行于基准值的交换
        while (tempArr[i] >= tempArr[begin]) {
            
            i -= 1;
        }
        //然后进行于基准值的交换
        tempArr.swapAt(i, begin)
        
        
        //此时，数组可以分成给两个部分 【 小于 基准值的元素集合 】【大于 基准值的 集合】
        
        //【 小于 基准值的元素集合 】递归进行上述的比较操作
        quickSort(baseTo: &tempArr, maxLenth: maxLenth, begin: begin, end: i)
        
        //【大于 基准值的 集合】递归进行上述的比较操作
        quickSort(baseTo: &tempArr, maxLenth: maxLenth, begin: j, end: end)
        
    }
    
}