彻底二叉树实现优先队列与堆排序

本文的目标是要作出优先队列和堆排序两个Demo。

• 彻底二叉树
• 优先队列
• 堆排序

彻底二叉树

彻底二叉树的定义是创建在满二叉树定义的基础上的，而满二叉树又是创建在二叉树的基础上的。

大体了解一下概念

一、树是一对多的数据结构，从一个根结点开始，生长出它的子结点，而每个子结点又生长出各自的子结点，成为子树。若是某个结点再也不生长出子结点了，它就成为叶子。 二、二叉树每一个结点最多只有两棵子树，并且左右子树是有顺序的，不可颠倒。

三、满二叉树的全部分支结点都既有左子树又有右子树，而且全部叶子都在同一层。满二叉树看起来的感受很完美，没有任何缺失。

四、彻底二叉树不必定是满的，但它自上而下，自左而右来看的话，是连续没有缺失的。

• 对一棵具备n个结点的二叉树按层序编号，若是编号为i (1 <= i <= n)的结点与一样深度的满二叉树中编号为i的结点在二叉树中位置彻底相同，则这棵二叉树称为彻底二叉树。

性质

彻底二叉树有好几条性质，其中有一条在本文中须要用到：

对于一棵有n个结点的彻底二叉树，对其结点按层序编号，从上到下，从左到右，对任一结点i (1 = i <= n)有：

1. 若是i = 1，则结点i是二叉树的根，无父结点；若是i > 1，则其父结点的位置是⌊i / 2⌋（向下取整）。
2. 若是2i > n，则结点i无左孩子（结点i为叶子结点）；不然其左孩子是结点2i。
3. 若是2i + 1 > n，则结点i无右孩子；不然其右孩子是结点2i + 1。

存储结构

得益于二叉树的严格定义，咱们只须要把彻底二叉树按层序遍历依次把结点存入一维数组中，其数组下标就可以体现出父子结点关系来（数组第0位不使用）。

优先队列 (Priority Queue)

彻底二叉树的概念大体了解后，下面进入正题，看看如何把它用起来。

• 普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。
• 在优先队列中，元素被赋予优先级。当访问元素时，具备最高优先级的元素最早删除。优先队列具备最高级先出的行为特征。

为何使用彻底二叉树来实现优先队列？

优先队列按数据结构的不一样有几种实现方式：

1. 有序数组。每次入队操做时都对数组从新排序，把入队元素放在合适位置，维持数组有序；每次出队操做只需删除数组第一位便可，因第一位老是优先值最大的元素，应被最早删除（降序排列的状况下）。
2. 无序数组。每次入队操做直接追加在数组末尾；每次出队操做须要遍历整个数组来寻找最大优先值。
3. 彻底二叉树(堆)。假如咱们能保证二叉树的每个父结点的优先值都大于或者等于它的两个子结点，那么在整棵树看来，顶部根结点一定就是优先值最大的。这样的树结构能够称为堆有序，而且由于最大值在根部，也称为大顶堆。 在每次出队操做时，只须要把根结点出队便可，而后从新调整二叉树恢复堆有序；在每次入队操做时把元素追加到末尾，一样调整二叉树恢复堆有序。

综合了入队和出队两个操做来看，使用彻底二叉树来实现的优先队列在时间效率上是最高的。

队列的操做

一个队列应该提供两个关键的方法：入队列和出队列。

typedef NSComparisonResult(^JXPriorityQueueComparator)(id obj1, id obj2);

@interface JXPriorityQueue : NSObject

/// 定义元素的比较逻辑
@property (nonatomic, copy) JXPriorityQueueComparator comparator;

/// 入列
- (void)enQueue:(id)element;

/// 出列
- (id)deQueue;

@end
复制代码

入列

入列总的来讲分为两步：

1. 把元素加入进来
2. 而后上游元素到合适的位置

- (void)enQueue:(id)element {
    // 添加到末尾
    [self.data addObject:element];
    
    // 上游元素以维持堆有序
    [self swimIndex:self.tailIndex];
}

/// 上游，传入须要上游的元素位置，以及容许上游的最顶位置
- (void)swimIndex:(NSInteger)index {
    // 暂存须要上游的元素
    id temp = self.data[index];
    
    // parent的位置为本元素位置的1/2
    for (NSInteger parentIndex = index / 2; parentIndex >= 1; parentIndex /= 2) {
        // 上游条件是本元素大于parent，不然不上游
        if (self.comparator(temp, self.data[parentIndex]) != NSOrderedDescending) {
            break;
        }
        // 把parent拉下来
        self.data[index] = self.data[parentIndex];
        // 上游本元素
        index = parentIndex;
    }
    // 本元素进入目标位置
    self.data[index] = temp;
}
复制代码

