选择类排序--简单选择、堆排序

一、简单选择排序

1. 执行过程：

原始序列：49，38，65，97，76，13，27，49

无序

49	38	65	97	76	13	27	49

从无序序列中选取一个最小的关键字13，使其与无序序列中的第一个关键字交换，则此时产生了仅含有一个关键字的有序序列，而无序序列中的关键字减少1个，如下：

 

13	38	65	97	76	49	27	49

重复上述步骤，直到无序序列中的关键字变为0个为止。

2. 算法思想：

代码：

void selectSort(int R[], int n)
{
    int i,j,k;
    int temp;
    for(i = 0; i < n; ++i)
    {
        k = i;
	for(j = i + 1; j < n; ++j)
	{
	    if(R[k] > R[j])
		k = j;
	}
	temp = R[i];
	R[i] = R[k];
	R[k] = temp;    
    }
}

3. 复杂度分析：

（1）时间复杂度分析
        外层循环执行n次，内层循环执行n-1次，将最内层循环中的比较操作视为关键操作，其执行次数为(n-1+1)(n-1)/2=n(n-1)/2，即本算法的复杂度为O(n²)。

（2）空间复杂度为O(1)

二、堆排序

1. 概念

    堆是一棵顺序存储的完全二叉树。完全二叉树中所有非终端节点的值均不大于（或不小于）其左、右孩子节点的值。

• 其中每个节点的值小于等于其左、右孩子的值，这样的堆称为小根堆；
• 其中每个节点的值大于等于其左、右孩子的值，这样的堆称为大根堆；

2. 基本思想

        将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的 n-1 个序列重新构造成一个堆，这样就会得到 n 个元素中次大的值。如此反复执行，便能得到一个有序序列了。 
堆排序的实现需要解决的两个关键问题： 

• 将一个无序序列构成一个堆。 
• 输出堆顶元素后，调整剩余元素成为一个新堆。

    (1)  插入结点

需要在插入结点后保持堆的性质，即完全二叉树形态与父大子小性质，因此需要先将要插入的结点x放在最底层的最右边，插入后满足完全二叉树的特点；然后把x依次向上调整到合适位置以满足父大子小的性质。

    (2)  删除结点

 

当删除堆中的一个结点时，原来的位置就会出现一个孔，填充孔的方法是，把最底层最右边的叶子的值赋给该孔并下调到合适的位置，最后把该叶子删除。

3. 代码

public class heapSort
{
    /**
     * 构建大顶堆
     */
    public static void main(String[] args)
    {
        int a[] = {49, 38, 65, 97, 76, 13, 27, 49};
		System.out.println("排序前：" + Arrays.toString(a));
		heapSort(a);
		System.out.println("排序后：" + Arrays.toString(a));
    }
    public static void heapSort(int[] a)
    {	
        for(int i = a.length / 2 - 1; i >= 0; i--)
		{
			adjustHeap(a, i, a.length - 1);
		}
		// 将堆顶记录和当前未经排序子序列的最后一个记录交换
		for(int i = a.length - 1; i >= 0; i--)
		{
			int temp = a[0];
			a[0] = a[i];
			a[i] = temp;
			// 将a中前i-1个记录重新调整为大顶堆
			adjustHeap(a, 0, i - 1);
		}
    }
    public static void adjustHeap(int[] a, int i, int len)
    {
        int temp = a[i];
		for(int j = 2 * i; j < len; j *= 2)// 沿关键字较大的孩子结点向下筛选
		{
			if(j < len && a[j] < a[j+1])
				++j;
			if(temp >= a[j])
				break;
			a[i] = a[j];
			i = j;			
		}
		a[i] = temp;
    }
}

4. 复杂度分析：

    （1）时间复杂度：O(nlog₂n)

      (2) 空间复杂度：O(1)