双向循环链表（C语言描述）（三）

代码清单

// linkedlist.h
#ifndef __LINKEDLIST_H__
#define __LINKEDLIST_H__

#include <assert.h>
#include <malloc.h>
#include <string.h>

typedef int LinkedListData;

typedef struct LinkedListNode {
    LinkedListData data;

    struct LinkedListNode * prior;
    struct LinkedListNode * next;
} LinkedListNode, *LinkedList;

typedef enum {
    TRAVELDIR_FORWARD, TRAVELDIR_BACKWARD
} LinkedListTravelDir;

LinkedList linkedlist_new();
void linkedlist_destory(LinkedList *list);

void linkedlist_insert(LinkedList list, LinkedListTravelDir dir, int location,
        const LinkedListData data);
void linkedlist_delete(LinkedList list, LinkedListTravelDir dir, int location);
int linkedlist_locate(const LinkedList list, LinkedListTravelDir dir,
        const LinkedListData data, int (*fpCompare)(const void *, const void *));
LinkedListData * linkedlist_get(LinkedList list, LinkedListTravelDir dir,
        int location);
int linkedlist_length(const LinkedList list);

#endif // __LINKEDLIST_H__

// linkedlist.c
#include "linkedlist.h"

LinkedList linkedlist_new() {
    // alloc head node
    LinkedList list = malloc(sizeof(LinkedListNode));
    assert(list);

    // initialize head node's pointer field
    list->prior = list;
    list->next = list;

    return list;
}

void linkedlist_destory(LinkedList *list) {
    while (linkedlist_length(*list)) {
        linkedlist_delete(*list, TRAVELDIR_FORWARD, 1);
    }
    free (*list);
    *list = NULL;
}

void linkedlist_insert(LinkedList list, LinkedListTravelDir dir, int location,
        const LinkedListData data) {
    LinkedList pCurNode = list;
    assert(location > 0 && location <= linkedlist_length(list) + 1);

    // alloc new node
    LinkedListNode * pNode = malloc(sizeof(LinkedListNode));
    assert(pNode);
    memcpy(&(pNode->data), &data, sizeof(LinkedListData));

    // move current pointer to prior node
    if (dir == TRAVELDIR_FORWARD) {
        for (int i = 0; i < location - 1; i++, pCurNode = pCurNode->next)
            ;

    } else {
        if (dir == TRAVELDIR_BACKWARD) {
            for (int i = 0; i < location; i++, pCurNode = pCurNode->prior)
                ;
        }
    }

    // insert new node
    pNode->next = pCurNode->next;
    pNode->prior = pCurNode;
    pCurNode->next = pNode;
    pNode->next->prior = pNode;
}

void linkedlist_delete(LinkedList list, LinkedListTravelDir dir, int location) {
    LinkedList pCurNode = list;
    assert(location > 0 && location < linkedlist_length(list) + 1);

    // move current pointer to the node will deleted
    if (dir == TRAVELDIR_FORWARD) {
        for (int i = 0; i < location; i++, pCurNode = pCurNode->next)
            ;
    } else {
        if (dir == TRAVELDIR_BACKWARD) {
            for (int i = 0; i < location; i++, pCurNode = pCurNode->prior)
                ;
        }
    }

    // delete current node
    pCurNode->prior->next = pCurNode->next;
    pCurNode->next->prior = pCurNode->prior;
    free(pCurNode);
}

int linkedlist_locate(const LinkedList list, LinkedListTravelDir dir,
        const LinkedListData data, int (*fpCompare)(const void *, const void *)) {
    static int location = 0;
    static LinkedList pCurNode = NULL;

    // if list argument is NULL, continue to start locate
    if (list) {
        location = 1;
        pCurNode = list->next;
    }
    assert(location && pCurNode);

    // locate data
    while (pCurNode != list) {
        if (!fpCompare(&(pCurNode->data), &data)) {
            return location;
        }
        location++;
        if (dir == TRAVELDIR_FORWARD) {
            pCurNode = pCurNode->next;
        } else {
            if (dir == TRAVELDIR_BACKWARD) {
                pCurNode = pCurNode->prior;
            }
        }
    }

    return -1;
}

LinkedListData * linkedlist_get(LinkedList list, LinkedListTravelDir dir,
        int location) {
    LinkedList pCurNode = list;
    assert(location > 0 && location < linkedlist_length(list) + 1);

    // move pointer to the node wanna get
    if (dir == TRAVELDIR_FORWARD) {
        for (int i = 0; i < location; i++, pCurNode = pCurNode->next)
            ;
    } else {
        if (dir == TRAVELDIR_BACKWARD) {
            for (int i = 0; i < location; i++, pCurNode = pCurNode->prior)
                ;
        }
    }

    return &(pCurNode->data);
}

int linkedlist_length(const LinkedList list) {
    int length = 0;
    assert(list);
    LinkedList pCurNode = list->next;

    while (pCurNode != list) {
        length++;
        pCurNode = pCurNode->next;
    }

    return length;
}