Java 二进制堆的代码

我正在练习用伪代码编写代码。我在阅读我的算法介绍文本时发现了这一点。但是，我确信我的代码是精确到伪代码的；它没有输出我想要的东西。代码是一个

二进制堆。代码不会对我的
输入进行排序
，而是返回我的
输入
，作为
输出
。我对这个问题的想法存在于
build
方法中，我将
Math.floor（）
转换为
int
。这是我第一次使用
floor（）
，所以我认为我的理解力不足是问题所在。我相信我返回的是
heapsize/2
的最低近似值，因此我可以分支
二进制堆
。但在我的编码中是这样吗

public class tester
{
public static void heapsort(int[] a)
{

    build(a);

    for (int i = a.length - 1; i >= 1; i--)
    {
        swap(a, 0, i);
        int heapsize = a.length - 1;
        heapify(a,0);
    }
}

public static void build(int[] a)
{
    int heapsize = a.length;
    int fl = (int) Math.floor((heapsize)/2);
    for (int i = fl; i >= 0; i--)
    {
        heapify(a, i);
    }
}

public static void heapify(int[] a, int root)
{
    int left = 2 * root + 1;
    int right = 2 * root + 2;
    int heapsize = a.length;
    int largest;

    if ( (left < heapsize) && (a[left] > a[root]))
    {
        largest = left;
    }
    else
    {
        largest = root;
    }
    if ( (right < heapsize) && (a[right] > a[largest]))
    {
        largest = right;
    }
    if (largest != root)
    {
        swap(a, a[root], a[largest]);
        heapify(a, largest);
    }

}

public static void swap(int[] a, int x, int y)
{
    int tmp;
    tmp = a[x];
    a[x] = a[y];
    a[y] = tmp;
}

public static void main(String[] args)
{
    int[] a = new int[args.length];
    for (int i = 0; i < args.length; i++)
    {
        a[i] = Integer.parseInt(args[i]);
    }
    heapsort(a);
    for (int i : a)
    {
            System.out.println(i);
        }
    }
}    

公共类测试器
{
公共静态无效堆端口（int[]a）
{
建造（a）；
对于（int i=a.length-1；i>=1；i--）
{
互换（a，0，i）；
int heapsize=a.length-1；
heapify（a，0）；
}
}
公共静态无效生成（int[]a）
{
int heapsize=a.length；
int fl=（int）数学地板（（heapsize）/2）；
对于（int i=fl；i>=0；i--）
{
希皮菲（a，i）；
}
}
公共静态void heapify（int[]a，int root）
{
int left=2*root+1；
int right=2*root+2；
int heapsize=a.length；
int最大；
if（（左a[根]）
{
最大=左；
}
其他的
{
最大=根；
}
如果（（右a[最大]）
{
最大=右；
}
如果（最大！=根）
{
掉期（a，a[根]，a[最大]）；
希皮菲（a，最大）；
}
}
公共静态无效交换（int[]a，int x，int y）
{
int tmp；
tmp=a[x]；
a[x]=a[y]；
a[y]=tmp；
}
公共静态void main（字符串[]args）
{
int[]a=新的int[args.length]；
对于（int i=0；i
您的swap方法在Java中不起作用，因为您只能按值传递原语，而不能按引用传递。您可以按如下方式修改该方法：

public static void swap(int[] a, int i, int j)
{
    int tmp;
    tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}

这将被称为

    swap(a, 0, i);

而不是

    swap(a[0], a[i]);

并将正确交换数组中的两个数字。
您应通过以下方式更正heapify：

public static void heapify(int[] a, int root)
{

    int left = 2 * root + 1;
    int right = 2 * root + 2;
    int heapsize = a.length;
    int largest;

    if ( (left < heapsize) && (a[left] > a[root]))
    {
        largest = left;
    }
    else
    {
        largest = root;
    }
    if ( (right < heapsize) && (a[right] > a[largest]))
    {
        largest = right;
    }
    if (largest != root)
    {
        swap(a, root, largest);
        heapify(a, largest);
    }

}

publicstaticvoidheapify（int[]a，int root）
{
int left=2*root+1；
int right=2*root+2；
int heapsize=a.length；
int最大；
if（（左a[根]）
{
最大=左；
}
其他的
{
最大=根；
}
如果（（右a[最大]）
{
最大=右；
}
如果（最大！=根）
{
交换（a，根，最大）；
希皮菲（a，最大）；
}
}

因此，您的总代码为：

public class tester
{
public static void heapsort(int[] a)
{

    build(a);

    for (int i = a.length - 1; i >= 1; i--)
    {
        swap(a, 0, i);
        int heapsize = a.length - 1;
        heapify(a,0);
    }
}

public static void build(int[] a)
{
    int heapsize = a.length;
    int fl = (int) Math.floor((heapsize)/2);
    for (int i = fl; i >= 0; i--)
    {
        heapify(a, i);
    }
}

public static void heapify(int[] a, int root)
{

    int left = 2 * root + 1;
    int right = 2 * root + 2;
    int heapsize = a.length;
    int largest;

    if ( (left < heapsize) && (a[left] > a[root]))
    {
        largest = left;
    }
    else
    {
        largest = root;
    }
    if ( (right < heapsize) && (a[right] > a[largest]))
    {
        largest = right;
    }
    if (largest != root)
    {
        swap(a, root, largest);
        heapify(a, largest);
    }

}

public static void swap(int[] a, int x, int y)
{
    int tmp;
    tmp = a[x];
    a[x] = a[y];
    a[y] = tmp;
}

public static void main(String[] args)
{
    int[] a = new int[args.length];
    for (int i = 0; i < args.length; i++)
    {
        a[i] = Integer.parseInt(args[i]);
    }
    heapsort(a);
    for (int i : a)
    {
        System.out.println(i);
    }
}
} 

公共类测试器
{
公共静态无效堆端口（int[]a）
{
建造（a）；
对于（int i=a.length-1；i>=1；i--）
{
互换（a，0，i）；
int heapsize=a.length-1；
heapify（a，0）；
}
}
公共静态无效生成（int[]a）
{
int heapsize=a.length；
int fl=（int）数学地板（（heapsize）/2）；
对于（int i=fl；i>=0；i--）
{
希皮菲（a，i）；
}
}
公共静态void heapify（int[]a，int root）
{
int left=2*root+1；
int right=2*root+2；
int heapsize=a.length；
int最大；
if（（左a[根]）
{
最大=左；
}
其他的
{
最大=根；
}
如果（（右a[最大]）
{
最大=右；
}
如果（最大！=根）
{
交换（a，根，最大）；
希皮菲（a，最大）；
}
}
公共静态无效交换（int[]a，int x，int y）
{
int tmp；
tmp=a[x]；
a[x]=a[y]；
a[y]=tmp；
}
公共静态void main（字符串[]args）
{
int[]a=新的int[args.length]；
对于（int i=0；i
也许代码格式少一点？很抱歉，直到最近我开始编码时，我才使用StackOverFlow。我看到其他人发布了他们代码的完整概要，所以我想我也可以这样做。另外，我也是一个新来的人，我知道。非常感谢。谢谢你指导我，输出仍然返回我的输入不变。谢谢你，我发现了我的错误。我已经用heapify（）中的swap（）进行了修复。我想我的问题在于heapsort方法。我正在返回未排序的输入。首先请尝试我发送的代码，我为我工作！你可以用这样的东西来测试它：int[]a={1,3,5,4,2,9}；天哪，我刚刚发现了一个例外，你是对的，代码工作不正常，可能代码的逻辑是错误的。