堆排序 Rust實現

堆排序

堆是一個數組，能夠當作一顆二叉樹

struct Heap(Vec<i32>);

impl Heap {
    //父節點索引
    fn parent(i: usize) -> usize {
        i / 2
    }
    //左子節點索引
    fn left(i: usize) -> usize {
        2 * i
    }
    //右子節點索引
    fn right(i: usize) -> usize {
        2 * i + 1
    }
}

首先要能維護最大堆(排序一般用最大堆)

思路就是找出該節點和兩個子節點的最大節點 若是該節點爲最大，則結束，不然，先交換，而後繼續判斷子節點 遞歸實現起來更簡單 具體實現以下

impl Heap {
    fn heap_size(&self) -> usize {
        self.0.len()
    }
    fn max_heapify(&mut self, mut i: usize) {
        loop {
            let l = Heap::left(i);
            let r = Heap::right(i);
            let mut largest;
            if l <= self.heap_size() && self.0[l - 1] > self.0[i - 1] {
                largest = l;
            } else {
                largest = i;
            }
            if r <= self.heap_size() && self.0[r - 1] > self.0[largest - 1] {
                largest = r;
            }

            if largest == i {
                break;
            } else {
                let tmp = self.0[i - 1];
                self.0[i - 1] = self.0[largest - 1];
                self.0[largest - 1] = tmp;
            }
            i = largest;
        }
    }
}

構建最大堆

依次對每一個節點都進行維護便可構建最大堆

impl Heap {
    fn build_max_heap(&mut self) {
        for i in (1..self.heap_size() + 1).rev() {
            self.max_heapify(i);
        }
    }
}

堆排序

1. 先構建一個最大堆
2. 交換第一個和最後一個元素的值
3. 縮小堆空間
4. 對第一個節點進行堆維護

impl Heap {
    fn heap_sort(&mut self) {
        let len = self.heap_size();
        self.build_max_heap();
        let mut v = Vec::with_capacity(self.heap_size());
        for i in (2..len + 1).rev() {
            let tmp = self.0[0];
            self.0[0] = self.0[i - 1];
            v.insert(0, tmp);
            let len = self.heap_size();
            self.0.truncate(len - 1);
            self.max_heapify(1);
        }
        self.0.append(&mut v);
    }
}

• 整個堆排序時間複雜度爲O(nlgn)
• 構建堆時間複雜度爲O(n)
• 每次維護堆爲O(lgn)， 總共調用n-1次