數據結構和算法分析（11）樹的簡介

    對於大量的數據，鏈表的線性訪問時間太慢，不宜使用。我們介紹一種簡單的數據結構，其大部分操作的平均時間為O(log N)。

   

    (1)學習目標:

    我們將要涉及到的數據結構叫做二叉查找樹(binary search tree)。

    我們將要了解如下內容:

1.了解樹是如何用於實現幾個流行的操作系統中的文件系統的;
2.看到樹如何能夠用來計算算術表達式的值;
3.如何指出利用樹支持以O(log N)平均時間進行的各種搜索操作，以及如何細化得到最壞情況時間界O(log N)。我們還將討論當數據被存在磁盤上時如何來實現這些操作。

 

    (2)樹的基礎知識:

    樹的遞歸定義:

      一棵樹由稱作根(root)的結點r以及0個或多個非空的(子)樹T1,T2,T3......組成，這些子樹中每一顆的根都來自根r的一條有向邊(Edge)所連接。

    

 

    2.1樹的實現:

    每一個結點的兒子樹不確定時，可以進行如下定義:

typedef struct TreeNode *PtrToNode;

struct TreeNode
{
    ElementType  Element;
    PtrToNode FirstChild;
    PtrToNode NextSibling;
}

 

    2.2樹的遍歷及應用:

    樹有很多應用，流行的用法之一是包括UNIX,VAX,VAX/VMS和DOS在內的許多常用操作系統中的目錄結構:

    在Unix文件系統每個目錄還有一項指該向目錄本身以及另一項指向該目錄的父目錄。因此嚴格來說，UNIX文件系統不是樹，而是類樹。

    設我們想要得到目錄中所有文件的名字。我們的輸出格式是:深度為di的文件的名字將被第di此跳格縮進后打印出來:

static void ListDir(DirectoryOrFile D,int Depth)
{
    if(D is a legitimate entry)
    {
      PrintName(D,Name);
      if(D is a directory)
        for each child,c,of D
          ListDir(C,Depth+1);            
    }
}//算法的核心例程
void ListDirectory(DirectoryOrFile D)
{
    ListDir(D,0);
}//驅動例程

    

    輸出文件通常用樹的先序遍歷(preorider traversal)，而樹的后續遍歷通常用來計算該樹所有文件占用的磁盤塊的總數。

    計算一個目錄大小的例程:

static void SizeDirectory(DirectoryFile D)
{
    int TotalSize;  
    TotalSize=0;
    if(D is a legitimate Entry)
    {
      TotalSize=FileSize(D);//當當前是文件，不是目錄時
      if(D is a directory)
        for(each child,C, of D)
          TotalSize+=SizeDirectory(C);
    }
    return TotalSize;
}

 

    (3)二叉樹:

    定義:

    二叉樹(binary tree)是一棵樹，每一個結點都不能有多於兩個的兒子。

   

    特點:

    平均二叉樹的深度要比N小得多，這個性質有時很重要。分析表明，這個平均深度為O(√N)，而對於特殊的二叉樹，即二叉查找樹(binary search tree)，其深度的平均值是O(log N)。

    二叉樹的結點聲明:

typedef struct TreeNode *PtrToNode;
typedef struct PtrToNode Tree;

struct TreeNode
{
    ElementType Element;
    Tree left;
    Tree right;
};

 

    (4)二叉樹的應用:(表達式樹)

    二叉樹有許多與搜索無關的重要應用。它的主要用途之一是在編譯器的設計領域。

/***************構造表達式樹***************/
/*
  1.輸入中綴表達式先轉化為后綴表達式; 
  2.根據后綴表達式構造樹 
  3.分別以中序遍歷法和后序遍歷法遍歷此樹 
*/ 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define EmptyTOS (-1)
#define MinStackSize 5
 
struct StackRecord{
  int Capacity;//能存元素最大量
  int TopOfStack;//記錄新插入的元素所在數組中的位置
  char Array[30][5];//字符串數組，每個字符串的大小最多為5 
};
typedef struct StackRecord *Stack;

