静态链表的表示和实现

// 2014年4月15日
// 静态链表的表示和实现
// 改进的地方：用头结点来存储链表长度
// 第一个元素存储空闲链表的头结点，data中保存链表长度
// 最后一个元素存储工作链表的头结点，data中保存链表长度
//

// 存储格式
//
//    node0        node1        node2           node.
// [data|next]  [data|next]  [data|next] ... [data|next]
//  free list                                  work list
//


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>


#define MAX_SIZE 10

typedef int element_t;

typedef struct node_t
{
    element_t   data;
    int         next;
} node_t, list_t[MAX_SIZE];


void list_init(list_t& list)
{
    assert(MAX_SIZE > 2);

    for (int i=0; i < MAX_SIZE-2; ++i)
    {
        list[i].next = i + 1;
    }
    list[MAX_SIZE-2].next = 0;  // 空闲链表结束标志
    list[MAX_SIZE-1].next = 0;  // 工作链表结束标志

    list[0].data = MAX_SIZE-2;  // 空闲链表长度
    list[MAX_SIZE-1].data = 0;  // 工作链表长度
}

void list_clear(list_t& list)
{
    int i=0;
    int j=0;
    int k=0;

    i = list[MAX_SIZE-1].next;   // 工作链表第一个结点的位置
    list[MAX_SIZE-1].next = 0;

    k = list[0].next; // 空闲链表第一个结点的位置
    list[0].next = i;

    while (i != 0)
    {
        j = i;
        i = list[i].next;
    }
    list[j].next = 0;
}

int Malloc(list_t& list)
{
    int i = list[0].next;
    if (i != 0) // 有空闲节点
    {
        list[0].next = list[i].next; // 指向下一个空闲节点

        --list[0].data; // 更新链表长度
        ++list[MAX_SIZE-1].data;
    }

    return i;
}

void Free(list_t& list, int i)
{
    list[i].next = list[0].next; // 把当前节点放入到空闲链表
    list[0].next = i;

    ++list[0].data; // 更新链表长度
    --list[MAX_SIZE-1].data;
}

int list_length(list_t& list)
{
    return list[MAX_SIZE-1].data;
}

bool list_insert(list_t& list, int n, element_t e)
{
    if ((n < 1) || (n > list_length(list)+1))
    {
        return false;
    }

    int j = Malloc(list);
    if (0 == j)
    {
        return false;
    }

    list[j].data = e;

    int k = MAX_SIZE-1;     // 从头结点开始找前驱节点
    for (int i=1; i<n; ++i)
    {
        k = list[k].next;
    }

    list[j].next = list[k].next;
    list[k].next = j;

    return true;
}

bool list_delete(list_t& list, int i, element_t *e)
{
    if ((i < 1) || (i > list_length(list)))
    {
        return false;
    }

    int k = MAX_SIZE-1;     // 从头结点开始找前驱节点
    for (int n=1; n < i-1; ++n)
    {
        k = list[k].next;
    }

    int j = list[k].next;
    list[k].next = list[j].next;

    if (e != 0)
    {
        *e = list[j].data;
    }

    Free(list, j);

    return true;
}

bool list_is_full(list_t& list)
{
    return (MAX_SIZE-2) == list_length(list);
}

bool list_is_empty(list_t& list)
{
    return 0 == list_length(list);
}

void print(list_t& list)
{
    for (int i = list[MAX_SIZE-1].next; i != 0; i = list[i].next)
    {
        printf("%02d ", list[i].data);
    }
    printf("\n");
}

int range(int a, int b)
{
    assert(a>0);
    assert(b>0);
    return rand()%b + a;
}


int main()
{
    int n = 10;

    srand((unsigned)time(0));

    while (n--)
    {
        printf("n: %d\n", n);

        list_t list;

        list_init(list);

        int a = range(1, MAX_SIZE-2);
        while (a--)
        {
            int i = range(1, 10);
            int j = range(1, 10);
            if (!list_insert(list, i, j))
            {
                if (list_is_full(list))
                {
                    break;
                }

                ++a;
                continue;
            }

            print(list);
        }

        int b = range(1, MAX_SIZE-2);
        while (b--)
        {
            int i = range(1, 10);
            if (!list_delete(list, i, 0))
            {
                if (list_is_empty(list))
                {
                    break;
                }

                ++b;
                continue;
            }

            print(list);
        }

        list_clear(list);
    }

    return 0;
}