heap_sort(int arr[], int size)
{
int max;
int i, n = size;
buildHeap(arr, size);
printf("Heap size is %d\n", size);
printf("Heap is : ");
display(arr,size);
display_heap(arr,size);
printf("\n");
while(size>1)
{
max = del_root(arr,&size);
arr[size+1]=max;
printf("Root = %d is deleted and placed at arr[%d]\n", max, size+1);
printf("Heap size is %d\n", size);
printf("Heap is : ");
for(i=1;i<=size;i++)
printf("%d ",arr[i]);
printf("\n");
display_heap(arr, size);
printf("\n");
printf("Array is : ");
for(i=1;i<=size;i++)
printf("%d ",arr[i]);
printf("_____");
for(i=size+1;i<=n;i++)
printf("%d ",arr[i]);
printf("\n\n");
STOP;
}
}/*End of heap_sort*/
heap_sort()
{
int last;
for(last=n-1; last>0; last--)
del_root(last);
}/*End of del_root*/
void heap_sort()
{
int last;
for(last=n-1; last>0; last--)
del_root(last);
}
/*
* bdelete()
*
* Delete the given record from a B-tree.
*/
static int bdelete(struct hfs_brec *brec)
{
struct hfs_btree *tree = brec->tree;
struct hfs_belem *belem = brec->bottom;
struct hfs_belem *parent = (belem-1);
struct hfs_bnode *bnode;
hfs_u32 left_node, right_node;
struct hfs_bnode_ref left, right;
int left_space, right_space, min_space;
int fix_right_key;
int fix_key;
while ((belem > brec->top) &&
(belem->flags & (HFS_BPATH_UNDERFLOW | HFS_BPATH_FIRST))) {
bnode = belem->bnr.bn;
fix_key = belem->flags & HFS_BPATH_FIRST;
fix_right_key = 0;
bdelete_nonempty(brec, belem);
if (bnode->node == tree->root->node) {
del_root(&belem->bnr);
--brec->bottom;
goto done;
}
/* check for btree corruption which could lead to deadlock */
left_node = bnode->ndBLink;
right_node = bnode->ndFLink;
if ((left_node && hfs_bnode_in_brec(left_node, brec)) ||
(right_node && hfs_bnode_in_brec(right_node, brec)) ||
(left_node == right_node)) {
hfs_warn("hfs_bdelete: corrupt btree\n");
hfs_brec_relse(brec, NULL);
return -EIO;
}
/* grab the left neighbor if it exists */
if (left_node) {
hfs_bnode_lock(&belem->bnr, HFS_LOCK_RESRV);
left = hfs_bnode_find(tree,left_node,HFS_LOCK_WRITE);
if (!left.bn) {
hfs_warn("hfs_bdelete: unable to read left "
"neighbor.\n");
hfs_brec_relse(brec, NULL);
return -EIO;
}
hfs_bnode_lock(&belem->bnr, HFS_LOCK_WRITE);
if (parent->record != 1) {
left_space = bnode_freespace(left.bn);
} else {
left_space = NO_SPACE;
}
} else {
left.bn = NULL;
left_space = NO_SPACE;
}
/* grab the right neighbor if it exists */
if (right_node) {
right = hfs_bnode_find(tree,right_node,HFS_LOCK_WRITE);
if (!right.bn) {
hfs_warn("hfs_bdelete: unable to read right "
"neighbor.\n");
hfs_bnode_relse(&left);
hfs_brec_relse(brec, NULL);
return -EIO;
}
if (parent->record < parent->bnr.bn->ndNRecs) {
right_space = bnode_freespace(right.bn);
} else {
right_space = NO_SPACE;
}
} else {
right.bn = NULL;
right_space = NO_SPACE;
}
if (left_space < right_space) {
min_space = left_space;
} else {
min_space = right_space;
}
if (min_space == NO_SPACE) {
hfs_warn("hfs_bdelete: no siblings?\n");
hfs_brec_relse(brec, NULL);
return -EIO;
}
if (bnode->ndNRecs == 0) {
delete_empty_bnode(left_node, &left, &belem->bnr,
right_node, &right);
} else if (min_space + bnode_freespace(bnode) >= FULL) {
if ((right_space == NO_SPACE) ||
((right_space == min_space) &&
(left_space != NO_SPACE))) {
hfs_bnode_shift_left(left.bn, bnode,
bnode->ndNRecs);
} else {
hfs_bnode_shift_right(bnode, right.bn, 1);
fix_right_key = 1;
}
delete_empty_bnode(left_node, &left, &belem->bnr,
right_node, &right);
} else if (min_space == right_space) {
balance(bnode, right.bn);
fix_right_key = 1;
} else {
balance(left.bn, bnode);
fix_key = 1;
}
if (fix_right_key) {
hfs_bnode_update_key(brec, belem, right.bn, 1);
}
hfs_bnode_relse(&left);
hfs_bnode_relse(&right);
if (bnode->ndNRecs) {
if (fix_key) {
hfs_bnode_update_key(brec, belem, bnode, 0);
}
goto done;
}
hfs_bnode_free(&belem->bnr);
--brec->bottom;
belem = parent;
--parent;
}
if (belem < brec->top) {
hfs_warn("hfs_bdelete: Missing parent.\n");
hfs_brec_relse(brec, NULL);
return -EIO;
}
bdelete_nonempty(brec, belem);
done:
hfs_brec_relse(brec, NULL);
return 0;
}
