堆排序(不理解)

package sort;

import java.util.Scanner;

public class HeapSort {
    public static int arr[];
    static{
        System.out.println("Please enter the array to sort, and use ‘,‘ as a separator:");
        Scanner sc=new Scanner(System.in);
        String s=sc.nextLine();
        String n[]=s.split(",");
        arr=new int[n.length];
        System.out.println("Before sort:");
        for(int i=0;i<arr.length;i++){
            arr[i]=Integer.parseInt(n[i]);
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
    public static void main(String args[]){
        int m=arr.length-1;
        heapSort(m);
        System.out.println("After sort:");
        for(int i=0;i<=m;i++)
            System.out.print(arr[i]+" ");
        System.out.println();
    }
    public static void heapSort(int m){
        int temp=0;
        for(int i=(m+1)/2;i>=1;i--)
            createHeap(m+1,i);  //创建整个初始大根堆
        for(int i=m;i>=1;i--){  //控制范围,逐渐缩小
            createHeap(i+1,1);  //创建根堆
            temp=arr[0];
            arr[0]=arr[i];
            arr[i]=temp;
            System.out.print("Current sorting:");
            for(int k=0;k<=m;k++)
                System.out.print(arr[k]+" ");
            System.out.println();
        }
    }
    //下面的方法是创建大根堆,每运行一次,都能找到堆的根部的数据
    public static void createHeap(int m,int i){  //创建根堆
        int j=2*i;
        int temp=arr[i-1];
        while(j<=m){
            if(j<m && arr[j-1]<arr[j])  //找一个最大的数
                j++;
            if(temp<=arr[j-1]){  //判断第一个数是否比最大的数小
                arr[i-1]=arr[j-1];
                i=j;
                j=2*i;
            }
            else break;
        }
        arr[i-1]=temp;
    }

}
时间: 2024-11-03 21:39:04

堆排序(不理解)的相关文章

让算法会说话之堆排序

转载请注明出处:http://blog.csdn.net/ruoyunliufeng/article/details/26364047        堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法.堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点. 一.堆的删除 虽然在这里我默认读者对"堆"是有所了解的,但是这里我仍然要讲一下堆的删除,因为这直接影响你对下面堆排序的理解. 这里以删除最小元为例讲解,当然下面的

8大排序算法---我熟知3(归并排序/快速排序/堆排序)

排序算法: 快排: o(nlogn) o(1)不稳定 归并:o(nlogn) o(n) 稳定 基数: 冒泡 睡眠 面条 烙饼 1.quicksort: 返回条件:start >=end private = a[start]+a[end]/2 while(left <= right) while(left <= right && a[left] < privot) while(left <= right && a[right] > priv

堆排序讲解(代码简洁)

//本文适用于对堆排序部分理解的同学,主要体现的是代码的简洁. /*算法思想(以大顶堆为例):      1.将长度为n的待排序的数组进行堆有序化构造成一个大顶堆      2.将根节点与尾节点交换并输出此时的尾节点      3.将剩余的n -1个节点重新进行堆有序化      4.重复步骤2,步骤3直至构造成一个有序序列*/ //堆排序public class HeapSort {    public static void heapSort(int arr[]){        int s

数据结构与算法之美-堆和堆排序

堆和堆排序 如何理解堆 堆是一种特殊的树,只要满足以下两点,这个树就是一个堆. ①完全二叉树,完全二叉树要求除了最后一层,其他层的节点个数都是满的,最后一层的节点都靠左排列. ②树中每一个结点的值都必须大于等于(或小于等于)其子树中每个节点的值.大于等于的情况称为大顶堆,小于等于的情况称为小顶堆. 如何实现堆 如何存储一个堆 完全二叉树适合用数组来存储,因为数组中对于下标从1开始的情况,下标为i的节点的左子节点就是下标为i*2的节点,右子节点就是i下标为i*2+1的节点,其父节点时下标为i/2的

算法系列笔记1(排序)

本次主要记录一些经典的排序算法,其中包括冒泡排序.直接选择排序.插入排序.归并排序.快速排序.堆排序.希尔排序.桶排序以及计数排序和基数排序.首先会给出这些排序算法的基本思想,然后给出实现的代码,最后会给出其时间复杂度. 1:冒泡排序 思想: (1):比较相邻的前后两个元素,如果后面的数据小于前面的数据,则交换这两个数据的位置.这样经过一次遍历,最小的元素将在第0个位置,属于"冒泡". (2):重复第一步,依次将第二小-的元素排列到数组的顶端. // 交换数据的三种方法 void sw

堆排序的进一步理解

堆-顾名思义,上面小,下面大,或者上面大,下面小. 在堆排序过程中,首先应该建堆.如何将数组中的元素建立成一个规范的堆行结构. 二叉堆是完全二叉树或者是近似完全二叉树.二叉堆满足二个特性: 1.父结点的键值总是大于或等于(小于或等于)任何一个子节点的键值. 2.每个结点的左子树和右子树都是一个二叉堆(都是最大堆或最小堆). 当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆.当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆. 假设根结点的下标为1,则第 i 个结点的父结点下标为

堆排序理解 完整代码

/* <转自 http://www.wutianqi.com/?p=1820 > 自我修改 * Note: 堆排序(Heap Sort) */ #include <iostream> using namespace std; // 输出当前堆的排序状况 void PrintArray(int data[], int size) { for (int i=1; i<=size; ++i) cout <<data[i]<<" "; co

【实习记】2014-08-27堆排序理解总结+使用typedef指代函数指针

过程记录 4个月前C语言版的七大排序算法实践让我在写C++版时轻车熟路.特别是冒泡,插入,希尔,选择这四种排序不用调试即运行成功.输出的效果与C语言做的版本完全一样,其中令我印象深刻的是,cout对浮点的处理远不如printf简单明了.非常让开发者难受. 写C++版时有所改进. #define sortfunc _selsort 可以用 typedef void (*sort_t)(vector<int>& arr); sort_t sortfunc = _selsort; 两句代替.

深入浅出理解排序算法之-堆排序

#include <iostream> void Swap(int &a,int &b){ int temp; temp = a; a = b; b = temp; } // 维护最小堆 void AdjustMinHeap(int *a,int pos,int len){ int temp,child; for (temp = a[pos];2*pos +1 <= len; pos = child) {       //不断下移父结点,直到结束 // 左孩子(由于第一个