树-C实现

注意事项

1.可能存在变量名大小问题
2.注意定义例如ElementType

二叉树

层次建立二叉树

BinTree* CreateBinTree(){    int Data;    BinTree* BT,*T;    Queue* Q = CreateQueue();    scanf("%d",&Data); //建立根节点    if(Data){        BT = (BinTree*)malloc(sizeof(BinTree));        BT->Data = Data;        Add(Q,BT);    }else{        return NULL;    }    while(!IsEmptyQ(Q)){          T = DeleteQ(Q);        scanf("%d",&Data);   //读入左孩子        if(!Data)            T->Left = NULL;        else{            T->Left = (BinTree*)malloc(sizeof(BinTree));            T->Left->Data = Data;            AddQ(Q,T->Left);        }        scanf("%d",&Data);//读入右孩子        if(!Data)            T->Right = NULL;        else{            T->Right = (BinTree*)malloc(sizeof(BinTree));            T->Right->Data = Data;            AddQ(Q,T->Right);        }    }    return BT;}

树的高度

int PostOrderGetHeight(BinTree *BT){    int HL,HR,MaxH;    if(BT){        HL = PostOrderGetHeight(BT->Left);        HR = PostOrderGetHeight(BT->Right);        MaxH = HL > HR ? HL : HR;        return (MaxH + 1);    }else{        return 0;    }}

层次遍历

void LevelOrderTraversal ( BinTree BT){    Queue *Q;    BinTree* T;    if(!BT)        return;    Q = CreateQueue();    AddQ(Q,BT);    while(!IsEmptyQ(Q)){        T = DeleteQ(Q);        printf("%d",T->Data);        if(T->Left)            AddQ(Q,T->Left);        if(T->Right)            AddQ(Q,T->Right);    }}

后序非递归

void PostOrder(BinTree *BT){    BinTree *cur;    BinTree *Pre = NULL;    Stack *S = CreateStack();    Push(S,BT);    while(!IsEmpty()){        cur = PtrS->Data[(PtrS->Top)];         if( (cur->Left == NULL && cur->Right == NULL) || (pre != NULL && (pre == cur->Left ||pre == cur->Right ))){            printf("%d",cur->Data);            Pop(S);            pre = cur;        }else{            if(cur->Right)                Push(cur->Right);            if(cur->Left)                Push(cur->Left);        }    }}

前序非递归

void PreOrder(BinTree *BT){    BinTree *T;    Stack *S = CreateStack();    T = BT;    while(T || !IsEmpty(S) ){        while(T){  ////一直向左并将沿途结点压入堆栈            printf("%d",T->Data);//打印结点            Push(S,T);            T = T->Left;        }        T = Pop(S); //结点弹出堆栈        T = T->Right;//转向右子树    }}

中序非递归

void InOrder(BinTree *BT){    BinTree *T;    Stack *S = CreateStack();    T = BT;    while(T || !IsEmpty(S) ){        while(T){  ////一直向左并将沿途结点压入堆栈            Push(S,T);            T = T->Left;        }        T = Pop(S); //结点弹出堆栈        printf("%d",T->Data);//打印结点        T = T->Right;//转向右子树    }} 

递归后中前

void PostOrderTraversal(BinTree *BT){    if(BT){        PostOrderTraversal(BT->Left);        PostOrderTraversal(BT->Right);        printf("%d",BT->Data);    }}void InOrderTraversal(BinTree *BT){    if(BT){        InOrderTraversal(BT->Left);        printf("%d",BT->Data);        InOrderTraversal(BT->Right);    }}void PreOrderTraversal(BinTree *BT){    if(BT){        printf("%d",BT->Data);        PreOrderTraversal(BT->Left);        PreOrderTraversal(BT->Right);    }}

二叉搜索树

按值查找

//递归BinTree* Find(ElementType X, BinTree* BST){    if(!BST)        return NULL; //查找失败    if(X > BST->Data)        return Find(X , BST->Right);    else        if(X < BST->Data)            return Find(X, BST->Left);    else        return BST;}//迭代BinTree* iterFind( ElementType X, BinTree* BST){    while(BST)    {        if(X > BST->Data)            BST=BST->Right;        else if(X < BST->Data)            BST=BST->Left;        else            return BST;    }    return NULL;}

查找最小

BinTree* FindMin( BinTree* BST){    if(BST)        while(BST->Left)            BST=BST->Left;    return BST;}BinTree* FindMin( BinTree* BST){    if(!BST)        return NULL;    else        if(!BST->Left)            return BST;    else        return FindMin(BST->Left);}

查找最大

BinTree* FindMax( BinTree* BST){    if(BST)        while(BST->Right)            BST=BST->Right;    return BST;}BinTree* FindMax( BinTree* BST){    if(!BST)        return NULL;    else        if(!BST->Right)            return BST;    else        return FindMin(BST->Right);}

插入

BinTree* Insert( ElementType X ,BinTree* BST){    if(!BST){        BST = (BinTree*)malloc(sizeof(BinTree));        BST->Data = X;        BST->Left = BST->Right = NULL;    }else{        if(X < BST->Data)            BST->Left = Insert(X,BST->Left);        else if(X > BST->Data)            BST->Right = Insert(X,BST->Right);    }    return BST;}

删除

BinTree* Delete(ElementType X, BinTree *BST){    BinTree* tmp;    if(!BST)        printf("No Found");    else        if(X < BST->Data)            BST->Left = Delete(X,BST->Left); //左子树递归删除        else            if(X > BST->Data)                BST->Right = Delete(X,BST->Right); //右子树递归删除            else if(BST->Left && BST->Right){   //左右节点都存在                tmp = FindMin(BST->Right);  //先找到右边最小 或者左边最大                BST->Data = tmp->Data;                BST->Right = Delete(BST->Data,BST->Right); //删除那个元素            }else{ //被删除的结点有一个或没有子结点                tmp = BST;                if(!BST->Left)                    BST = BST->Right;                else if(!BST->Right)                    BST = BST->Left;                free(tmp);            }    return BST;}

平衡二叉树

实现结构

typedef struct AVLTreeNode{    ElementType Data;    struct AVLTreeNode* Left;    struct AVLTreeNode* Right;    int Height;}AVLTree;

插入以及调整函数

AVLTree* AVL_insertion(ElementType X ,AVLTree* T) //AVL树插入AVLTree* SingleLeftRotation(AVLTree* A); //左单旋AVLTree* DoubleLeftRightRotation(AVLTree* A);//左右双旋AVLTree* SingleRightRotationRotation(AVLTree* A);//右单选AVLTree* DoubleRightLeftRotation(AVLTree* A);//右左双旋AVLTree* DoubleRightLeftRotation(AVLTree* A){    A->Right = SingleLeftRotation(A->Right);    return SingleRightRotation(A);}AVLTree* SingleRightRotation(AVLTree* A){    AVLTree* B = A->Right;    A->Right = B->Left;    B->Left = A;    A->Height = Max(GetHeight(A->Left) , GetHeight(A->Right) ) + 1;    B->Height = MAX(GetHeight(B->Left), GetHeight(B->Right)) + 1;    return B;}AVLTree* DoubleLeftRightRotation(AVLTree* A){    A->Left = SingleRightRotation(A->Left);    return SingleLeftRotation(A);}AVLTree* SingleLeftRotation(AVLTree* A){    AVLTree* B = A->Left;    A->Left = B->Right;    B->Right = A;    A->Height = Max(GetHeight(A->Left) , GetHeight(A->Right) ) + 1;    B->Height = MAX(GetHeight(B->Left), A->Height) + 1;    return B;}AVLTree* AVL_insertion(ElementType X ,AVLTree* T){    if(!T){ //如果插入的是空树        T = (AVLTree*)malloc(sizeof(AVLTree));        T->Data = X;        T->Height = 0;        T->Left = T->Right = NULL;    }else if(X < T->Data){         T->Left = AVL_insertion(X,T->Left);        if(GetHeight(T->Left) - GetHeight(T->Right) == 2) //需要左旋            if(X < T->Left->Data)                T = SingleLeftRotation(T);   //左单旋            else                T = DoubleLeftRightRotation(T); //左右双旋    }else if(X > T->Data){        T->Right = AVL_insertion(X,T->Left);        if(GetHeight(T->Left) - GetHeight(T->Right) == -2)  //需要右旋            if(X < T->Left->Data)                T = SingleRightRotation(T); //右单旋            else                T = DoubleRightLeftRotation(T);//右左双旋    }    //else X == T->Data , 无需插入    T->Height = Max(GetHeight(T->Left) , GetHeight(T->Right) ) + 1; //更新高度    return T;}

最大堆

实现结构

typedef struct Heap{    ElementType *Elements;    int Size;    int Capacity;}MaxHeap;

创建

MaxHeap* Create(int MaxSize){    MaxHeap *H = (MaxHeap)malloc(sizeof(MaxHeap));    H->Elements = (ElementType*)malloc(   (MaxSize + 1)  * sizeof(ElementType) );    H->Size = 0;    H->Capacity = MaxSize;    H->Elements[0] = MaxData; //     哨兵 ：大于堆中所有元素    return H;}

插入

void Insert(MaxHeap H,ElementType item){    int i;    if(IsFull(H)){        printf("最大堆满");        return;    }    i = ++H->Size;    for(;H->Elements[i / 2] < item ; i /= 2)        H->Elements[i] = E->Elements[i / 2];    H->Elements[i] = item;}

删除

Elements DeleteMax(MaxHeap *H){    int Parent,Child;    ElementType MaxItem,tmp;    if(IsEmpty(H)){        printf("最大堆空")        return;    }    MaxItem = H->Elements[1];    tmp = H->Elements[H->Size --];     for(Parent = 1 ; Parent * 2 <= H->Size ; Parent = Child){        Child = Parent * 2;        if( (Child != H->Size) && (H->Elements[Child] < H->Elements[Child + 1])  ) //第一个判断是否有右儿子            Child ++;        if(tmp >= H->Elements[Child])            break;        else //移动到下一层            H->Elements[Parent] = H->Elements[Child];    }    H->Elements[Parent] = tmp;    return MaxItem;}

建立

MaxHeap* BuildMaxHeap(MaxHeap *H){    //调整H中的元素，使有序    int Parent,Child,i;    ElementType tmp;    for( i = H->Size / 2 ; i > 0 ; i --){ //从最后一个结点的父结点开始        tmp = H->Elements[i];        for(Parent = i ; Parent * 2 <= H->Size ; Parent = Child){            Child = Parent * 2;            if( (Child != H->Size) && (H->Elements[Child] < H->Elements[Child + 1 ]))                Child ++;            if(tmp >= H->Elements[Child] )                break;            else                H->Elements[Parent] = H->Elements[Child];        }//内部for循环对以H->Elements[i]为根的子树调整        H->Elements[Parent] = tmp;    }    return H;}

哈夫曼树和集合

哈夫曼树结构及建立

typedef struct TreeNode{    int Weight;    struct TreeNode *Left;    struct TreeNode *Right;}HuffmanTree;HuffmanTree* Huffman(MinHeap H){    int i;    HuffmanTree * T;    BuildMinHeap(H);    for(i = 1 ; i < H->Size ; i ++){        T = (HuffmanTree*)malloc(sizeof(HuffmanTree));        T->Left = DeleteMin(H);        T->Right = DeleteMin(H);        T->Weight = T->Left->Weight + T->Right->Weight;        Insert(H,T);    }    T = DeleteMin(H);    return T;}

集合结构以及查找合并函数

int Find(SetType *S ,ElementType X);//在数组S中查找元素X，返回X元素的树根结点在S中的下标void Union(SetType *S,ElementType X1,ElementType X2);//实现元素合并void Union(SetType *S,ElementType X1,ElementType X2){    int Root1,Root2;    Root1 = Find(S,X1);    Root2 = Find(S,X2);    if( Roo1 != Root2)        S[Root2].Parent = Root1;}int Find(SetType *S ,ElementType X){    for(i = 0 ; i < MaxSize && S[i].Data != X ; i ++);    if(i > MaxSize)        return -1;    for(;S[i].Parent >= 0 ; i = S[i].Parent);    return i;}