2 堆排序

第4趟
第5趟
25*，49
移动，稳定的
堆排序
可将堆序列看成完全二叉树，则堆顶元素（完全二 叉树的根）必为序列中n个元素的最小值或最大值
堆排序过程—以大顶堆为例
buildHeap 1）将无序序列建成一个堆，得到关键字最大的记录； 2）输出堆顶的最大值后，使剩余的n-1个元素重又建 成一个堆，则可得到n个元素的次最大值。 下虑/上虑 3）重复执行，得到一个有序序列，这个过程叫堆排 序
堆排序—堆排序算法
public static <AnyType extends Comparable<? super AnyType>> void percDown(AnyType [ ] a,int i,int n){ /* 已知 a[i..n]中记录的关键字除 a[i] 之外均满足堆的特征，本方法自上而下 调整 a[i] 的，使 a[i..n] 也成为一个大顶堆*/ int child; AnyType tmp; //利用tmp暂存a[i]
27 13 50 76 65
38 13 百度文库6
49 13 97
堆排序—举例
13
27 13
38 13 50 76 65
76
49 13 97
堆排序-课堂练习
1、判断下列序列是否是堆，如果不是，请调整为堆 a.100，85，98，77，80，60，82，40，20，10，66 b.100，98，85，82，80，77，66，60，40，20，10 c.100，85，40，77，80，60，66，98，82，10，20 d.10，20，40，60，66，77，80，82，85，98，100
简单选择排序-例子
k
1
k
2 3 4 5
k
6 7
第一趟 i=1
13 49
i
38 65
j j
97 76
j j
49 13
j
27
j
简单选择排序-例子
k
1 2 3 4 5 6
k
7
第二趟：
38 65 13 27
i j
97 76
j j
49 38 27
j j
i=2
简单选择排序-例子
k
1 2 3 4 5
k
6
k
7
第5趟
08，16, 21，25*，25，49
交换，不稳定的
简单选择排序-讨论
例：关键字序列T= （21，25，49，25*，16，08），请 给出简单选择排序的具体实现过程。 原始序列： 21，25，49，25*，16，08 第1趟 第2趟 第3趟 08，21，25，49，25*，16 08，16, 21，25，49， 25* 08，16, 21，25, 49, 08，16, 21，25， 49, 08，16, 21，25, 25* 25*
小结和作业
简单选择 排序 选择排序 堆排序
1．基本思想 2．实例模拟 3．算法
4．时间复杂度 1．基本思想 2．实例模拟 3．算法
4．时间复杂度
小结和作业
重点：
1）算法的设计思想；
2）手工排序方法； 3）算法的时间复杂度和空间复杂度。 作业：P213,7.11
简单选择排序-性能分析
1.对n个记录进行简单选择排序，所需进行的
关键字间的比较次数总计为：
n(n 1) (n i ) 2 i 1
n 1
2.移动记录的次数，当待排序列为正序数为最小，
最小值为 0。
待排序列为逆序数为最大，最大值为3(n-1) 。
3.简单选择排序是一种不稳定的排序方法 ???
}
break;
堆排序—堆排序算法
private static int leftChild(int i){ return 2*i+1; }
堆排序-性能分析
1. 对深度为 k 的堆，“筛选”所需进行的关键字 比较的次数至多为2(k-1)； 2. 对 n 个关键字，建成深度为h(=log2n+1)的堆， 所需进行的关键字比较的次数至多 4n；
选择排序
选择排序的基本思想
简单选择排序 堆排序7.5 小结和作业
简单选择排序-基本思想
假设排序过程中，待排记录序列的状态为：
有序序列R[1..i-1]
第 i 趟 简单选择排序
无序序列 R[i..n]
从中选出 关键字最小的记录
有序序列R[1..i]
无序序列 R[i+1..n]
选择排序的基本思想
选择排序的基本思想： 每一趟从待排序的n-i+1（i=1,2,3,…,n-1）个记 录中选出关键字最小的记录，作为有序序列中 第i个记录，直到全部记录排序完毕。 1. 直接选择排序 2. 堆选择排序
//下虑算法
for(tmp=a[i]; leftChild(i)<n;i=child){ child=leftChild(i); // 左/右“子树根”之间先进行相互比较,令 child 指示关键字较大记录的位置 /*再作“根”和“子树根”之间的比较，若“>=”成立，则说明已 找到 tmp 的插入位置 ，不需要继续往下调整*/ // 否则记录上移，尚需继续往下调整 } a[i]=tmp;
堆排序-性能分析
3. 调整“堆顶” n-1 次，总共进行的关键字比较的
次数不超过 2 (log2(n-1)+ log2(n-2)+ …+log22) < 2n(log2n) 因此，堆排序的时间复杂度为O(nlogn)。 堆排序的平均性能较接近于最坏性能。 辅助空间为O(1) 4.堆排序是一个不稳定的排序方法。
第三趟： i=3
65 13 27 38
1 2 3i
97 76
j
4
49
j
6
65 38
j
7
j
5
第四趟：
i=4
13 27 38 65 49 97 76
i
49 97
65
简单选择排序-例子
1 2 3 4 5 6 7
第五趟： i=5
65 49 97 76 65 13 27 38
i
97 76 65
1
2
3
4
5
6
7
堆排序—堆排序算法
public static <AnyType extends Comparable<? super AnyType>> void HeapSort(AnyType [ ] a){ // 对顺序表 H 进行堆排序 for(int i=a.length/2;i>=0;i--) percDown(a,i,a.length); //建堆 for(int i=a.length-1;i>0;i--){ SwapReferences(a,0,i); //删除最大元 percDown(a,0,i); } }
38
76 97
堆排序—举例
50 49 13 49 27 13 38 50 13 65 27 76 97 97 49 13 27 50 76 65 49 13 38 13 38 76
27 13
97
堆排序—举例
38 13 27 27 13 27 13
38 13 50 76 65
76 97 49 13
堆排序—举例
（97，76，65，49，50，27，38，13）
97 76 49 13 50 65 50 76 13 38 13 49 13 50 27 97 76 13 65 38
27
97
堆排序—举例
76 38 65 50 49 97 13 13 27 38 65 76 38 97 27 49 50 27 49 13 65 27 65 50 27
第六趟：
i=6
65 49 97 76 65 13 27 38
1 2 3 4 5
97 97 76 76
6
i
7
排序结果：
65 49 97 76 65 13 27 38
97 76
97
简单选择排序-算法
private static <AnyType extends Comparable<? super AnyType>> void SelectSort(AnyType [ ] a){ //对记录序列a[ ]进行简单选择排序 for(int i=0;i<a.length-1;i++){ //排序趟数 int k=i; for(int j=k+1;j<a.length;j++) // 在 a[ ] 中选择关键字最小的记录，并用k来存放 if(a[j].compareTo(a[k])<0) k=j; if(i!=k) SwapReferences(a,i,k); } }
}
堆排序—堆排序算法
//下虑算法
for(tmp=a[i]; leftChild(i)<n;i=child){ child=leftChild(i); if(child!=n-1 && a[child].compareTo(a[child+1])<0) child++; if(tmp.compareTo(a[child])<0) a[i]=a[child]; else
简单选择排序-讨论
例：关键字序列T= （21，25，49，25*，16，08），请 给出简单选择排序的具体实现过程。 原始序列： 21，25，49，25*，16，08 第1趟 第2趟 第3趟 第4趟 08，25，49，25*，16，21 08，16, 49，25*，25，21 08，16, 21，25*，25，49 08，16, 21，25*，25，49