template<class T>
void bubble_sort(std::vector<T> &v){
for (int i = 0; i<v.size(); i++) {
for (int j = i; j<v.size()-i-1; j++) {
if (v[j+1]<v[j]) { //if next one is smaller then swap
std::swap(v[j], v[j+1]);
}
}
}
}
template <class T>
void insert_sort(std::vector<T> &v) {
if (v.size() > 1) {
for (int i = 0; i<v.size()-1; i++) {
T next_value = v[i+1];
int next = i+1;
while(v[next-1] > next_value ){ //if next one is smaller than previous
v[next] = v[next-1]; //overwrite the next one with privous
next--;
}
v[next] = next_value;
}
}
}
template <class T>
void count_sort(std::vector<T> &v, int max) {
//create a count vector
std::vector<int> count(max+1);
for (int i = 0; i < v.size(); i++) {
count.at(v[i]) ++;
}
//self increment of count vector
for (int i = 1; i < count.size(); i++) {
count[i] += count[i-1];
}
//create result vector
std::vector<int> result(v.size());
//put the element in the correct position in result vector
for (int i = 0; i<v.size(); i++) {
int current_index = count[v[i]]-1;
result[current_index] = v[i];
count[v[i]] --;
}
//copy the result to the input vector
v=result;
}
def heapify(arr, n, i):
# 先把parent设为最大的,parent的位置为i
largest = i
# 然后根据公式 写出左右child 的位置 2i+1, 2i+2
l = 2 * i + 1
r = 2 * i + 2
# 如果左孩子存在,也就是l< n 且左孩子的值比largest的位置的值大
# 则设最大值的位置为左孩子的位置
if l < n and arr[largest] < arr[l]:
largest = l
# 同理判断右孩子存在与否 并和largest位置的值比较
if r < n and arr[largest] < arr[r]:
largest = r
# 如果largest的位置和parent的位置不一样,证明最大值不在parent那里
# 则将largest位置的元素和parent位置的元素交换
# 并且继续递归调用
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i] # swap
heapify(arr, n, largest)
def heap_sort(arr):
n = len(arr)
# 对于数组表示的二叉堆,能作为parent的只有前 n//2 -1 个元素
# 应该从最下面的parent开始进行最大堆化,
# 这样才能保证循环完整个二叉堆都是最大堆
# 可以由不等式的方式说明
for i in range(n//2-1, -1, -1):
heapify(arr, n, i)
# 建立完二叉堆之后就是顺序取出二叉堆的元素即可得到有序数组
# 方法把第一个放到最后,然后固定最后的再把前面的最大堆化
for i in range(n-1, 0, -1):
arr[i], arr[0] = arr[0], arr[i]
heapify(arr, i, 0)