内部排序（3）——选择类排序

选择类排序

---

一、简单选择排序

---

简单选择排序的思路很简单：进行len-1趟选择，剩下一个元素就不用选择了，每一趟将选取的最小的元素放至该趟的起始位置i,那么从i开始到len为止的元素向后移动一位。然后再将这个最小值放在该处。代码如下：

void SelectSort(int a[], int len)   //简单选择排序 
{
    int i = 0,j = 0,pos = 0;
    for(i = 1; i< len; ++i)//选择的躺数；最后剩下的一个元素已经是最大的了不用再排一趟。 
    {
        a[0] = a[i]; //记录剩下的元素中最小的元素 
        pos = i;//记录最小元素的下标 
        for(j = i; j <= len; ++j)
        {
            if(a[j] < a[0])
            {
                a[0] = a[j];
                pos = j;
            } 
        }
        a[pos] = a[i];
        a[i] = a[0]; 
    } 
}

---

二、简单选择排序的改进

从上面可以看出，以上算法的时间复杂度为O(n^2),在这个基础上我们稍作改进：每趟选择最大和最小的两个元素，分别将第i个位置和找到的min交换，第len-i+1与第max个位置交换。代码如下：

void swap(int a[],int i,int j)
{
    a[0] = a[i];
    a[i] = a[j];
    a[j] = a[0];
}

void SelectSortAdvance(int a[],int len)
{
    int min =0,max = 0;//记录最小元素和最大元素的下标。
    int i = 0,j = 0;
    for(i = 1; i<= len/2; i++)     //最后剩下一个元素或者不剩，都是在中间不用变位置，故一共需要len/趟。 
    {
        min = i;
        max = i;
        for(j = i; j<= len+1-i; j++)   //注意边界len+1-i； 
        {
            if(a[j] > a[max])
            {
                max = j;
            }
            if(a[j] < a[min])
            {
                min = j;
            }
        }
        swap(a,i,min);
        swap(a,len-i+1,max); 
    } 
} 

---

三、堆排序

首先：由于堆是一棵完全二叉树，因此初次建立堆将99 , 58 , 230 , 100 , 75 , 69 , 200 , 180 , 66 , 18 , 135的值按下标从1开始一次存储进一个数组a[]；
然后：从n/2开始到1为止，依次做大根堆调整：选择左右结点中较大的值与该节点交换；然后从刚刚交换的子树结点开始，往下递归这个过程（可用循环实现），直止i大于n一次调整完毕。
全部调整完毕后如下所示：

这样堆化树就建立好了（这里我们建立的是大根堆）；
插入操作：每次插入最后一个位置，然后开始调整，调整的方法为：从该节点的父节点开始向上，递归地调整堆。
删除操作：每次删除根节点，然后将最后一个节点替换根节点，在进行一次由上而下的堆调整。

排序时，我们每次取堆顶的元素（最大），然后删除堆顶元素。堆化数组的下一个位置可用来存储刚刚删除的结点的值；这样就从后往前，调整了的整个数组。

void swap(int a[],int i,int j)
{
    a[0] = a[i];
    a[i] = a[j];
    a[j] = a[0];
}
void AdjustHeap(int a[],int n, int pos)
{
    if(pos*2 >  n)
    {
        return;
    }
    if(pos*2 +1 > n)
    {
        if(a[pos*2] > a[pos])
        {
            swap(a,pos,2*pos);
            AdjustHeap(a,n,pos*2);
        }
        else
        {
            return;
        }
    }
    else
    {
        if(a[pos*2] >= a[pos*2 +1])
        {

            if(a[pos*2] > a[pos])
            {
                swap(a,pos,2*pos);
                AdjustHeap(a,n,pos*2);
            }
            else
            {
                return;
            }   
        }
        else
        {

            if(a[pos*2 + 1] > a[pos])
            {
                swap(a,pos,2*pos + 1);
                AdjustHeap(a,n,pos*2 + 1);
            }
            else
            {
                return;
            }
        }

    }
} 
//删除根节点、并调整堆 
void DeleteRoot(int a[], int len)
{
    int tmp = a[1];
    a[1] = a[len];
    AdjustHeap(a,len-1,1);
    a[len] = tmp;
    PrintArry(a,9);
} 

