选择排序

  选择排序的基本方法是：每步从带排序的元素中选出关键词最小（或最大）的元素，顺序放在已排序的元素的最后，直到全部排序完为止。这里介绍简单选择排序和堆排序。

简单选择排序

1.算法思想

  每次从无序区中挑选出一个最小的值，将其与无序区的第一个元素交换，初始有序区为空，无序区包含所有待排序元素。

2.性能分析

  简单选择排序算法的效率与初始数据的顺序无关。



3.完整代码

#include<iostream>
using namespace std;

void select_sort(int a[], int n) {
int k,temp=0;
//每次从无序区中选出最小的元素与无序区的第一个元素交换
for(int i=0;i<n;++i) {
//k标记无序区最小元素
k=i;
for(int j=i+1;j<n;++j)
if(a[j]<a[k])
k = j;

if(k!=i) {
temp = a[i];
a[i] = a[k];
a[k] = temp;
}
}
}

//输出数组
void print_array(int a[],int n) {
for(int i=0;i<n;++i){
cout<<a[i]<<" ";
}
cout<<endl;
}

int main() {
//简单选择排序测试数据
int a[] = {7,3,1,12,5,9};
int n = 6;
cout<<"Before sort:";
print_array(a,n);
cout<<"After binary insertion:";
select_sort(a,n);
print_array(a,n);

return 0;
}

测试结果如下：

堆排序

1.算法思想

  首先按照大根推的定义将数组调整为堆（初始建堆），交换根结点a[0]和最后一个结点a[n-1]（将最大元素a[0]归位）；然后将a[0]~a[n-2]重新调整为堆，交换a[0]和a[n-2]；如此反复，直到交换了a[0]和a[1]。

2.算法过程

（1）维护堆的性质

  AMX-HEAPIFY是用于维护最大堆性质的重要过程。它的输入为一个数组a和一个下标i。在调用MAX-HEAPIFY的时候，我们假定根结点为LEFT(i)和RIGHT(i)的二叉树都是最大堆，但这时a[i]有可能小于其孩子，这样就违背了最大堆的性质。MAX-HEAPIFY通过让a[i]在最大堆中“逐级下降”，从而使得以下标i为根结点的字数重新遵循最大堆的性质。

//假设以index为结点的左右子树Left(index)和Right（index）都为最大堆
//这时a[index]可能小于其孩子
//maxHeapify通过让a[index]在最大堆中“逐级下降”来维持最大堆的性质
void maxHeapify(int a[], int index) {
int l = Left(index);
int r = Right(index);
int largest = 0;
if(l<heapSize && a[l]>a[index])
largest = l;
else largest = index;
if(r<heapSize && a[r]>a[largest])
largest = r;
if(largest != index) {
swap(&a[largest],&a[index]);
maxHeapify(a,largest);
}
}

（2）建堆

  我们可以用自底向上的方法利用过程MAX-HEAPIFY把一个大小为n=A.length的数组a[0]~a[n-1]转换为最大堆。我们知道，每个叶子节点都可以堪称只包含一个元素的堆，通过过程BUILD-MAX-HEAP对树中非叶子结点从下标最大的开始都调用一次MAX-HEAPIFY来建堆。

void buildMaxHeap(int a[],int length) {
heapSize = length;
//含有n个结点的堆的下标最大的非叶子结点的标号为(n-2)/2
for(int i=(length-2)>>1;i>=0;--i)
maxHeapify(a,i);
}

（3）堆排序算法

  调用过程BUILD-MAX-HEAP初始化堆，交换a[0]与堆中最后一个结点，调用MAX-HEAPIFY(a,0)，重复这一过程直到堆的大小为1。

void heap_sort(int a[], int length) {
//初始化堆
buildMaxHeap(a,length);
//选择堆的根结点与最后一个结点交换
for(int i=length-1;i>=1;--i){
swap(&a[i],&a[0]);
--heapSize;
maxHeapify(a,0);
}
}

3.性能分析

  堆排序的时间效率与带排序数据的顺序无关。



4.完整代码

#include<iostream>
using namespace std;

int heapSize = 0;

int  Left(int index) {
return (index<<1)+1;
}

int Right(int index) {
return (index<<1)+2;
}

void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
//假设以index为结点的左右子树Left(index)和Right（index）都为最大堆
//这时a[index]可能小于其孩子
//maxHeapify通过让a[index]在最大堆中“逐级下降”来维持最大堆的性质
void maxHeapify(int a[], int index) {
int l = Left(index);
int r = Right(index);
int largest = 0;
if(l<heapSize && a[l]>a[index])
largest = l;
else largest = index;
if(r<heapSize && a[r]>a[largest])
largest = r;
if(largest != index) {
swap(&a[largest],&a[index]);
maxHeapify(a,largest);
}
}

void buildMaxHeap(int a[],int length) {
heapSize = length;
for(int i=(length-2)>>1;i>=0;--i)
maxHeapify(a,i);
}

void heap_sort(int a[], int length) {
buildMaxHeap(a,length);
for(int i=length-1;i>=1;--i){
swap(&a[i],&a[0]);
--heapSize;
maxHeapify(a,0);
}
}

//输出数组
void print_array(int a[],int n) {
for(int i=0;i<n;++i){
cout<<a[i]<<" ";
}
cout<<endl;
}

int main() {
//直接插入测试数据
int a[] = {4,10,16,2,12,9,7};
int n = 7;
cout<<"Before sort:";
print_array(a,n);
cout<<"After heap-sort:";
heap_sort(a,n);
print_array(a,n);
cout<<endl;

return 0;
}

测试结果如下：