import java.io.IOException;
import Input.InputString;
/**
* 堆排序
* @author xiaomi
* 2012.4.1
*/
public class HeapSort {
private static int[] heap;
public static void main(String[] args) throws IOException{
String s = InputString.getString();
String[] str = s.split(" ");
heap = new int[str.length+1];//从下标1开始算起
for(int i = 0;i < str.length;i++){
heap[i+1] = Integer.parseInt(str[i]);
}
heapSort();
for(int i = 1;i < heap.length;i++){
System.out.print(heap[i]+" ");
}
}
public static void heapSort(){
createHeap();
for(int i = 1;i < heap.length;i++){
ajustHeap(i);
}
}
//每加入一个节点就要向上筛选一次
public static void createHeap(){
for(int i = 2; i < heap.length;i++){
for(int j = i; j/2>=1;j/=2){
if(heap[j]>heap[j/2]){
int temp = heap[j];
heap[j] = heap[j/2];
heap[j/2] = temp;
}
}
}
}
//每移走一个节点就要向下调整一次
public static void ajustHeap(int k){
int temp = heap[1];
heap[1] = heap[heap.length-k];
heap[heap.length-k] = temp;
int i = 1;
while((2*i) < heap.length-k){
if((2*i+1) < heap.length-k){
if(heap[i] > heap[2*i] && heap[i] > heap[2*i+1]){
break;
}
else{//与较大的一个子节点交换
if(heap[2*i] < heap[2*i+1]){
int a = heap[i];
heap[i] = heap[2*i+1];
heap[2*i+1] = a;
i = 2*i+1;
}else{
int a = heap[i];
heap[i] = heap[2*i];
heap[2*i] = a;
i = 2*i;
}
}
}else{//不存在右节点的时候
if(heap[i] > heap[2*i]){
break;
}
else{
int a = heap[i];
heap[i] = heap[2*i];
heap[2*i] = a;
i = 2*i;
}
}
}
}
}
package Sort;
import java.io.IOException;
import Input.InputString;
public class HeapSort {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
String str = InputString.getString();
String[] s = str.split(" ");
int[] a = new int[s.length+1];
for(int i = 1; i<=s.length;i++){
a[i] = Integer.parseInt(s[i-1]);
}
heapSort(a);
for(int i = 1; i<a.length;i++){
System.out.print(a[i]+" ");
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void heapAdjust(int[] a, int begin,int end){
int temp = a[begin];
for(int i = 2*begin; i <= end; i = 2*i){
if(i < end && a[i] < a[i+1]){
i++;
}
if(temp >= a[i]){
break;
}
a[begin] = a[i];
begin = i;
}
a[begin] = temp;
}
public static void heapSort(int[] a){
for(int i = a.length/2; i > 0; i--){
heapAdjust(a, i, a.length-1);
}
for(int i = a.length-1; i > 1; i--){
int temp = a[1];
a[1] = a[i];
a[i] = temp;
heapAdjust(a, 1, i-1);
}
}
}
七大基本排序算法之冒泡排序
七大基本排序算法之选择排序
七大基本排序算法之插入排序
七大基本排序算法之希尔排序
七大基本排序算法之堆排序
七大基本排序算法之快速排序
七大基本排序算法之归并排序
分享到:
相关推荐
在第一版的基础上新加了对冒泡排序,直接插入排序,直接选择排序,希尔排序,归并排序,快速排序和堆排序这七种常用的排序方法的总结篇,方便大家复习,合适作为笔试面试前的复习资料。
七大排序算法如下: 交换排序:快速排序quicksort,冒泡排序bubblesort 选择排序:直接选择排序selectionsort,堆排序maxheapsort 插入排序:直接插入排序insertsort,希尔排序shellsort 合并排序:归并排序...
包括冒泡排序,直接 插入排序,直接选择排序,希尔排序,归并排序,快速排序和堆 排序这七种常用的排序方法,
七大排序算法C++实现,包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序。代码随机生成数组来排序,MAX1定义了数组个数,用QueryPerformanceCounterday打印除了各算法用时。
包含(归并排序、堆排序、希尔排序、快速排序、冒泡排序、直接插入/选择排序)七种排序算法的C++代码实现
包括冒泡排序,直接插入排序,直接选择排序,希尔排序,归并排序,快速排序和堆排序这七种常用的排序方法和实现代码,并有配图的解释,直接明了,容易理解!
对冒泡排序,直接插入排序,直接选择排序,希尔排序,归并排序,快速排序和堆排序这七种常用的排序方法进行了详细的讲解
堆排序的基本思路: a.将无需序列构建成一个堆,根据升序降序需求选择大顶堆或小顶堆; b.将堆顶元素与末尾元素交换,将最大元素”沉”到数组末端; c.重新调整结构,使其满足堆定义,然后继续交换堆顶元素与当前末尾...
在第一版的基础上新加了对冒泡排序,直接插入排序,直接选择排序,希尔排序,归并排序,快速排序和堆排序这七种常用的排序方法的总结篇,方便大家复习,合适作为笔试面试前的复习资料。
插入排序,选择排序,冒泡排序,归并排序,快速排序,堆排序,希尔排序的java实现
这是本人在研一上课时所整理的文档,包括冒泡排序,直接插入排序,直接选择排序,希尔排序,归并排序,快速排序和堆排序这七种常用的排序方法,这些文章不仅使我在考试中取了不错的成绩,也为后来顺利面过迅雷,腾讯...
直接选择排序 希尔排序 归并排序 快速排序 堆排序等经典算法之七大排序白话讲解第二版
1. 熟练运用冒泡排序、选择排序、插入排序、希尔排序、快速排序、合并排序、堆排序等七种常见的内排序算法 2. 使用不同的数据结合计算各种算法的运行时间,验证算法的时间复杂性 3. 能够运用二路归并算法进行外排序 ...
包括冒泡排序,直接插入排序,直接选择排序,希尔排序,归并排序,快速排序和堆排序
目录插入排序直接插入排序基本原理代码实现性能分析折半插入排序代码实现希尔排序基本原理代码实现性能分析选择排序单向选择排序基本原理代码实现性能分析双向选择排序代码实现堆排序基本原理代码实现性能分析冒泡...
MoreWindows白话经典算法之七大排序 这是本人在研一上课时所整理的文档,包括冒泡排序,直接插入排序,直接选择排序,希尔排序,归并排序,快速排序和堆排序
冒泡,归并,快速,插入,基数,希尔,堆排序等排序算法使用java实现