void MakeEmpty(Stack s){
    s->TopOfStack=EmptyTOS;
}
Stack CreateStack(int MaxElement){
    Stack s;  
    if(MaxElement<MinStackSize){
        printf("要創建的棧太小，應大於5。\n");
        exit(0); 
    }else{        
      s=malloc(sizeof(struct StackRecord));
      s->Capacity=MaxElement;
      MakeEmpty(s);    
    }
    return s; 
}
//判斷棧是否為空棧 
int IsEmpty(Stack S){
    return S->TopOfStack==EmptyTOS; 
}
//判斷是否滿了，當為1是滿了，為0是表示未滿 
int IsFull(Stack S){
    if(S->TopOfStack+1>=S->Capacity){
        return 1;
    }else
    return 0;
}
//壓棧 
void Push(char *x,Stack S){
 if(IsFull(S)){
     printf("棧已經滿了！\n");
 }else{
     strcpy(S->Array[++S->TopOfStack],x);
 }     
}
//只獲得頭元素 
char *Top(Stack S){
    if(IsEmpty(S)){
        printf("此棧為空，無法取棧頭元素!\n");
        exit(0);
    }else{
        return S->Array[S->TopOfStack]; 
    }
}
//只刪除頭元素 
void Pop(Stack S){
    if(IsEmpty(S)){
        printf("此棧為空，無法去除棧頭元素!\n");
    }else{
        S->TopOfStack--; 
    }
}
//獲取頭元素並刪除 
char *PopAndTop(Stack S){
    if(IsEmpty(S)){
        printf("此棧為空，無法執行獲取棧頭元素和去除棧頭元素!\n");
        exit(0);
    }else{
        return S->Array[S->TopOfStack--];
    }
}
//釋放棧空間 
void DisposeStack(Stack s){
    if(s!=NULL){
        free(s); 
    }
} 
void printStack(Stack s){
    int i;
    for(i=0;i<=s->TopOfStack;i++){
        printf("%s ",s->Array[i]);
    }    
}
//位置是從棧頭開始計算，所以誰小誰離棧頂比較遠 
int LastPosition(char *p,Stack temp){
    int i;
    if(exist(p,temp)){
      for(i=temp->TopOfStack;i>=0;i--){
        if(strcmp(temp->Array[i],p)){
            return i;
        }
      }    
    }
    else{
      printf("臨時棧沒有%s這個操作符\n",p);
      return -1; 
    }
}
int IsNumber(char p){
    if(p>='0'&&p<='9'){
      return 1;    
    }else
    return 0;
}
//由於這里允許負數的存在，所以與之前的函數不同 
int IsOperator(char *p){//這個函數是給turnInto函數使用的 
    //當長度不為1.肯定是數字，不是操作符 
    if(p[1]!='\0'){
        return 0;
    }     
    //當長度為1，且不為從0到9的數時，才是操作符 
    if(IsNumber(p[0])){
        return 0;
    }else
    return 1; 
}
int exist(char *p,Stack temp){
    int i;
    for(i=0;i<=temp->TopOfStack;i++){
        if(strcmp(temp->Array[i],p)==0){
            return 1;
        }
    }
    return 0;
}
//用這個遞歸提取函數明顯比以前用的順序處理要好得多 
void handleString(char *s,Stack    s_center){
    //printf("即將操作的字符串%s\n",s);
    int i=0;
    int flag=-1;//當遞歸調用這個函數，上一個函數的flag會影響下一個函數的flag值，所以最好每次用時都初始化，而且函數段中每次用flag都最好先賦初值 
    char temp[5];
    if(s[0]=='\0'){
        return;
    }
    if(s[i]=='('&&s[i+1]=='-'){//處理類似1.(-34*76+21)-12或者2.(-43)+76這種形式的表達式字符串
      flag=0; 
      temp[flag]='-';
      i=i+2;//i指到-號后的第一個數字 
      while(IsNumber(s[i])){
          temp[++flag]=s[i];
          temp[flag+1]='\0';
          i++;
      }//如果數字過后的符號不是右括號，類似1 
      if(s[i]!=')'){
          Push("(",s_center);
          Push(temp,s_center);
        s=s+i;
        handleString(s,s_center); 
      }else{//等於右括號，類似2 
        Push(temp,s_center);
        i++;
        s=s+i;
        handleString(s,s_center); 
        }
   } 
   //如果字符串的開頭是是數字，就將這一串數字壓棧，並將數字后的第一個操作符壓棧 
     else//else不能少，這里是為了在一次調用此函數時只能執行一次操作，他們是互斥關系 
     if(IsNumber(s[i])){
       flag=-1;
       while(IsNumber(s[i])){
          temp[++flag]=s[i];
          temp[flag+1]='\0';
          i++;
       }
       Push(temp,s_center);
       s=s+i;
       handleString(s,s_center); 
    }
    else
    if(!IsNumber(s[0])) {
         temp[0]=s[0];
         temp[1]='\0';
         Push(temp,s_center);
         handleString(s+1,s_center);
    }
}
int Max(int a,int b){
    return a>b?a:b;
} 
void turnInto(Stack A,Stack B){
    Stack s_temp=CreateStack(15);
    int i;int max;int leftbracketPosition;
    for(i=0;i<=A->TopOfStack;i++){
      //printStack(s_temp);printf("\n");
      //如果不是操作符，直接輸出到后綴表達式 
      if(!IsOperator(A->Array[i])){
        strcpy(B->Array[++B->TopOfStack],A->Array[i]);
        //printf("輸出中存的有:%s\n",A->Array[i]);
      }else{
        char c=A->Array[i][0];
        //printf("\n操作的字符是第%d個%c\n",i+1,A->Array[i][0]); 
        switch(c){
          case '(':{
                      Push(A->Array[i],s_temp);
                      break;
                   }
          case ')':{
                      while(!strcmp( "(",Top(s_temp) )==0){
                        strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));
                      }
                      Pop(s_temp);
                      break;
                   }
          case '+':
          case '-':{
                      if(exist("(",s_temp)){//如果存在左括號，將左括號右側全部運算符彈出 
                        while(Top(s_temp)[0]!='('){
                          strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));
                        }
                      Push(A->Array[i],s_temp);          
                      }else{//如果不存在左括號，將棧中所有元素彈出 
                        while(!IsEmpty(s_temp)){
                          strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));    
                        }
                      Push(A->Array[i],s_temp);        
                      }
                      break;
                   }
          case '*':
          case '/':{
                      if(IsEmpty(s_temp)){
                          Push(A->Array[i],s_temp);
                      }
                      else{
                        if(exist("(",s_temp)){
                          leftbracketPosition=LastPosition("(",s_temp);
                          if(exist("/",s_temp)||exist("*",s_temp)){
                            max=Max(LastPosition("/",s_temp),LastPosition("*",s_temp));
                          if(max>leftbracketPosition){//表明符號在左括號右側 
                            while(Top(s_temp)[0]!='*' || Top(s_temp)[0]!='/'){
                              strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );      
                            }
                            strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));
                            Push(A->Array[i],s_temp);
                          }else{//符號在左括號左側 
                            Push(A->Array[i],s_temp); 
                          }    
                        }else{//存在左括號，但既不存在乘號也不存在除號，判斷此時有沒有乘方號 
                        //如果有乘方號，且乘方號在左括號右側 
                          if(exist("^",s_temp)&&(LastPosition("^",s_temp)>leftbracketPosition)){
                            strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );
                            Push(A->Array[i],s_temp);       
                          }else{//不存在乘方號或者存在乘方號，但乘方號在左括號的左側 
                            Push(A->Array[i],s_temp);
                          }        
                        }    
                        }else{//不存在左括號時，只要臨時棧中有乘號或除號就不可能再有乘方號 
                          if(exist("*",s_temp)||exist("/",s_temp)){
                            while(Top(s_temp)[0]!='*'&&Top(s_temp)[0]!='/'){
                            strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );
                            }
                            strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));
                            Push(A->Array[i],s_temp);    
                          }else{//表示既沒有左括號也沒有乘號或除號，此時考慮棧中有沒有乘方號 
                            if(exist("^",s_temp)){//如果有乘方號，肯定在棧頂 
                              strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );
                              Push(A->Array[i],s_temp);       
                            }else{
                              Push(A->Array[i],s_temp);    
                            } 
                          }//不存在*或/的結束 
                        }//不存在左括號的結束 
                      }    
                      break;
                    }
          case '^':{
                      if(IsEmpty(s_temp)){
                           Push(A->Array[i],s_temp);
                      }else{                          
                      //最高優先級，但臨時棧中有可能還有乘方號，要把臨時棧中與當前操作符有相同優先級的並在左括號的右邊的符號彈出 
                      if(!exist("^",s_temp)){
                        strcpy(s_temp->Array[++s_temp->TopOfStack],A->Array[i]);
                        break;    
                      }else{
                        if(exist("(",s_temp)&& ( LastPosition("(",s_temp)<LastPosition("^",s_temp) ) ){
                            while(Top(s_temp)[0]!='^'){
                              //printf("%s",Top(temp));
                              strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );
                              //printf("輸出中存的有:%s\n",A->Array[i]);
                            }
                            strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));
                            //printf("輸出中存的有:%s\n",B->Array[B->TopOfStack]);
                            Push(A->Array[i],s_temp);
                            //printStack(temp); 
                        }else{//包括不存在左括號和存在左括號且左括號在^右邊的情況 
                           if(!exist("(",s_temp)){
                             strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );
                             Push(A->Array[i],s_temp);           
                           }else 
                             strcpy(s_temp->Array[++s_temp->TopOfStack],A->Array[i]);    
                           }    
                        }     
                     } 
                     break;             
                  }
          default:printf("未知錯誤\n");    
        }//switch語句的結束        
      }//如果是操作符的結束 
    }//for循環結束 
    while(!IsEmpty(s_temp)){
        strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp)); 
    }    
}
//利用斐波那契數快速求冪 
unsigned long FB_QiuMi(int x,int n){
    if(n<=2){
        //printf("不用求冪公式！\n");
        switch(n){
            case 1:return x;
            case 2:return x*x;
        }
    }
    //記錄斐波那契數列的下標 
    int N=0;    
    int f=1;
    int temp;
    int flag=f+1; 
    while(flag<=n){
        temp=flag;
        flag=flag+f;
        f=temp;
        N++; 
    }
    int less=n-temp;
    int i;
    unsigned long result=x;
    flag=x;
    for(i=0;i<N;i++){
        temp=result;
        result=result*flag;
        flag=temp;
    } 
    while(less>0){
        result=result*x;
        less--;
    }
    return result;
}
/******后添加的模塊*****/ 
struct treeNode{
    char element[5];
    struct treeNode *left;
    struct treeNode *right; 
};
typedef struct treeNode *TreePtr; 
typedef TreePtr Tree;//樹的一個結點 
struct TreeStackNode{
    TreePtr Element;//此棧中的元素用來存指向樹結點的指針 
    struct TreeStackNode *Next;
};
typedef struct TreeStackNode *TreeStackPtr; 
typedef TreeStackPtr TreeStack;
TreeStack createTreeStack(){
    TreeStack treestack=malloc(sizeof(struct TreeStackNode));
    treestack->Next=NULL;
    return treestack;
}
//將樹結點的指針壓入棧中 
void Tree_Push(TreeStack tree_stack,TreePtr treePtr){
     TreeStackPtr temp=malloc(sizeof(struct TreeStackNode));
    temp->Element=treePtr;
    //AA:printf("%s",treePtr->element);printf("左子樹是否為空:%d\n",treePtr->left==NULL);
    temp->Next=tree_stack->Next;
    tree_stack->Next=temp;
} 
TreeStackPtr Tree_PopandTop(TreeStack tree_stack){
    if(tree_stack->Next==NULL){
        printf("棧為空"); 
        return NULL; 
    }
    TreeStackPtr temp=tree_stack->Next;
    tree_stack->Next=tree_stack->Next->Next;
    return temp;    
}
void makeTree(Stack s_later,TreeStack treestack){
    int i;
    TreePtr tempTreeNode=NULL; 
    for(i=0;i<=s_later->TopOfStack;i++){
        //如果后綴表達式的元素不為操作符，就新建樹結點，並將樹結點的指針壓入指針棧中
        if(!IsOperator(s_later->Array[i])){
            tempTreeNode=malloc(sizeof(struct treeNode));
            tempTreeNode->left=NULL;tempTreeNode->right=NULL;
            strcpy(tempTreeNode->element,s_later->Array[i]);
            //BB:printf("進棧1個元素"); printf("%s\n",tempTreeNode->element); 
            //AA:printf("%s %d\n",tempTreeNode->element,tempTreeNode->left==NULL); 
            Tree_Push(treestack,tempTreeNode);
        }else{
            tempTreeNode=malloc(sizeof(struct treeNode));
            strcpy(tempTreeNode->element,s_later->Array[i]);
            tempTreeNode->right=Tree_PopandTop(treestack)->Element;
            tempTreeNode->left=Tree_PopandTop(treestack)->Element;
            //BB:printf("進棧1個元素"); printf("%s\n",tempTreeNode->element);
            //AA:printf("%s %d\n",tempTreeNode->element,tempTreeNode->left==NULL);     
            Tree_Push(treestack,tempTreeNode);
            //BB:printf("出棧2個元素"); printf("進棧1個元素"); 
        }
    }
}
void Traverl_Center(Tree tree){
    if(tree->left!=NULL){
        Traverl_Center(tree->left);    
    }
    printf(" %s",tree->element);
    if(tree->right!=NULL){
        Traverl_Center(tree->right);    
    }    
}
void Taverl_Later(Tree tree){
    if(tree->left!=NULL){
        Taverl_Later(tree->left);    
    }
    if(tree->right!=NULL){
        Taverl_Later(tree->right);    
    }
    printf(" %s",tree->element);        
}
int main(){
    printf("請輸入一個中綴表達式:");
    printf("(最多40個字符的字符串，可以包含任意整數，+，-，*，/，^和（）兩個括號！)\n");
    Stack s_center=CreateStack(35);
    Stack s_later=CreateStack(35); 
    char x[40];
    gets(x);
    char *p=x;
    handleString(p,s_center);
    printf("此中綴表達式為:"); 
    printStack(s_center);
    //將中綴表達式轉化為后綴表達式 
    turnInto(s_center,s_later);
    printf("\n這個后綴表達式是:");
    printStack(s_later);printf("\n");
    TreeStack treestack=createTreeStack();
    //構造表達式樹
    makeTree(s_later,treestack);
    Tree tree=Tree_PopandTop(treestack)->Element; 
    //中序遍歷和后序遍歷樹
    printf("------------------------------樹形結構下的輸出------------------------------\n");
    printf("此中綴表達式為:"); Traverl_Center(tree);
    printf("\n這個后綴表達式是:");printf("\b");Taverl_Later(tree);printf("\n");
    return 0;
}