在java中使用heapsort进行排序 导入java.util.array； 公开课考试{ //主要方法 公共静态void main（字符串…参数）{ int[]a=新的int[]{16,14,10,8,7,9,3,2,4,1}； System.out.println（“未排序数组”+Arrays.toString（a））； 堆排序（a）； System.out.println（“排序数组”+Arrays.toString（a））； } //返回给定索引的左子索引 私有静态int左_子级（int i）{ 返回（i*2+1）； } //返回给定索引的右子索引 私有静态整数右\子项（整数i）{ 返回（i*2+2）； } 公共静态void max_heapify（int[]数组、int索引、int堆大小）{ int=指数； int left=left_子项（索引）； int right=右侧子对象（索引）； if（左array[index]）{ 最大=左； } 否则最大=指数； if（右数组[最大]）{ 最大=右； } 如果（最大！=索引）{ //交换数组[索引]与数组[最大] int a=数组[索引]； 数组[索引]=数组[最大]； 数组[最大]=a； 最大堆大小（数组、最大值、堆大小）； } } 公共静态无效生成\u最大\u堆（int[]数组）{ int heap_size=array.length-1； 对于（int i=（（array.length-1）/2）；i>=0；i--）{ 最大堆大小（数组、i、堆大小）； } } //主堆排序函数 公共静态无效堆_排序（int[]数组）{ int heap_size=array.length-1； 构建最大堆（数组）； 对于（inti=（array.length-1）；i>0；i--）{ //将数组[0]与数组[i]交换 int a=数组[0]； 数组[0]=数组[i]； 数组[i]=a； 堆大小=堆大小-1； 最大堆大小（数组，1，堆大小）； } } }

我已经尝试了几乎所有的可能性，但效果并不好。你能找出我错在哪里吗。 我的代码的输出是： 未排序数组[16,14,10,8,7,9,3,2,4,1]

---

排序数组[14、10、8、7、9、3、2、4、1、16]

问题是您将项目松散，因为左右子项必须：

import java.util.Arrays;

public class Test{

//main method
public static void main(String... args){
    int[] a = new int[]{16,14,10,8,7,9,3,2,4,1};

    System.out.println("unsorted array " + Arrays.toString(a));

    heap_sort(a);

    System.out.println("Sorted array " + Arrays.toString(a));
}

//returns left child index of given index
private static int left_child(int i){
return (i * 2 + 1);
}

//returns right child index of the given index
private static int right_child(int i){
    return (i * 2 + 2);
}


public static void max_heapify(int[] array , int index , int heap_size){
    int largest = index;
    int left = left_child(index);
    int right = right_child(index);

    if(left < heap_size && array[left] > array[index]){
        largest = left;
    }
    else largest = index;

    if (right < heap_size && array[right] > array[largest]){
        largest = right;
    }

    if(largest != index){
        //exchange array[index] with array[largest]
        int a = array[index];
        array[index] = array[largest];
        array[largest] = a;

        max_heapify(array,largest,heap_size);
    }
}

public static void build_max_heap(int[] array){
    int heap_size = array.length - 1;


    for (int i = ((array.length - 1) / 2) ; i >= 0 ; i--){
        max_heapify(array, i, heap_size);
    }
}

//main heap sort function 
public static void heap_sort(int[] array){

    int heap_size = array.length - 1;


    build_max_heap(array);

    for(int i = (array.length - 1) ; i > 0 ; i--){
        //exchange array[0] with array[i]
        int a = array[0];
        array[0] = array[i];
        array[i] = a;

        heap_size = heap_size - 1;
        max_heapify(array , 1 , heap_size);
    }
}


}

存在一些问题： -“左”和“右”子元素被修改，因为您松开了数组中的第一个元素。 -在max_heapify函数中，循环为=0；我——） { 最大堆大小（数组、i、堆大小）； } } //主堆排序函数 公共静态无效堆_排序（int[]数组） { int heap_size=array.Length-1； 构建最大堆（数组）； 对于（inti=（array.Length-1）；i>0；i--） { //将数组[0]与数组[i]交换 int a=数组[0]； 数组[0]=数组[i]； 数组[i]=a； 堆大小=堆大小-1； 最大堆大小（数组，0，堆大小）； } }

---

结果是一样的吗？是的！结果是一样的。另一点：if（left array[index]）{max=left；}else-max=index；if（右数组[maximum]）{maximum=right；}。您永远不会到达第一个和最后一个元素。当使用基于0的数组（如Java、C和许多其他语言）作为堆时，您可以看到未排序的数组[16、14、10、8、7、9、3、2、4、1]排序的数组[14、10、8、7、9、3、3、2、4、1、16]，对于左边的孩子使用索引

i*2+1

，对于右边的孩子使用索引

i*2+2

，这是标准的。

//returns left child index of given index
private static int left_child(int i){
return (i * 2);
}

//returns right child index of the given index
private static int right_child(int i){
    return (i * 2 + 1);
}

  //returns left child index of given index
    private static int left_child(int i)
    {
        return (i * 2);
    }

    //returns right child index of the given index
    private static int right_child(int i)
    {
        return (i * 2 + 1);
    }

    public static void max_heapify(int[] array, int index, int heap_size)
    {
        int largest = index;
        int left = left_child(index);
        int right = right_child(index);

        if (left <= heap_size && array[left] > array[index])
        {
            largest = left;
        }

        if (right <= heap_size && array[right] > array[largest])
        {
            largest = right;
        }

        if (largest != index)
        {
            //exchange array[index] with array[largest]
            int a = array[index];
            array[index] = array[largest];
            array[largest] = a;

            max_heapify(array, largest, heap_size);
        }
    }

    public static void build_max_heap(int[] array)
    {
        int heap_size = array.length - 1;


        for (int i = ((array.length - 1) / 2); i >= 0; i--)
        {
            max_heapify(array, i, heap_size);
        }
    }

    //main heap sort function 
    public static void heap_sort(int[] array)
    {

        int heap_size = array.Length - 1;


        build_max_heap(array);

        for (int i = (array.Length - 1); i > 0; i--)
        {
            //exchange array[0] with array[i]
            int a = array[0];
            array[0] = array[i];
            array[i] = a;

            heap_size = heap_size - 1;
            max_heapify(array, 0, heap_size);
        }
    }