Java 使用堆排序对数组进行排序

我现在真的想知道我到底出了什么问题，但是我失败了。请大家告诉我我到底出了什么问题

对不起，我的英语不好

首先要解决两个问题（还会有更多问题）

1） Java不是C。请使用

A.length

查找

A的长度，不要传递单独的变量

2） 你对l和r的计算被破坏了。您输入
6/2
=
3
，然后获得
2*3
和
2*3+1
（
6
和
7
）作为您的指示。这两个问题都无效。
还有两个问题需要解决（还会有更多问题）

1） Java不是C。请使用
A.length
查找
A的长度，不要传递单独的变量

2） 你对l和r的计算被破坏了。您输入
6/2
=
3
，然后获得
2*3
和
2*3+1
（
6
和
7
）作为您的指示。这两个都是无效的。
我猜你的问题在这里：
void MaxHeapify（int A[]，int i）

您可以指定左侧和右侧子对象：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 6
    at HeapSor.MaxHeapify(HeapSort.java:41)
    at HeapSor.BuiltHeap(HeapSort.java:31)
    at HeapSor.Heap_Sort(HeapSort.java:23)
    at HeapSort.main(HeapSort.java:5)

但你不会检查他们是否在禁区内。您可以检查
i

int l=2*i;  
int r=2*i+1; 

但是
2*i
可能超出范围，您可以使用它：

if(i>HeapSize)  
        return;

我猜你的问题就在这里：
void MaxHeapify（inta[]，inti）

您可以指定左侧和右侧子对象：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 6
    at HeapSor.MaxHeapify(HeapSort.java:41)
    at HeapSor.BuiltHeap(HeapSort.java:31)
    at HeapSor.Heap_Sort(HeapSort.java:23)
    at HeapSort.main(HeapSort.java:5)

但你不会检查他们是否在禁区内。您可以检查
i

int l=2*i;  
int r=2*i+1; 

但是
2*i
可能超出范围，您可以使用它：

if(i>HeapSize)  
        return;

void max_heapify（int a[]，int i，int n）{
int mxPos=i；
int l=i*2；//左子级
int r=i*2+1；//右子代
如果（la[mxPos]）mxPos=l；
如果（ra[mxPos]）mxPos=r；
如果（mxPos！=i）{
掉期（a[i]，a[mxPos]）；
max_heapify（a，mxPos，n）；
}
}
无效生成最大堆（int a[]，int n）{
对于（inti=n/2；i>=1；i--）max_heapify（a，i，n）；
}
无效堆口（int a[]，int n）{
构建最大堆（a，n）；
对于（int i=n；i>=2；i--）{
掉期（a[1]，a[i]）；
n--；
max_heapify（a，1，n）；
}
}
int main（）{
int n，a[100]；
cin>>n；
对于（int i=1；i>a[i]；
heapsort（a，n）；
对于（inti=1；i
void max_heapify（inta[]，inti，intn）{
int mxPos=i；
int l=i*2；//左子级
int r=i*2+1；//右子代
如果（la[mxPos]）mxPos=l；
如果（ra[mxPos]）mxPos=r；
如果（mxPos！=i）{
掉期（a[i]，a[mxPos]）；
max_heapify（a，mxPos，n）；
}
}
无效生成最大堆（int a[]，int n）{
对于（inti=n/2；i>=1；i--）max_heapify（a，i，n）；
}
无效堆口（int a[]，int n）{
构建最大堆（a，n）；
对于（int i=n；i>=2；i--）{
掉期（a[1]，a[i]）；
n--；
max_heapify（a，1，n）；
}
}
int main（）{
int n，a[100]；
cin>>n；
对于（int i=1；i>a[i]；
heapsort（a，n）；
对于（inti=1；i这对我来说很有效：

void max_heapify(int a[],int i,int n) {
    int mxPos = i;
    int l = i*2; // left child
    int r = i*2+1; // right child

    if( l <= n and a[l] > a[mxPos] ) mxPos = l;
    if( r <= n and a[r] > a[mxPos] ) mxPos = r;

    if( mxPos != i ) {
        swap( a[i] , a[mxPos] );
        max_heapify( a , mxPos , n );
    }
}

void build_max_heap( int a[] ,int n) {
    for(int i = n / 2 ; i >= 1 ; i-- ) max_heapify(a,i,n);
}

void heapsort(int a[],int n) {
    build_max_heap(a,n);
    for( int i = n ; i >= 2 ; i-- ) {
        swap( a[1] , a[i] );
        n--;
        max_heapify( a , 1 , n );
    }
}

int main() {
    int n , a [100] ;
    cin >> n ;
    for( int i = 1 ; i <= n ; i++ ) cin >> a[i] ;
    heapsort(a,n);
    for( int i = 1 ; i <= n ; i++ ) cout << a[i] << endl;
}

包堆；
公共类堆{
私有静态int[]a；
私有静态int n；
私有静态int左；
私权；
私有静态int最大；
公共静态void buildheap（int[]a）{
n=a.长度-1；
对于（int i=n/2；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，最大）；
}
}
公共静态无效交换（int i，int j）{
int t=a[i]；
a[i]=a[j]；
a[j]=t；
}
公共静态无效排序（int[]a0）{
a=a0；
建筑群（a）；
对于（int i=n；i>0；i--）{
交换（0，i）；
n=n-1；
maxheap（a，0）；1
}
}
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
int[]a1={4,1,3,2,16,9,10,14,8,7}；
排序（a1）；
对于（int i=0；i
这对我很有用：

void max_heapify(int a[],int i,int n) {
    int mxPos = i;
    int l = i*2; // left child
    int r = i*2+1; // right child

    if( l <= n and a[l] > a[mxPos] ) mxPos = l;
    if( r <= n and a[r] > a[mxPos] ) mxPos = r;

    if( mxPos != i ) {
        swap( a[i] , a[mxPos] );
        max_heapify( a , mxPos , n );
    }
}

void build_max_heap( int a[] ,int n) {
    for(int i = n / 2 ; i >= 1 ; i-- ) max_heapify(a,i,n);
}

void heapsort(int a[],int n) {
    build_max_heap(a,n);
    for( int i = n ; i >= 2 ; i-- ) {
        swap( a[1] , a[i] );
        n--;
        max_heapify( a , 1 , n );
    }
}

int main() {
    int n , a [100] ;
    cin >> n ;
    for( int i = 1 ; i <= n ; i++ ) cin >> a[i] ;
    heapsort(a,n);
    for( int i = 1 ; i <= n ; i++ ) cout << a[i] << endl;
}

包堆；
公共类堆{
私有静态int[]a；
私有静态int n；
私有静态int左；
私权；
私有静态int最大；
公共静态void buildheap（int[]a）{
n=a.长度-1；
对于（int i=n/2；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，最大）；
}
}
公共静态无效交换（int i，int j）{
int t=a[i]；
a[i]=a[j]；
a[j]=t；
}
公共静态无效排序（int[]a0）{
a=a0；
建筑群（a）；
对于（int i=n；i>0；i--）{
交换（0，i）；
n=n-1；
maxheap（a，0）；1
}
}
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
int[]a1={4,1,3,2,16,9,10,14,8,7}；
排序（a1）；
对于（int i=0；i
尝试调试时您发现了什么？尝试调试时您发现了什么？将其更改为if（i>HeapSize | | l>HeapSize | | r>HeapSize）仍然不起作用您的heapsort算法是错误的。但是您不应该得到任何异常。如果这样做，请放置堆栈跟踪并向我们显示行将其更改为if（i>HeapSize | l>HeapSize | r>HeapS