Algorithm 当考虑堆排序的比较时，你认为什么是比较？

我已经编写了堆排序算法，但我很难决定什么应该被视为比较。我认为以下内容有助于进行比较，但我得到的结果似乎与我不符（可能很多？），下面是代码

       public class heapsort{
      static int counter = 0;

      public static void main(String[] args) { 
         //int[] a1={1, 16, 2, 3, 14, 4, 5, 12, 7, 10, 8, 9, 17, 19, 21, 23, 26, 27}; 

            int[] a1 = {1, 2};
            System.out.println(sort(a1)); 
         for(int i=0;i<a1.length;i++){ 
            System.out.print(a1[i] + " "); 
         } 
      } 

      private static int[] a; 
      private static int n; 
      private static int left; 
      private static int right; 
      private static int largest;

      public static void buildheap(int[] a){ 
         n= a.length-1; 
         for(int i= n/2; i >= 0; --i){ 
            maxheap(a,i); 
         } 
      } 

      public static void maxheap(int[] a, int i){ 
         left=2*i; 
         right=2*i+1; 
         if(left <= n && a[left] > a[i]){ 
            counter++;
            largest=left; 
         } 
         else{ 
            counter++;
            largest=i; 
         } 

         if(right <= n && a[right] > a[largest]){ 
            counter++;

            largest=right; 
         } 
         if(largest!=i){ 
            counter++;     
            exchange(i,largest); 
            maxheap(a, largest); 
         } 
      } 

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

      public static int sort(int []a0){ 
         a=a0; 
         buildheap(a); 

         for(int i=n;i>0; --i){ 
            exchange(0, i); 
            n=n-1; 
            maxheap(a, 0); 
         } 
         return counter;
      }       
   }

公共类heapsort{
静态整数计数器=0；
公共静态void main（字符串[]args）{
//int[]a1={1,16,2,3,14,4,5,12,7,10,8,9,17,19,21,23,26,27}；
int[]a1={1，2}；
系统输出打印LN（排序（a1））；
对于（int i=0；i=0；--i）{
maxsheap（a，i）；
} 
} 
公共静态void maxheap（int[]a，int i）{
左=2*i；
右=2*i+1；
if（左a[i]）{
计数器++；
最大=左；
} 
否则{
计数器++；
最大=i；
} 
如果（右a[最大]{
计数器++；
最大=右；
} 
如果（最大！=i）{
计数器++；
交易所（i，最大）；
最大堆（a，最大）；
} 
} 
公共静态无效交换（inti，intj）{
int t=a[i]；
a[i]=a[j]；
a[j]=t；
} 
公共静态int排序（int[]a0）{
a=a0；
建筑群（a）；
对于（int i=n；i>0；--i）{
交换（0，i）；
n=n-1；
maxheap（a，0）；
} 
返回计数器；
}       
}

---

我知道有些柜台可能是错的，是吗

计算数组的比较，有时/总是“a”。例如：“a[左]>a[我]”。您可以为比较添加一个计数器作为全局计数器，并在每次进行比较时使用它来获得比较计数

---

顺便说一句，堆排序在理论上很有趣，但它不稳定，通常没有timsort快，也没有利用部分排序的数据。

通常只计算元素比较，而不是整数比较，即使数组中的元素是整数

为了让这更有意义，如果要将数组更改为字符串数组（例如），只计算字符串比较的数量。字符串比较通常要比整数比较昂贵得多（如果您有一个包含许多字段的大型对象，则更为昂贵），因此只计算这些字段是有意义的

因此，这些比较元素：

a[left] > a[i]
a[right] > a[largest]

这些只是比较整数：

i >= 0
left <= n
right <= n
largest != i
i > 0

因此

a[left]>a[i]

将变成

compare（a[left]，a[i]）>0

，对于另一个也是如此

---

A可能是一个更通用的解决方案，但在这种情况下可能有点过头了。

现在还不清楚你在问什么。关键是要找出算法的效率。手动执行此操作时，必须对数组中的值进行比较。什么时候我应该考虑比较，这样我就可以在我的比较计数中加上1？这是为了找到算法OK的最佳情况和最坏情况；你的问题中没有描述你试图计算比较的事实。@OliCharlesworth我希望我能突出它，但试着读第一句话。也许吧。但是，没有人会想通过拖网浏览所有这些代码来了解您的问题；）在实际解决方案中，这是一种更好的方法。结果表明，我们典型的堆排序算法有时会遗漏或添加手动进行的比较。答案实际上取决于手动执行算法，而不是在计算机上运行。谢谢你的意见，这给了我一个更好的主意。

int compare(int a, int b)
{
  counter++;
  return Integer.compare(a, b);
}