数据结构（2）-CSDN博客

本文链接：https://blog.csdn.net/m0_73412923/article/details/129229988

二叉树的遍历

（1）先序遍历（根，左，右）

#include  <stdio.h>
int main()
{void PreOrderTraversal(BinTree BT)
{
     if (BT)  {
         printf("%d",BT->DATA);
         PreOrderTravelsal(BT->Left);
         PreOrderTravelsal(BT->Right);
              })

（2）中序遍历（左，根，右）

#include  <stdio.h>
int main()
{void InOrderTraversal(BinTree BT)
{
     if (BT)  {
         InOrderTraversal(BT->Left)
         printf("%d",BT->DATA);
         InOrderTraversal(BT->Right)
              })

(3)后序遍历( 左，右，根）

#include  <stdio.h>
int main()
{void POSTOrderTraversal(BinTree BT)
{
     if (BT)  {
         printf("%d",BT->DATA);
         POSTOrderTravelsal(BT->Left);
         POSTOrderTravelsal(BT->Right);
              })

二叉搜索树

特别函数

Postion Find (ElementType X,BinTree BST)从二叉搜索树中查找元素X，返回其所在节点的地址

Postion FindMin(BinTree BST) 从二叉搜索树中查找并返回最小元素所在的节点地址

Postion FindMax(BinTree BST) 从二叉搜索树中查找并返回最大元素所在的节点地址

Bin Tree Insert（Element Type X,BinTree)

BinTree Delete (ElementType X,BinTree)

查找

Postion 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->Left);
    else
        return BST;
    }

迭代函数

Postion IterFind (ElementType X,BinTree BST)
{
    While(BST){
        if(X>BST->Data)
            BST=BST->Right;
        else if (X<BST->Data)
            BST->Left;
        else
           return BST;        
    }
    return NULL;
    }

查找的效率决定于树的高度

插入

BinTree Insert(ElementType X ,BinTree BST)
{   
    if(!BST)
        BST=malloc(sizeof(struct TreeNode));
        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)
{  Postion Tmp;
   if(!BST) printf("要删除的元素未找到")
    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; 
}

平衡二叉树

空树或者任一结点左，右子树高度差的绝对值不超过1

3.堆（heap)

1.优先队列，取出的元素的顺序是依照元素的优先权大小，而不是元素进入队列的先后顺序

2.堆的性质，结构性，有序性(最大堆操作集)

MaxHeap Create 创建空堆

Boolean IsFull 判断堆是否已经满了

Insert 将item插入

Boolean IsEmpty 判断堆是否为空

ElementType DeleteMax 返回H中最大元素

最大堆的创建

typedef struct HeapStruct  *MaxHeap
struct HeapStruct{
    ElementType  *Elements;
    int size;
    int capacity;
    
}; 
MaxHeap Create (int Maxsize){

MaxHeap Heap =malloc(sizeof (struct Heapstruct));
H->Elements =malloc (sizeof (struct HeapStruct));
H->size =0;
H->capacity =Maxsize;
H->Element[0]=MaxDate;
return  H;
}

算法

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

最大堆的删除

ElementType DeleteMax(MaxHeap)
{
    int Parent ,child;
    ElementType MaxItem , temp;
    if ( IsEmpty (H))  {
        printf("最大堆已经为空")
        return； 
    }
    MaxItem =H->Element[1]//取出根节点的最大值 
    temp =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(temp >=H->Elements[Child]) break;
       else//移动到下一层 
          H->Element[Parent]=H->Elements[Child];
}//给temp找一个位置 
H->Elements[Parent] =temp;
return MaxItem;
 }

3.哈夫曼树

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

哈夫曼树的特点 1.没有度为1 的节点 2. n 个叶子节点的哈夫曼树一共有2n-1个节点

编码（二义性（前缀码，用二叉树进行编码，）

集合

int Find (SetType S[] ,ElementType  X)
{
    int i;
    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;
 }

//堆的表示及操作做
#define MAXH  1001
#define MINH -10001 
int H[MAXN],size;
void  Create()
{
    size=0;
    H[0]=MINH;
 
 }

1.六度空间理论表示一种多对多的关系

一定包含一组顶点边（顶点对）有向便

2.操作集 Graph crteate() 建立并返回空图

Graph InsertVertex(Graph G ,Vertex v)将v插入G

Graph InsertEdge(Graph G,Edge e) 将e插入G

void Dfs (Graph G，Vertex v) 从顶点v出发深度优先遍历图G

void Bfs (Graph G，Vertex v) 从顶点v出发宽度优先遍历图G

void Shortest Path (Graph G，Vertex v，int Dist[]) 计算图G中任意顶点v到其他顶点的最短距离

void MST （Graph G）计算图G的最小生成树

3.*生成图：邻接矩阵邻接表*/

void DFS (Vertex V)
{
    visited[V] =true;
    for(V 的没个临界点w)
       if(!visited[w]) 
         DFS(w); 
}


void BFS(Vertex V)
{
    visited[V] =ture;
    Enqueue (V,Q);
    while (!IsEmpty(Q)){
        V=Dequeue(Q)
        for (V 的每个邻接点w)
           if (!visited[w]){
               visited[w] =ture;
               Enqueue(W,Q);
           }
    } 
}