一般情況下,我們使用連結串列無非就是在連結串列結點中儲存該連結串列中下一個元素的指標.如果為了刪除方便,可能需要儲存前一個元素的指標,也就是雙向連結串列,這樣在刪除一個結點的時候就可以很快的定位到前面和後面的結點,並且改變它們相應的指向.在這些操作裡面,指向連結串列元素的指標無疑是最關鍵的資料.

考慮這樣一個問題,如果兩個程序進行通訊,A程序負責管理連結串列,B程序向A程序發出分配或者刪除連結串列元素的請求.這種情況下,像上面所描述的那樣A程序直接向B程序返回連結串列元素的指標是不能做到的了,很自然的,可以想到返回另一個key標示該連結串列元素.但是,當需要查詢或者刪除該連結串列元素的時候,就不能像上面那樣馬上定位到連結串列元素的位置了,需要遍歷整個連結串列.原來常量級時間複雜度的演算法,在使用情形變換了之後變成了O(n)級別的複雜度.

可以找到別的辦法來解決這個問題.第一可以返回一個key標示該連結串列元素,第二保證了時間的複雜度,在這裡需要定義一種新的資料結構和演算法來解決這個問題.

首先,我們使用一個數組,陣列中的元素是指向連結串列元素的指標,而指標的索引則是每個連結串列元素的id,這樣,通過id就可以馬上定位到對應的連結串列元素.
但是這裡又會出現另一個問題,該id是從零開始的,假如在一段時間之後,需要分配一個新的連結串列元素,如何知道陣列中的哪個位置是可以分配的?在這裡,使用了一個整型資料的陣列,陣列中的每個元素是該id對應的連結串列元素在連結串列中下一個結點的id(有點拗口).我們使用兩個連結串列頭,一個將已經使用的連結串列元素id連線起來,另一個則將未使用的連結串列元素id連線起來.於是,在程式初始化的時候,未使用的連結串列中儲存了所有的id,而已經使用的連結串列為空.每次分配了一個新的連結串列元素,將它的id放在使用連結串列的最開始;而每次釋放一個連結串列元素,將它的id放到未使用的連結串列頭部.
同時,改變原先連結串列元素的定義,在該結構體中,儲存的不再是指標,而是連結串列中前一個元素的陣列索引id.而它的下一個元素id則儲存在上面的那個陣列中.

如果上面我的解釋還不夠明白,可以看看下面的程式碼:

#include <stdio.h>#define LIST_NODE_NULL -1#define ARRAY_SIZE 200/* 連結串列元素定義 */
typedef struct list_node
{
    int prev;   /* 下一個連結串列元素在list_array中的id */
}list_node;

/* 存放連結串列元素指標的陣列 */
list_node* list_array[ARRAY_SIZE];
/* 未使用連結串列的頭結點id */int top_of_free;
/* 已使用連結串列的頭結點id */int top_of_used;
/* 儲存連結串列下一個元素結點id的連結串列 */int next_list[ARRAY_SIZE];

void init_list()
{
    int i;

    for (i =0; i < ARRAY_SIZE; ++i)
    {
        list_array[i] = NULL;
        /* 初始時,next_list中每個結點的值都是下一個id */
        next_list[i] = i +1;
    }

    /* 最後一個結點是空 */
    next_list[i -1] = LIST_NODE_NULL;

    top_of_free =0;
    top_of_used = LIST_NODE_NULL;
}

int alloc_list_node()
{
    int id;
    
    /* 從未使用連結串列頭部取出一個id */
    id = top_of_free;

    if (LIST_NODE_NULL == id)
    {
        return LIST_NODE_NULL;
    }

    /* 未使用連結串列頭結點往下走一步 */
    top_of_free = next_list[top_of_free];

    if (NULL == list_array[id])
    {
        list_array[id] = (list_node*)malloc(sizeof(list_node));
        if (NULL == list_array[id])
        {
            return LIST_NODE_NULL;
        }
    }

    if (LIST_NODE_NULL == top_of_used)
    {
        next_list[id] = top_of_used;
        top_of_used = id;
    }
    else
    {
        /* 修改prev和next */ 
        list_array[top_of_used]->prev = id;
        list_array[id]->prev = LIST_NODE_NULL;

        next_list[id] = top_of_used;
        top_of_used = id;
    }

    return id;
}

void free_list_node(int id)
{
    int prev, next;

    prev = list_array[id]->prev;
    next = next_list[id];

    /* 修改next和prev */
    if (LIST_NODE_NULL != prev)
    {
        next_list[prev] = next_list[id];
    }
    if (LIST_NODE_NULL != next && NULL != list_array[next])
    {
        list_array[next]->prev = prev;
    }

    if (id == top_of_used)
    {
        top_of_used = next_list[id];
    }

    /* 將連結串列id返回到free連結串列頭部並且修改free連結串列頭結點 */
    next_list[id] = top_of_free;
    top_of_free = id;
}

int main()
{
    int id;

    init_list();

    id = alloc_list_node();
    free_list_node(id);

    return0;
}



這個想法很巧妙,有效的避免了查詢和刪除陣列元素帶來的開銷.我不知道具體的出處在哪裡,如果您知道,勞煩告訴我一聲:)