选择排序(C++/Java实现)

常用的选择排序算法有两种：直接选择排序和堆排序。 

一、直接选择排序

基本思路：

第一趟比较：程序将记录定位在第一个数据上，拿第一个数据依次和后面的数据进行比较，如果第一个数据大于后面的某个数据，交换它们，....依次进行下去。这趟比较将选出最小的数据并将其排在第一位。

第二趟比较：程序将记录定位在第二个数据上，拿第二个数据依次和后面的数据进行比较，如果第二个数据大于后面的某个数据，交换它们，....依次进行下去。这趟比较将选出第二小的数据并将其排在第二位。

......

依此规则进行比较n-1趟，这组数据中第2大的数据被选出之后，被排在倒数第1位，剩下的就是最大的数了。

Java实现代码：

//定义一个数据包装类  
public class DataWrap implements Comparable<DataWrap>    
{  
    int data;  
    String flag;  
    public DataWrap(int data, String flag)  
    {  
        this.data = data;  
        this.flag = flag;  
    }  
    public String toString()  
    {  
        return data + flag;  
    }  
    //根据data实例变量来决定两个DataWrap的大小  
    public int compareTo(DataWrap dw)  
    {  
        return this.data > dw.data ? 1   
            : (this.data == dw.data ? 0 : -1);  
    }  
}  

直接选择排序：

//选择排序
public class SelectSort  
{  
    public static void selectSort(DataWrap[] data)   
    {  
        System.out.println("开始排序");  
        int arrayLength = data.length;  
        //依次进行n－1趟比较, 第i趟比较将第i大的值选出放在i位置上。  
        for (int i = 0; i < arrayLength - 1 ; i++ )  
        {  
            //第i个数据只需和它后面的数据比较  
            for (int j = i + 1 ; j < arrayLength ; j++ )  
            {                 
                //如果第i位置的数据 > j位置的数据, 交换它们  
                if (data[i].compareTo(data[j]) > 0)  
                {  
                    DataWrap tmp = data[i];  
                    data[i] = data[j];  
                    data[j] = tmp;  
                }  
            }  
            System.out.println(java.util.Arrays.toString(data));  
        }  
    }  
    public static void main(String[] args)  
    {  
        DataWrap[] data = {  
            new DataWrap(21 , ""),  
            new DataWrap(30 , ""),  
            new DataWrap(49 , ""),  
            new DataWrap(30 , "*"),  
            new DataWrap(16 , ""),  
            new DataWrap(9 , "")  
        };  
        System.out.println("排序之前：\n"  
            + java.util.Arrays.toString(data));  
        selectSort(data);  
        System.out.println("排序之后：\n"   
            + java.util.Arrays.toString(data));  
    }  
}  

下面是排序过程：

排序之前：
[21, 30, 49, 30*, 16, 9]
开始排序
[9, 30, 49, 30*, 21, 16]
[9, 16, 49, 30*, 30, 21]
[9, 16, 21, 49, 30, 30*]
[9, 16, 21, 30, 49, 30*]
[9, 16, 21, 30, 30*, 49]
排序之后：
[9, 16, 21, 30, 30*, 49]

对上面的算法改进，每次找到最小的数据的索引，减少交换的次数，提高算法效率： 

public class SelectSort2  
{  
    public static void selectSort(DataWrap[] data)   
    {  
        System.out.println("开始排序");  
        int arrayLength = data.length;  
        //依次进行n－1趟比较, 第i趟比较将第i大的值选出放在i位置上。  
        for (int i = 0; i < arrayLength - 1 ; i++ )  
        {  
            //minIndex永远保留本趟比较中最小值的索引  
            int minIndex = i ;  
            //第i个数据只需和它后面的数据比较  
            for (int j = i + 1 ; j < arrayLength ; j++ )  
            {  
                //如果第minIndex位置的数据 > j位置的数据  
                if (data[minIndex].compareTo(data[j]) > 0)  
                {  
                    //将j的值赋给minIndex  
                    minIndex = j;  
                }  
            }  
            //每趟比较最多交换一次  
            if (minIndex != i)  
            {  
                DataWrap tmp = data[i];  
                data[i] = data[minIndex];  
                data[minIndex] = tmp;  
            }  
            System.out.println(java.util.Arrays.toString(data));  
        }  
    }  
    public static void main(String[] args)  
    {  
        DataWrap[] data = {  
            new DataWrap(21 , ""),  
            new DataWrap(30 , ""),  
            new DataWrap(49 , ""),  
            new DataWrap(30 , "*"),  
            new DataWrap(16 , ""),  
            new DataWrap(9 , "")  
        };  
        System.out.println("排序之前：\n"  
            + java.util.Arrays.toString(data));  
        selectSort(data);  
        System.out.println("排序之后：\n"   
            + java.util.Arrays.toString(data));  
    }  
}  

