PostgreSQL的FSM檔案,其資料結構基礎是最大堆二叉樹,構建/刪除/插入的相關程式碼詳見程式碼註釋.

```C

#include "heap.h"

static int heap[MAX_ELEMENTS];
static int counter = 0;

//交換資料
static void swap(int *i,int *j)
{ 
  int tmp = *j;
  *j = *i;
  *i = tmp;
}

//列印堆資訊
//n : 元素個數
void print_max_heap()
{
  for(int i = 1;i <= counter;i++)
  {
     printf("item[%d] is %d\n",i,heap[i]);
  }
}

//初始化堆陣列
void init_heap(int *array,int n)
{
  for(int i=0;i < n;i++)
  {
    heap[i] = array[i];
  }
  counter = n;
}

//插入到最大堆
//item : 插入的值
//*n : 堆元素個數
void insert_max_heap(int item)
{
    if(HEAP_FULL(counter)){
      return;
    }
    //整個演算法思想是首先把插入的值放在堆中的最後一個位置,然後為其找到合適的位置(遞迴向上)
    int i = ++counter;
    //i ≠ 1是因為陣列的第一個元素並沒有儲存堆結點
    for(;(i != 1) && (item > heap[i/2]);i = i / 2){
      //如果插入的值比其父節點要大,把父節點的值互動到當前節點
      heap[i] = heap[i/2];//這裡其實和遞迴操作類似，就是去找父結點
    }
    //父節點的值比當前值要大或者已到達根節點,設定當前位置的值為要插入的值
    heap[i] = item;
}

//刪除最大堆中的元素
//*n : 堆元素個數
void delete_max_heap()
{
  //刪除最大堆,總是刪除最大堆的根節點
  if(HEAP_EMPTY(counter))
  {
     return;
  }
  //演算法思想 : 把最後一個元素作為根節點,然後尋找該節點在樹中合適的位置
  int lastone = heap[--counter];
  //父節點,初始化為1
  int parent = 1;
  for (int son=parent*2;son <= counter;son=son*2)
  {
    //刪除父節點後,比較左右子節點的大小
    if(son < counter && heap[son] < heap[son+1])
    {
      //如果右子節點大於左子節點,切換到右子節點
      son++;
    }
    if (lastone > heap[son])
    {
      break;//已經比兒子要大,退出
    }
    //把子節點移到父節點
    //parent的位置就是lastone移動到的位置
    heap[parent]=heap[son];
    //遞迴,到下一層子樹
    parent = son;
  }
  //parent的位置就是最後一個元素所在的位置
  heap[parent]=lastone;//lastone的實際位置已找到,賦值
}

//構建最大堆
//n : 元素個數
//heap是初始化但未構建的陣列
void build_max_heap()
{
  for(int i = counter;i > 1;i--)
  {
    //從最後一個元素(最下層)開始遍歷陣列
    if(heap[i] > heap[i/2])
    {
      //子節點比父節點要大,交換父子節點
      swap(&(heap[i/2]),&(heap[i]));
      for(int j=i*2;j < counter;j=j*2)
      {
        //遞迴處理子節點
        if (j > counter)
        {
          break;
        }
        if(j < counter && heap[j+1] > heap[j])
        {
          //切換至右子節點
          j++;
        }
        if (heap[j] > heap[j/2])
        {
          //如果子節點大於父節點,交換
          swap(&(heap[j/2]),&(heap[j]));
        }
      }//end for#2
    }//end if
  }//end for#1
}

void build_max_heap_new()
{
  for(int i = counter/2;i > 1;i--)
  {
    //從子節點上一層開始處理
    //父節點為i
    int parent=i;
    //該節點的值
    int temp=heap[parent];
    for(int child=parent*2;child <=counter;child=child*2)
    {
      //
      if(child < counter && heap[child] < heap[child+1])
      {
        //切換到右子節點
        child++;
      }
      if(temp > heap[child])
        //父節點比子節點大,退出該父節點構成的樹迴圈
        break;
      else
      {
        //把子節點的值放到父節點中
        heap[parent] = heap[child];
      }
      //進入到子節點,遞迴處理
      parent = child;
    }
    //已找到該父節點合適的位置,賦值
    heap[parent]=temp;
  }//end for#1
}

```

資料庫實現原理#5（FSM：最大堆二叉樹）

相關文章