My heap sorting is wrong somewhere, help me fix it

When maintaining the heap, your flag is not initialized, and whether it enters the while loop is undetectable.

Just assign a non-0 value to the flag before while to ensure that it enters the loop.

Also, I don't understand why you use a very small pile to arrange the array in reverse order, and then output it in reverse order, which is purely redundant. Just use the very large pile.

*heapsort*/

#include

#include

#include

int a[1000];

int n;

void heap(int d ,int m) maintains the heap.

int min,flag=1,temp;

while(flag)

flag=0;

min=a[d];

if(d*2<=m&&a[d*2]=1;i--)heap(i,n);The initial heap is built in an orderly manner from the bottom to the top.

int main()

int i,temp;

printf("please enter the number(<999) of the number is to be sorted.");

scanf("%d",&n);

printf("please enter each number.");

for(i=1;i<=n;i++)scanf("%d",&a[i]);

long tim=gettickcount();

buildheap();

for(i=n;i>=2;i--)

temp=a[1];

a[1]=a[i];

a[i]=temp;

heap(1,i-1);

for(i=n;i>=1;i--)printf("%d",a[i]);

printf("it takes %ld (ms).",gettickcount()-tim);

system("pause");

It's correct to use the size of the left and right trees to sort the heaps. There's nothing wrong with that.

I'm going to post my own template, my heap sorting.

#include

#include

void heapadjust(int array, int a, int nlength)

void heapsort(int array, int nlength)

int main()

Heap sorting1, heap definition.

A heap is a sequence of n keywords with the following characteristics:

ki<=k2i

and ki<=k2i+1 (1<=i<=n 2) (1).

or ki>=k2i

and ki>=k2i+1 (1<=i<=n 2) (2).

ki>=k2i

Those that satisfy Eq. (1) are called minimalist heaps, or very small heaps, or small heaps, and those that satisfy Eq. (2) are called maximized heaps, or very large heaps. In this section, we will use a miniaturized heap as an example.

The relationship between the heap and the full binary tree: The heap is a sequence of n elements (keywords), which satisfies the relationship between the nodes (the relationship between the parents and the children's serial numbers) in the sequential storage of the complete binary tree.

17, 28, 51, 33, 62, 96, 87, 51 are small top piles.

96, 51, 87, 33, 28, 62, 51, 17 are the big top piles.

Binary heap 2, the basic problem of heap sorting.

Since the top element (keyword) is the smallest element, it is the smallest element of the sorted sequence, and after output, the other elements are adjusted into a heap, and the new top element is the second element of the sorted sequence. In this way, a disordered sequence can be turned into an ordered sequence by using the heap. Therefore, the basic problem with heap ordering is:

1) How to build a pile.

2) How to adjust the pile.

3. How to adjust the pile.

After swapping the last element with the top element of the heap (equivalent to outputting the top element of the heap), all elements from the top of the heap to the penultimate element meet the definition of the heap. The following is a filter method to put all the elements, including the top element of the pile, into a pile. Big pile of roots.

void sift(rectype r，int i，int m)

for‖heapsort

6. Analysis of heap sorting algorithm.

The time complexity is o(nlogn) and only one secondary storage space of record size is required for swapping.

Let's give you a stacked **!

Smallroot tree * include

using namespace std;

int a[10000];

int n;

void check(int i)}}

void bheap()

int main()

system("pause");

return 0;}

Number of deletions in the minimum heap.

void minheapdeletenumber(int a, int n)

The problem with this function is that you should first swap the deleted element with the last element, compare it and then decide whether to adjust it up or down.

You're obviously wrong Heap sorting first of all there must be more than one data should be a set of data in the array int a 20 , and then assign a value to the array, heap sorting is not written by yourself...

minheapaddnumber();

minheapsorttodescendarray();

The arguments passed by your two functions don't match the form parameters.

Heap ordering is the equivalent of a sorting binary tree, except that the priority of the root node is greater than that of any child, so that the root node can be deleted each time and then the whole heap can be adjusted.

program heap;

var a:array[1..10000] of integer;

n,i:integer;

procedure down(i:integer);

var x,j:integer;

beginx:=a[i];

j:=i*2;

while j<=n do

beginif a[j]>a[j+1] then j:=j+1；

if a[j]begin

a[i]:=a[j];

i:=j;j:=i*2;

end else break;

end;a[i]:=x;

end;procedure delete(i);

beginn:=n-1；

if (n=0)or(i=n+1) then exitelse

begina[i]:=a[n+1];

down(i);

end;end;

beginreadln(n);

for i:=1 to n do read(a[i]);

for i:=n div 2 downto 1 do down(i);

for i:=1 to n do

beginwrite(a[1]);

delete(1);

end;end.

You can imagine that this data is used to form a binary tree, where the left child of each node is smaller than him, and the child is older than him, so that a sorting tree is established. Finally, in the middle order of traversing one side, read a point to print the data of this point.

PS: Who is that master upstairs? The program seems right?!

for (int i = heap[0] /2; i > 0; i++)

heapmaxheapify(heap, i);

This cycle is an endless loop.