asd二叉树

1.树概念及结构

2.二叉树概念及结构

3.二叉树顺序结构及实现

4.二叉树链式结构及实现

---------------------------------------------------------------------------------------------

1.树概念及结构

//HP.h
#include<stdio.h>
#include<stdbool.h>
#include<assert.h>
#include<stdlib.h>

typedef int HPDataType;

typedef struct HP
{
	HPDataType* a;
	int size;
	int capacity;
}HP;
void HPInit(HP* php);

//HP.c
void HPInit(HP* php)
{
    assert(php);
    php->a = (HPDataType*)malloc(sizeof(HPDataType) * 4);
    if (php->a == NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
    else
    {
      php->size = 0;  
      php->capacity = 4;
    }
}

void HPInitArray(HP* php, int n, int* a)
{
    assert(php);
    php->a = (HPDataType*)malloc(sizeof(HPDataType)*n);
    if (php->a == NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
    php->size = n;
    php->capacity=n;
    for (int i = (n - 2) / 2; i >= 0; i--)
    {
        AjustDown(php->a, php->size, i);
    }
}

void HPDestroy(HP* php)
{
    assert(php);
    free(php->a);
    php->a = NULL;
    php->capacity = php->size = 0;
}

void Swap(HPDataType* p1, HPDataType* p2)
{
    *p1 = *p1 ^ *p2;
    *p2 = *p1 ^ *p2;
    *p1 = *p1 ^ *p2;
}

void AjustUp(HPDataType* a,int child)
{
    int parent = (child - 1) / 2;
    while (child > 0)
    {
        if (a[child] > a[parent])
        {
            Swap(&a[child], &a[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }

}

void HPPush(HP* php, HPDataType x)
{
    assert(php);
    if (php->capacity == php->size)
    {
        int newcapacity = php->capacity * 2;
        php->a = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
        assert(php->a);
        php->capacity = newcapacity;
      
    }  php->a[php->size++] = x;
    AjustUp(php->a, php->size, php->size - 1);
    
}

void AjustDown(HPDataType* a, int n, int parent)
{
    int child = parent * 2 + 1;
    while (child < n)
    {
        if (a[child] > a[child + 1])
        {
            child++;
        }
        if (a[child] < a[parent])
        {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = (parent * 2 + 1);
        }
        else
        {
            break;
        }
    }
}

void HPPop(HP* php)
{
    assert(php);
    assert(php->size > 0);
    Swap(&php->a[0], &php->a[php->size - 1]);
    php->size--;
    AjustDown(php->a, php->size, 0);
}

HPDataType HPTop(HP* php)
{
    assert(php);
    return php->a[0];
}

bool HPEmpty(HP* php)
{
    assert(php);
    return php->size == 0;
}

int HPSize(HP* php)
{
    assert(php);
    return php->size;
}