void HeapSort(int a[], int len)
{
    //初次调整成大根堆 
    for(int i = len/2; i >0; --i)
    {
        AdjustHeap(a,len,i);        
    }
    //依次删除根节点 
    while(len)
    {
        DeleteRoot(a,len);
        len--;
    }   
    //
}

---

四、整体代码实现

---

#include<iostream>
using namespace std;

void SelectSort(int a[], int len)   //简单选择排序 
{
    int i = 0,j = 0,pos = 0;
    for(i = 1; i< len; ++i)//选择的躺数；最后剩下的一个元素已经是最大的了不用再排一趟。 
    {
        a[0] = a[i]; //记录剩下的元素中最小的元素 
        pos = i;//记录最小元素的下标 
        for(j = i; j <= len; ++j)
        {
            if(a[j] < a[0])
            {
                a[0] = a[j];
                pos = j;
            } 
        }
        a[pos] = a[i];
        a[i] = a[0]; 
    } 
}

void PrintArry(int a[],int len)  //打印函数 
{
    int i = 1;
    for(i = 1; i <= len; i++)
    {
        cout<<a[i]<<"  ";
    }
    cout<<endl;
} 

void swap(int a[],int i,int j)
{
    a[0] = a[i];
    a[i] = a[j];
    a[j] = a[0];
}

void SelectSortAdvance(int a[],int len)
{
    int min =0,max = 0;//记录最小元素和最大元素的下标。
    int i = 0,j = 0;
    for(i = 1; i<= len/2; i++)     //最后剩下一个元素或者不剩，都是在中间不用变位置，故一共需要len/趟。 
    {
        min = i;
        max = i;
        for(j = i; j<= len+1-i; j++)   //注意边界len+1-i； 
        {
            if(a[j] > a[max])
            {
                max = j;
            }
            if(a[j] < a[min])
            {
                min = j;
            }
        }
        swap(a,i,min);
        swap(a,len-i+1,max); 
    } 
} 

void AdjustHeap(int a[],int n, int pos)
{
    if(pos*2 >  n)
    {
        return;
    }
    if(pos*2 +1 > n)
    {
        if(a[pos*2] > a[pos])
        {
            swap(a,pos,2*pos);
            AdjustHeap(a,n,pos*2);
        }
        else
        {
            return;
        }
    }
    else
    {
        if(a[pos*2] >= a[pos*2 +1])
        {

            if(a[pos*2] > a[pos])
            {
                swap(a,pos,2*pos);
                AdjustHeap(a,n,pos*2);
            }
            else
            {
                return;
            }   
        }
        else
        {

            if(a[pos*2 + 1] > a[pos])
            {
                swap(a,pos,2*pos + 1);
                AdjustHeap(a,n,pos*2 + 1);
            }
            else
            {
                return;
            }
        }

    }
} 
//删除根节点、并调整堆 
void DeleteRoot(int a[], int len)
{
    int tmp = a[1];
    a[1] = a[len];
    AdjustHeap(a,len-1,1);
    a[len] = tmp;
    PrintArry(a,9);
} 

void HeapSort(int a[], int len)
{
    //初次调整成大根堆 
    for(int i = len/2; i >0; --i)
    {
        AdjustHeap(a,len,i);        
    }
    //依次删除根节点 
    while(len)
    {
        DeleteRoot(a,len);
        len--;
    }   
    //
}


int main()
{
    int a[] = {0,12,54,65,98,48,39,73,81,27};
//  SelectSort(a,9);
//    SelectSortAdvance(a,9);
    HeapSort(a,9); 
    PrintArry(a,9);
}

算法分析：
堆排序的时间复杂度为nlog2n.