2013-04-21 翻阅《算法导论》

再谈堆排序

堆排序利用的特性——堆的数据结构特征：最大/最小 的元素总是在根处取得。

那么要利用根来排序，我们只需要保持堆的特性，然后每次把最后的元素与根交换，取出根元素就可以了。但是这个过程需要用到整堆，即保证这个数组能够形成堆的特征（这里对最大堆来讲）：父节点总是比子节点要大。

整堆就是对这种“僭越”的清洗，说起来很残忍，其实就是如果比自己小的占用了上位，则和它交换，这样递归下去，就一定能够让整棵树变得“井井有条”。

 

这次我用python来实现一个堆。

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
# heapsort of python
# by bibodeng
# 2013-04-21
'''
DEBUG=1
                                          
class heap_sort:
    array = []      #the array to be sort
    heap_size = 0
                                              
    def __init__(self, array):
        self.array = array      #the array to be sort
        self.heap_size = len(self.array) - 1
        '''print self.array
        print self.heap_size'''
                                              
    # find the parent node index in array
    def parent(self,i):
        return i>>1
                                                  
    def left_child(self,i):
        return (i<<1) + 1
                                                  
    def right_child(self,i):
        return (i<<1) + 2
                                                  
    def heap_max(self):
        return self.array[0]
                                                  
    def swap(self,x,y):
        return y,x
                                              
    # make the array fit heap from node i
    def max_heapify(self, i):  
        # judge the i is smaller than his child
        l = self.left_child(i)
        r = self.right_child(i)
        largest  = i
        # left
        if l <= self.heap_size and array[i] < array[l]:
            largest = l
        # right
        if r <= self.heap_size and array[largest] < array[r] :
            largest = r
        # exchange the largest with i
        if largest != i:
            array[i],array[largest] = self.swap(array[i], array[largest])
            # recur
            self.max_heapify(largest)
                                                      
                                              
    # make the array is a heap
    def build_heap(self):
        # self.heap_size = self.array.len()
        for i in range((self.heap_size/2), -1, -1):
            # print "heapify node", i ,":", self.array[i]
            self.max_heapify(i)
                                                  
                                              
    def h_sort(self):
        print "before build: ",self.array
        # first , build heap
        self.build_heap()
        # second get the heap node by order
        # print self.heap_size
        print "after build: ",self.array
        for i in range(self.heap_size, -1, -1):
            # get root
            print "the ",i,"num : ", self.heap_max()
            self.array[0] = self.array[i]
            del self.array[i]
            self.heap_size -= 1
            # heapify the array
            self.max_heapify(0)
                                                  
                                          
# call the program to run
array = []
if DEBUG == 1:
    array.extend([3,2,5,4,6,9,1,10,20])
else:
    tmp = int(raw_input("input one number :"))
    while(tmp > 0):
        array.append(tmp);
        tmp = int(raw_input("input one number :"))
                                                  
# 正式验证程序功能 
sort_example = heap_sort(array)
sort_example.h_sort()
                                              
                                                

优先队列

 

在堆的基础上，添加了增长key功能，这样增长后的元素要遵守堆的规则，在合适的地方排队。故而需要自底向上地整堆，如果比父节点大，就一直交换。其实堆本身就已经具备了优先队列的功能了，增加功能会变得更加灵活，因为优先权可能是会改变的。

 

添加一个插入功能，其实是在最后添加一个无穷小的元素（这样就可以理所当然地排在最后），然后对它进行增长key，然后它的位置就改变了。

 

by bibodeng  2013-04-21 21:54:21