基本思想：每一趟（如第i趟）在后面n-i+1（i=1，2...n-1）个待排序元素中选取关键字最小的元素，作为有序子序列的第i个元素，直到第n-1趟排完。

简单选择排序

void SelectSort(ElemType A[], int n)
{
    for(i=0;i<n-1;++i){
        min=i; //记录小最小元素的位置
        for(j=i+1;j<n;++j)
            if(A[j]<A[min])  min=j;
        if(min!=i)  swap(A[i], A[min]);
    }
}

空间效率 O(1)
时间效率 O(n^2)
不稳定
第i个元素和当前最小元素交换时，可能会改变第i个元素与其相同关键字元素的相对位置（本来在前面的被换到后面去了）

堆排序

void BuildMaxHeap(ElemType A[], int len){
    for(int i=len/2;i>0;i--)
        AdjustDown(A, i, len);
}

void AdjustDown(ElemType A[], int k, int len)
{
    A[0]=A[k]; //A[0]用来暂存
    for(i=2*k;i<=len;i*=2){
        if(i<len&&A[i]<A[i+1])
            ++i;
        if(A[0]>=A[i]) break;
        else{
            A[k]=A[i];
            k=i;
        }
    }
    A[k]=A[0];
}

O(n)
基本思想：在排序过程中，将序列视为一棵完全二叉树的顺序存储，首先将L[1...n]个元素建成初始大顶堆，在一次输出堆顶元素

void HeapSort(ElemType A[], int len)
{
    BuildMaxHeap(A, len);
    for(i=len;i>1;--i){
        Swap(A[i], A[1]);    //输出堆顶元素（和堆底元素交换）
        AdjustDown(A, 1, i-1);
    }
}

空间效率O(1)
时间效率O(nlog2n)
不稳定
进行筛选时，有可能把本来排在前面的先调到堆顶，先输出，那就被调到后面去了。