这里关键在于如何上游元素：

1. 在元素加入进来后，与其父结点比较，假如大于父结点，则把元素上游到父结点的位置。
2. 在上游到父结点位置后，再和当前所处结点的父结点比较，若是大于父结点，继续上游。
3. 重复，直到整棵树调整成为大顶堆。

出列

把优先值最大的元素(根结点)出列，可分为以下步骤：

1. 交换首尾两个元素的位置，这样尾元素将会成为根结点，堆有序被打破。
2. 剪掉被交换到末尾的原根元素
3. 把交换到根结点的元素下沉到合适位置，从新调整为大顶堆
4. 返回被剪出的元素，即为须要出列的最大优先值元素

- (id)deQueue {
    if (self.count == 0) {
        return nil;
    }
    // 取根元素
    id element = self.data[1];
    // 交换队首和队尾元素
    [self swapIndexA:1 indexB:self.tailIndex];
    [self.data removeLastObject];
    
    if (self.data.count > 1) {
        // 下沉刚刚交换上来的队尾元素，维持堆有序状态
        [self sinkIndex:1];
    }
    return element;
}

/// 交换元素
- (void)swapIndexA:(NSInteger)indexA indexB:(NSInteger)indexB {
    id temp = self.data[indexA];
    self.data[indexA] = self.data[indexB];
    self.data[indexB] = temp;
}

/// 下沉，传入须要下沉的元素位置，以及容许下沉的最底位置
- (void)sinkIndex:(NSInteger)index {
    // 暂存须要下沉的元素
    id temp = self.data[index];
    
    // maxChildIndex指向最大的子结点，默认指向左子结点，左子结点的位置为本结点位置*2
    for (NSInteger maxChildIndex = index * 2; maxChildIndex <= self.tailIndex; maxChildIndex *= 2) {
        // 若是存在右子结点，而且左子结点比右子结点小
        if (maxChildIndex < self.tailIndex && (self.comparator(self.data[maxChildIndex], self.data[maxChildIndex + 1]) == NSOrderedAscending)) {
            // 指向右子结点
            ++ maxChildIndex;
        }
        // 下沉条件是本元素小于child，不然不下沉
        if (self.comparator(temp, self.data[maxChildIndex]) != NSOrderedAscending) {
            break;
        }
        // 不然
        // 把最大子结点元素上游到本元素位置
        self.data[index] = self.data[maxChildIndex];
        // 标记本元素须要下沉的目标位置，为最大子结点原位置
        index = maxChildIndex;
    }
    // 本元素进入目标位置
    self.data[index] = temp;
}
复制代码

这里关键在于如何把剪枝后的树从新调整为大顶堆，在下沉方法中：

1. 将其左右两个子结点比较一下，找出值最大的那个子结点。
2. 与最大子结点比较，若是本身比最大子结点还要大，或者等于最大子结点，则无须下沉；若是比子结点小，则为了调整为大顶堆，本身就须要下沉到子结点的位置。
3. 在进入到子结点位置后，再和当前所处结点的子结点比较，若是小于子结点，继续下沉。
4. 重复，直到整棵树调整成为大顶堆。

堆排序 (Heap Sort)

堆排序是对简单选择排序的一种改进，改进后的效果很是明显。选择排序的时间复杂度是n²，堆排序是nlog₂n。

堆排序总的来讲分为两个步骤：

1. 构造大顶堆。从下往上、从右到左，把每一个非终结点（即叶子结点）看成根结点，将其和其子树调整成大顶堆。
2. 对大顶堆进行排序。这一步骤和优先队列的出列操做是很是类似的，都是不断地把大顶堆根结点交换到末尾位置，而后剪掉，再把这样剪枝后的树从新调整成大顶堆以找出下一个最大值，放在根结点，继续进行新一轮剪枝。 这是一个不断选择最大值，依次排列起来的过程。

NSMutableArray+JXHeapSort.h

typedef NSComparisonResult(^JXSortComparator)(id obj1, id obj2);
typedef void(^JXSortExchangeCallback)(id obj1, id obj2);
typedef void(^JXSortCutCallback)(id obj, NSInteger index);