下面是排序过程：

排序之前：
[21, 30, 49, 30*, 16, 9]
开始排序
[9, 30, 49, 30*, 16, 21]
[9, 16, 49, 30*, 30, 21]
[9, 16, 21, 30*, 30, 49] 不交换
[9, 16, 21, 30*, 30, 49] 不交换
[9, 16, 21, 30*, 30, 49]
排序之后：
[9, 16, 21, 30*, 30, 49]

可以看出：直接选择排序的第n趟比较至多交换一次，永远总是拿n-1位的数据和中间某个数据(本趟比较中最小的数据)进行交换。如果本趟比较时第n-1位(本趟比较的第一位)数据已经是最小，则无需进行交换。

 C++代码实现：

#include<iostream>
using namespace std;

//直接选择排序
void select_sort(int a[],int len)
{

    int i,j,x,l;
    for(i=0;i<len;i++)
    {
    
        x = a[i];//每次遍历前对x和i的初值设定
        l = i;

        for(j=i;j<len;j++)//遍历从i位置向数组尾部进行
        {
        
            if(a[j] < x)
            {            

                x = a[j];//x保存每次遍历搜索到的最小数
                l = j;//l记录最小数的位置
            }
        }
        a[l] = a[i];//把最小数与a[i]交换
        a[i] = x;
    }
}

void main()
{

    int data[9] = {54,38,96,23,15,72,60,45,83};
    select_sort(data,9);
    for(int i=0;i<9;i++)
    {
    
        cout<<data[i]<<" ";
    }
}

二、堆排序

首先，关于堆的概念这里就不说了，详情请看《算法导论》

堆排序的关键在于建堆，下面简单介绍一下建堆的过程：

第1趟将索引0至n-1处的全部数据建大顶（或小顶）堆，就可以选出这组数据的最大值（或最小值）。将该堆的根节点与这组数据的最后一个节点交换，就使的这组数据中最大（最小）值排在了最后。

第2趟将索引0至n-2处的全部数据建大顶（或小顶）堆，就可以选出这组数据的最大值（或最小值）。将该堆的根节点与这组数据的倒数第二个节点交换，就使的这组数据中最大（最小）值排在了倒数第二位。

......

第k趟将索引0至n-k处的全部数据建大顶（或小顶）堆，就可以选出这组数据的最大值（或最小值）。将该堆的根节点与这组数据的倒数第k个节点交换，就使的这组数据中最大（最小）值排在了倒数第k位。

所以我们只是在重复做两件事：

1：建堆

2：拿堆的根节点和最后一个节点交换

下面通过一组数据说明：

9,79,46,30,58,49

1:先将其转换为完全二叉树，如图

2：完全二叉树的最后一个非叶子节点，也就是最后一个节点的父节点。最后一个节点的索引为数组长度len-1，那么最后一个非叶子节点的索引应该是为(len-1)/2.也就是从索引为2的节点开始，如果其子节点的值大于其本身的值。则把他和较大子节点进行交换，即将索引2处节点和索引5处元素交换。交换后的结果如图：

建堆从最后一个非叶子节点开始即可

3：向前处理前一个节点，也就是处理索引为1的节点，此时79>30,79>58,因此无需交换。

4：向前处理前一个节点，也就是处理索引为0的节点，此时9<79,9<49,因此无需交换。应该拿索引为0的节点与索引为1的节点交换，因为79>49.如图

5：如果某个节点和它的某个子节点交换后，该子节点又有子节点，系统还需要再次对该子节点进行判断。如上图因为1处，3处，4处中，1处的值大于3,4出的值，所以还要交换。

Java代码实现：

