选择排序

思想：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。

void swap(int*a,int*b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}
void select_sort(int A[],int n)
{
    register int i,j,min,m;
    for(i=0;i<n-1;i++)
    {
        min=i;//查找最小值
        for(j=i+1;j<n;j++)
        {
            if(A[min]>A[j])
            {
                min=j;
            }
        }
        if(min!=i)
        {
            swap(&A[min],&A[i]);
        }
    }
}   

转载自：http://blog.csdn.net/ye_scofield/article/details/39312717
简单选择排序的改进——二元选择排序
简单选择排序，每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序，最多只需进行[n/2]趟循环即可。具体实现如下：

    int tmp;  
    int minIndex, maxIndex;  
    for (int i = 0; i <= n / 2; i++) {  
        minIndex = i;  
        maxIndex = i;  
        for (int j = i; j < n - i - 1; j++) {  

            if (arr[j] > arr[maxIndex]) {  
                maxIndex = j;  
                continue;  
            }  
            if (arr[j] < arr[minIndex]) {  
                minIndex = j;  

            }  

        }  
        if (maxIndex == i && minIndex == n - i - 1) {  
            //特殊交换位置一，当最大的交换位置和最小的交换位置都在最前面和最后面  
            tmp = arr[maxIndex];  
            arr[maxIndex] = arr[minIndex];  
            arr[minIndex] = tmp;  
        } else  
        if (maxIndex == i) {  
            //特殊交换位置二，当最大的交换位置是最前面  
            // Swap(arr[n - i], arr[maxIndex]) ;  
            tmp = arr[maxIndex];  
            arr[maxIndex] = arr[n - i - 1];  
            arr[n - i - 1] = tmp;  

            // Swap(arr[i], arr[minIndex]) ;  
            tmp = arr[minIndex];  
            arr[minIndex] = arr[i];  
            arr[i] = tmp;  
        } else  
        if (minIndex == n - i - 1) {  
            //特殊交换位置三，当最小的交换位置是最后面  
            // Swap(arr[i], arr[minIndex]) ;  
            tmp = arr[minIndex];  
            arr[minIndex] = arr[i];  
            arr[i] = tmp;  

            // Swap(arr[n - i], arr[maxIndex]) ;  
            tmp = arr[maxIndex];  
            arr[maxIndex] = arr[n - i - 1];  
            arr[n - i - 1] = tmp;  

        } else {  
            //除了上面三种特殊交换，就剩普通交换了，普通交换随便哪个先交换都行  
            // Swap(arr[i], arr[minIndex]) ;  
            tmp = arr[minIndex];  
            arr[minIndex] = arr[i];  
            arr[i] = tmp;  

            // Swap(arr[n - i], arr[maxIndex]) ;  
            tmp = arr[maxIndex];  
            arr[maxIndex] = arr[n - i - 1];  
            arr[n - i - 1] = tmp;  
        }  
        sortTest.dispaly(arr);   //自己写的输出函数  
    }  
    return arr;  
} 

树形选择排序：
堆排序是一种树形选择排序，是对直接选择排序的有效改进。
//堆排序:树形选择排序，将带排序记录看成完整的二叉树，第一步：建立初堆，第二步：调整堆

void HeapAdjust(int a[],int s,int n)//第二步：调整堆    
{   
//调整为小根堆，从小到大  
    int rc=a[s];  
    for(int j=2*s;j<=n;j*=2)  
    {  
        if(j<n && a[j]>a[j+1])//判断左右子数大小  
            j++;  
        if(rc<=a[j])  
            break;  
        a[s]=a[j];  
        s=j;  
    }  
    a[s]=rc;  
}   


void CreatHeap(int a[],int n)//第一步：建初堆    
{  
    //小根堆  
    for(int i=n/2;i>0;i--)  
    HeapAdjust(a,i,n);  
}   


void HeapSort(int a[],int n)  //整合  
{  
    CreatHeap(a,n);//第一步，建立初堆  
    for(int i=n;i>1;i--)  
    {  
        int x=a[1];//堆顶与最后一个元素互换  
        a[1]=a[i];  
        a[i]=x;  
        HeapAdjust(a,1,i-1);  
    }  
}