/******************************************************************************
* MAIN
******************************************************************************/
int main(int argc, char * argv[])
{
int A[MAX_NUM_NR];
char * filename_unsorted = get_filename(argc, argv);
char * filename_sorted = get_sorted_filename(filename_unsorted);
int n = get_A(A, MAX_NUM_NR, filename_unsorted);
print_A(A, n, "original:");
heap_sort(A, n);
print_A(A, n, "sorted:");
assert(verify_A(A, n, filename_sorted));
/* priority queue */
int heapsize = n;
build_max_heap(A, heapsize);
______________________________(A, n, heapsize, "===============\\nafter build_max_heap\\n===============");
printf("heap_maximum: %d\n", heap_maximum(A, heapsize));
printf("heap_extract_max: %d\n", heap_extract_max(A, &heapsize));
print_A(A, heapsize, "after heap_extract_max");
______________________________(A, n, heapsize, "===============\\nafter heap_extract_max\\n===============");
heap_increase_key(A, heapsize, 3, 88);
print_A(A, heapsize, "after heap_increase_key");
______________________________(A, n, heapsize, "===============\\nafter heap_increase_key\\n===============");
max_heap_insert(A, n, &heapsize, 97);
print_A(A, heapsize, "after max_heap_insert");
______________________________(A, n, heapsize, "===============\\nafter max_heap_insert\\n===============");
return 0;
}
void
main(void)
{
int i;
int arr[] = {4, 1, 3, 2, 16, 9, 10, 14, 8, 7};
int *heap_size = malloc(sizeof(int));
*heap_size = sizeof(arr) / sizeof(int) - 1;
HEAP A = {arr, heap_size};
build_max_heap(A);
heap_increase_key(A, 8, 15);
for (i = 0; i <= *(A.heap_size); i++)
printf("%d\t", A.arr[i]);
printf("\n%d\n", *(A.heap_size));
heap_extract_max(A);
printf("%d\n", *(A.heap_size));
printf("\n");
for (i = 0; i <= *(A.heap_size); i++)
printf("%d\t", A.arr[i]);
printf("\n");
A = max_heap_insert(A, 16);
printf("%d\n", *(A.heap_size));
for (i = 0; i <= *(A.heap_size); i++)
printf("%d\t", A.arr[i]);
printf("\n");
A = heap_delete(A, 3);
for (i = 0; i <= *(A.heap_size); i++)
printf("%d\t", A.arr[i]);
printf("\n");
}
int max_heap_insert(int *a, int key)
{
a[0]++;
a[a[0]] = INT_MIN;
heap_increase_key(a,a[0],key);
}
HEAP
max_heap_insert(HEAP A, int key)
{
int i;
*(A.heap_size) = *(A.heap_size) + 1;
A.arr[*(A.heap_size)] = -1111111;
heap_increase_key(A, *(A.heap_size), key);
return A;
}
/**
* @brief insert an element in a max heap
*
* This routine inserts an element in the heap. The element is a {key,data}
* pair.
*
* @param[in] h The heap to operate on
* @param[in] key The element key component
* @param[in] data The element data component
* @param[out] i The updated heap index for the {key, data} will be stored here.
* @return HEAP_ERR_E
*/
HEAP_ERR_E heap_max_insert (HEAP_T* h, unsigned long key, void* data, unsigned long* i)
{
if (h->type != DS_HEAP_MAX)
return HEAP_ERR_WRONG_TYPE;
heap_add (h, HEAP_NIL_KEY, data, i);
heap_increase_key (h, h->heap_size-1, key);
return HEAP_ERR_OK;
}
void heap_insert(heap_t heap, int key)
{
heap.heap_size += 1;
if (heap.heap_size >= heap.size) {
printf("Over flow\n");
return;
}
heap.arr[heap_size] = -1;
heap_increase_key(heap, heap_size, key);
}
void
max_heap_insert(int *A, int key)
{
/*
* 把元素x插入集合A中
*/
heapsize++;
A[heapsize] = MIN;
heap_increase_key(A, heapsize, key);
}
void max_heap_insert(HeapT* h, SequenceT key) {
assert(h != NULL);
HeapImplT* heap = (HeapImplT*) h;
if (heap->size == heap->capacity) {
heap->capacity *= GROWTH_FACTOR;
heap->data = realloc(heap->data, sizeof(SequenceT) * heap->capacity);
}
++heap->size;
heap->data[heap->size - 1] = INVALID_NODE;
heap_increase_key(h, heap->size - 1, key);
}
void max_heap_insert (heap h, val_t v) {
// allocate new heap space if needed to insert a new key
if (h->size == h->data_length) {
int extra = h->size/2;
if ((h->data = (val_array) realloc (h->data, (h->size+extra)*sizeof(val_t))) == NULL) {
printf ("could realloc heap memory\n");
exit(1);
}
h->data_length += extra;
}
++h->size;
set(h,h->size-1,-65562);
heap_increase_key(h,h->size-1,v);
return;
}
void heap_insert(heap_t* heap, int key)
{
heap->heap_size ++;
if(heap->heap_size > heap->length)
{
int* items = malloc(sizeof(int) * heap->heap_size); // 内存泄露，由于items不是全局的，不好释放
for(int i = 0; i < heap->length; i++)
{
items[i] = heap->elements[i];
}
items[heap->heap_size - 1] = key - 1;
heap->elements = items;
heap->length ++;
}
heap_increase_key(heap, heap->heap_size - 1, key);
}
void max_heap_insert(int * A, int Asize, int * heapsize, int key)
{
assert(*heapsize < Asize);
A[(*heapsize)++] = INT_MIN;
heap_increase_key(A, *heapsize, *heapsize - 1, key);
}
void max_heap_insert(Heap h, Hnode value){
h[0].val += 1;
h[heap_size(h)].val = INT_MIN;
heap_increase_key(h, heap_size(h), value);
}
void max_heap_insert (int A[], int key, int size){
size++;
A[size] = -99999;
heap_increase_key(A, size, key);
return;
}
int main()
{
printf("----------------------Heap---------------------\n");
printf("\t0. max_heapify(heap_t*, int)\n");
printf("\t1. build_max_heap(heap_t*)\n");
printf("\t2. heap_extract_max(heap_t*)\n");
printf("\t3. heap_sort(heap_t*)\n");
printf("\t4. heap_increase_key(heap_t*, int, int)\n");
printf("\t5. heap_insert(heap_t*, int)\n");
printf("Please select (-1 to quit): ");
int select;
scanf("%d", &select);
if(select == -1)
{
exit(0);
}
while(select != -1)
{
heap_t heap;
int length;
int heap_size;
printf("Now create a heap\n");
printf("Enter heap length: ");
scanf("%d",&length);
printf("Enter heap size: ");
scanf("%d",&heap_size);
printf("Enter elements: \n");
int items[length];
for(int i = 0; i < heap_size; i++)
{
scanf("%d",&items[i]);
}
heap.length = length;
heap.heap_size = heap_size;
heap.elements = items;
switch(select)
{
case 0:
printf("Please enter index you want to heapify: ");
int index;
scanf("%d",&index);
max_heapify(&heap, index);
break;
case 1:
build_max_heap(&heap);
break;
case 2:
build_max_heap(&heap);
heap_extract_max(&heap);
break;
case 3:
build_max_heap(&heap);
heap_sort(&heap);
break;
case 4:
build_max_heap(&heap);
printf("Please enter index you want to increase: ");
int i = getchar();
printf("Please enter key: ");
int key = getchar();
heap_increase_key(&heap, i, key);
break;
case 5:
build_max_heap(&heap);
printf("Please enter elements you want to insert: ");
int element = getchar();
heap_insert(&heap,element);
break;
default:
printf("Num error.");
}
for(int i = 0; i < heap.length; i++)
{
printf("%d ", heap.elements[i]);
}
printf("\n\n");
printf("\t0. max_heapify(heap_t*, int)\n");
printf("\t1. build_max_heap(heap_t*)\n");
printf("\t2. heap_extract_max(heap_t*)\n");
printf("\t3. heap_sort(heap_t*)\n");
printf("\t4. heap_increase_key(heap_t*, int, int)\n");
printf("\t5. heap_insert(heap_t*, int)\n");
printf("Please select (-1 to quit): ");
scanf("%d",&select);
}
printf("----------------------End---------------------\n");
return 0;
}
void max_heap_insert(double* srcdata, int* len, double dValue){
*len = *len + 1;
srcdata[*len-1] = -1;
heap_increase_key(srcdata,*len,*len,dValue);
}
void heappush( Vector* V, cmp compare, void* item ) {
push( V, item );
heap_increase_key( V, compare, vector_size( V ) - 1, item );
}