@interface NSMutableArray (JXHeapSort)

// 堆排序
- (void)jx_heapSortUsingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback didCut:(JXSortCutCallback)cutCallback;

@end
复制代码

NSMutableArray+JXHeapSort.m

@implementation NSMutableArray (JXHeapSort)

/// 堆排序
- (void)jx_heapSortUsingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback didCut:(JXSortCutCallback)cutCallback {
    // 排序过程当中不使用第0位
    [self insertObject:[NSNull null] atIndex:0];
    
    // 构造大顶堆
    // 遍历全部非终结点，把以它们为根结点的子树调整成大顶堆
    // 最后一个非终结点位置在本队列长度的一半处
    for (NSInteger index = self.count / 2; index > 0; index --) {
        // 根结点下沉到合适位置
        [self sinkIndex:index bottomIndex:self.count - 1 usingComparator:comparator didExchange:exchangeCallback];
    }
    
    // 彻底排序
    // 从整棵二叉树开始，逐渐剪枝
    for (NSInteger index = self.count - 1; index > 1; index --) {
        // 每次把根结点放在列尾，下一次循环时将会剪掉
        [self jx_exchangeWithIndexA:1 indexB:index didExchange:exchangeCallback];
        if (cutCallback) {
            cutCallback(self[index], index - 1);
        }
        // 下沉根结点，从新调整为大顶堆
        [self sinkIndex:1 bottomIndex:index - 1 usingComparator:comparator didExchange:exchangeCallback];
    }
    
    // 排序完成后删除占位元素
    [self removeObjectAtIndex:0];
}

/// 下沉，传入须要下沉的元素位置，以及容许下沉的最底位置
- (void)sinkIndex:(NSInteger)index bottomIndex:(NSInteger)bottomIndex usingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback {
    for (NSInteger maxChildIndex = index * 2; maxChildIndex <= bottomIndex; maxChildIndex *= 2) {
        // 若是存在右子结点，而且左子结点比右子结点小
        if (maxChildIndex < bottomIndex && (comparator(self[maxChildIndex], self[maxChildIndex + 1]) == NSOrderedAscending)) {
            // 指向右子结点
            ++ maxChildIndex;
        }
        // 若是最大的子结点元素小于本元素，则本元素没必要下沉了
        if (comparator(self[maxChildIndex], self[index]) == NSOrderedAscending) {
            break;
        }
        // 不然
        // 把最大子结点元素上游到本元素位置
        [self jx_exchangeWithIndexA:index indexB:maxChildIndex didExchange:exchangeCallback];
        // 标记本元素须要下沉的目标位置，为最大子结点原位置
        index = maxChildIndex;
    }
}

/// 交换两个元素
- (void)jx_exchangeWithIndexA:(NSInteger)indexA indexB:(NSInteger)indexB didExchange:(JXSortExchangeCallback)exchangeCallback {
    id temp = self[indexA];
    self[indexA] = self[indexB];
    self[indexB] = temp;
    
    if (exchangeCallback) {
        exchangeCallback(temp, self[indexA]);
    }
}

@end
复制代码

在Demo中，nodeArray是一个UILabel数组：

@property (nonatomic, strong) NSMutableArray<UILabel *> *nodeArray;
复制代码

对这个数组进行排序，并借助信号量在线程间通讯，控制排序速度：

dispatch_semaphore_t sema = dispatch_semaphore_create(0);
    
// 定时发出信号，以容许继续交换
NSTimer *timer = [NSTimer scheduledTimerWithTimeInterval:0.6 repeats:YES block:^(NSTimer * _Nonnull timer) {
    dispatch_semaphore_signal(sema);
}];

[self.nodeArray jx_heapSortUsingComparator:^NSComparisonResult(id obj1, id obj2) {
    // 比较两个结点
    return [self compareWithNodeA:obj1 nodeB:obj2];
} didExchange:^(id obj1, id obj2) {
    // 交换两结点
    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
    [self exchangeNodeA:obj1 nodeB:obj2];
} didCut:^(id obj, NSInteger index) {
    // 剪枝
    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
    [self cutNode:obj index:index];
}];
复制代码

源码

优先队列：https://github.com/JiongXing/JXPriorityQueue 堆排序：https://github.com/JiongXing/JXHeapSort 排序算法比较 : https://github.com/JiongXing/JXSort