//堆排序
public class HeapSort  
{  
    public static void heapSort(DataWrap[] data)   
    {  
        System.out.println("开始排序");  
        int arrayLength = data.length;  
        //循环建堆  
        for (int i = 0; i < arrayLength - 1 ; i++ )  
        {  
            //建堆  
            builMaxdHeap(data , arrayLength - 1 - i);  
            //交换堆顶和最后一个元素  
            swap(data , 0 , arrayLength - 1 - i);  
            System.out.println(java.util.Arrays.toString(data));  
        }  
    }  
    //对data数组从0到lastIndex建大顶堆  
    private static void builMaxdHeap(DataWrap[] data , int lastIndex)  
    {  
        //从lastIndex处节点（最后一个节点）的父节点开始  
        for (int i = (lastIndex - 1) / 2 ; i >= 0  ; i--)  
        {  
            //k保存当前正在判断的节点  
            int k = i;  
            //如果当前k节点的子节点存在  
            while (k * 2 + 1 <= lastIndex)  
            {  
                //k节点的左子节点的索引  
                int biggerIndex = 2 * k  + 1;   
                //如果biggerIndex小于lastIndex，即biggerIndex + 1  
                //代表的k节点的右子节点存在  
                if (biggerIndex < lastIndex)  
                {  
                     //如果右子节点的值较大  
                    if(data[biggerIndex].compareTo(data[biggerIndex + 1]) < 0)  
                    {  
                        //biggerIndex总是记录较大子节点的索引  
                        biggerIndex++;   
                    }  
                }  
                //如果k节点的值小于其较大子节点的值  
                if(data[k].compareTo(data[biggerIndex]) < 0)  
                {  
                    //交换它们  
                    swap(data , k , biggerIndex);  
                    //将biggerIndex赋给k，开始while循环的下一次循环，  
                    //重新保证k节点的值大于其左、右子节点的值。  
                    k = biggerIndex;  
                }  
                else  
                {  
                    break;  
                }  
            }  
        }  
    }  
    //交换data数组中i、j两个索引处的元素  
    private static void swap(DataWrap[] data , int i , int j)  
    {  
        DataWrap tmp = data[i];  
        data[i] = data[j];  
        data[j] = tmp;  
    }  
    public static void main(String[] args)  
    {  
        DataWrap[] data = {  
            new DataWrap(21 , ""),  
            new DataWrap(30 , ""),  
            new DataWrap(49 , ""),  
            new DataWrap(30 , "*"),  
            new DataWrap(21 , "*"),  
            new DataWrap(16 , ""),  
            new DataWrap(9 , "")  
        };  
        System.out.println("排序之前：\n"  
            + java.util.Arrays.toString(data));  
        heapSort(data);  
        System.out.println("排序之后：\n"   
            + java.util.Arrays.toString(data));  
    }  
}  

实现过程：

排序之前：
[21, 30, 49, 30*, 21*, 16, 9]
开始排序
[9, 30, 21, 30*, 21*, 16, 49]
[16, 30*, 21, 9, 21*, 30, 49]
[16, 21*, 21, 9, 30*, 30, 49]
[9, 16, 21, 21*, 30*, 30, 49]
[9, 16, 21, 21*, 30*, 30, 49]
[9, 16, 21, 21*, 30*, 30, 49]
排序之后：
[9, 16, 21, 21*, 30*, 30, 49]

C++实现：

#include<iostream>
using namespace std;

int heapSize = 0;

void swap(int array[] , int i , int j)
{
    int temp;
    temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}
//array[index]与其左右子树进行递归对比，用最大值替换array[index],index表示堆顶索引
void MaxHeapify(int array[] , int index )
{
    int left = 2*index;//左子节点索引
    int right = 2*index+1;//右子节点索引
    int largest;//最大数
    //用largest存储堆顶与其左子节点的较大者
    if(left<=heapSize && array[left]>array[index])
        largest = left;
    else
        largest = index;
    //用largest存储堆顶与其右子节点的较大者
    if(right<=heapSize && array[right]>array[largest])
        largest = right;
    //此时largest为堆顶，左子节点，右子节点最大者
    if(largest != index)
    {
        //如果堆顶不是最大者，则交换，并递归调整堆
        swap(array , index , largest);
        MaxHeapify(array , largest);
    }
}
 
//初始化堆，将数组中的每一个元素放到合适的位置。此时堆顶的元素为数组的最大值
void BuildMaxHeap(int array[],int length )
{
    heapSize = length;
    for(int i=length-1 ; i>=0 ; i--)
    {
        MaxHeapify(array , i );
    }
}
 
//排序
void HeapSort(int array[] , int length)
{
    //初始化堆
    BuildMaxHeap(array,length);
    for(int i=length ; i>=1 ; i--)
    {
        swap(array , 0 , i);
        //堆顶元素array[0](即数组的最大值)被置换到数组的尾部array[i]
        heapSize--;//从堆中移除该元素
        MaxHeapify(array , 0);//重建堆
    }
}
int main()
{
    int a[8] = {68,20,39,88,97,46,59,11};
    int i;
    HeapSort(a,8);
    for(i=0 ; i<8 ; i++)
    {
        cout << a[i] << " ";
    }
    cout <<endl;
    return 0;
}

这是经过改正的，终于解决了.....