C語言數組形雙向連結清單的處理

指針形連結清單的試用已經非常友善，可以帶參數結點，但在某些情況下，還會用到數組形連結清單，是以做以總結，具體如下：

alist.h

//
// Created by helios on 2019/1/27.
//

#ifndef ALIST_H
#define ALIST_H

#include <stdint.h>

#define LIST_NULL   0xFFFF
typedef uint16_t ALIST_SUB;      //LIST SUBSCRIPT

typedef struct {
    ALIST_SUB next;
    ALIST_SUB prev;
} ALIST_NODE;

/**
 * 初始化node結點
 * @param list
 * @param node
 */
void alist_node_init(ALIST_NODE *list, ALIST_SUB node);

/**
 * 将node結點插入到head位置，并将插入結點的位置當作新的head位置傳回
 * @param list 連結清單
 * @param head 頭結點位置
 * @param node 插入結點位置
 * @return 新的head位置
 */
ALIST_SUB alist_add_to_head(ALIST_NODE *list, ALIST_SUB head, ALIST_SUB node);

/**
 * 将head位置的結點删除，并傳回新的head位置
 * @param list
 * @param head
 * @return 新的head位置
 */
ALIST_SUB alist_del_from_head(ALIST_NODE *list, ALIST_SUB head);

/**
 * 将node結點插入到tail位置，并将插入結點的位置當作新的tail位置傳回
 * @param list
 * @param tail
 * @param node
 * @return 新的tail位置
 */
ALIST_SUB alist_add_to_tail(ALIST_NODE *list, ALIST_SUB tail, ALIST_SUB node);

/**
 * 将tail位置的結點删除，并傳回新的tail位置
 * @param list
 * @param tail
 * @return
 */
ALIST_SUB alist_del_from_tail(ALIST_NODE *list, ALIST_SUB tail);

/**
 * 将node結點插入到curr位置後面，并将插入結點的位置當作新的curr位置傳回
 * @param list
 * @param curr
 * @param node
 * @return 新的curr位置
 */
ALIST_SUB alist_add_after_curr(ALIST_NODE *list, ALIST_SUB curr, ALIST_SUB node);

/**
 * 将node結點插入到curr位置前面，并将插入結點的位置當作新的curr位置傳回
 * @param list
 * @param curr
 * @param node
 * @return 新的curr位置
 */
ALIST_SUB alist_add_before_curr(ALIST_NODE *list, ALIST_SUB curr, ALIST_SUB node);

/**
 * 将curr位置的結點删除，并将curr位置後的結點位置當作新的curr位置傳回
 * @param list
 * @param curr
 * @return
 */
ALIST_SUB alist_del_curr_go_after(ALIST_NODE *list, ALIST_SUB curr);

/**
 * 将curr位置的結點删除，并将curr位置前的結點位置當作新的curr位置傳回
 * @param list
 * @param curr
 * @return
 */
ALIST_SUB alist_del_curr_go_before(ALIST_NODE *list, ALIST_SUB curr);

#define IS_ALIST_NULL(head, tail)                   (head == tail)
#define IS_ALIST_HEAD_NODE(head, node)              (head == node)
#define IS_ALIST_TAIL_NODE(tail, node)              (tail == node)

#define ALIST_NODE_INIT(list, node)                 do{alist_node_init(list, node);}while(0)

#define ALIST_ADD_TO_HEAD(list, head, node)         do{head = alist_add_to_head(list, head, node);}while(0)
#define ALIST_DEL_FROM_HEAD(list, head, node)       do{node = head; head = alist_del_from_head(list, head);}while(0)

#define ALIST_ADD_TO_TAIL(list, tail, node)         do{tail = alist_add_to_tail(list, tail, node);}while(0)
#define ALIST_DEL_FROM_TAIL(list, tail, node)       do{node = tail; tail = alist_del_from_tail(list, tail);}while(0)

#define ALIST_ADD_AFTER_CURR(list, curr, node)      do{curr = alist_add_after_curr(list, curr, node);}while(0)
#define ALIST_ADD_BEFORE_CURR(list, curr, node)     do{curr = alist_add_before_curr(list, curr, node);}while(0)

#define ALIST_DEL_CURR_GO_AFTER(list, curr, node)   do{node = curr; curr = alist_del_curr_go_after(list, curr);}while(0)
#define ALIST_DEL_CURR_GO_BEFORE(list, curr, node)  do{node = curr; curr = alist_del_curr_go_before(list, curr);}while(0)

#endif //ALIST_H
           

alist.c

//
// Created by helios on 2019/1/27.
//

#include "alist.h"

void alist_node_init(ALIST_NODE *list, ALIST_SUB node) {
    list[node].next = LIST_NULL;
    list[node].prev = LIST_NULL;
}

ALIST_SUB alist_add_to_head(ALIST_NODE *list, ALIST_SUB head, ALIST_SUB node) {
    list[node].next = head;
    list[node].prev = LIST_NULL;
    list[head].prev = node;
    return node;
}

ALIST_SUB alist_del_from_head(ALIST_NODE *list, ALIST_SUB head) {
    head = list[head].next;
    list[head].prev = LIST_NULL;
    return head;
}

ALIST_SUB alist_add_to_tail(ALIST_NODE *list, ALIST_SUB tail, ALIST_SUB node) {
    list[node].next = LIST_NULL;
    list[node].prev = tail;
    list[tail].next = node;
    return node;
}

ALIST_SUB alist_del_from_tail(ALIST_NODE *list, ALIST_SUB tail) {
    tail = list[tail].prev;
    list[tail].next = LIST_NULL;
    return tail;
}

ALIST_SUB alist_add_after_curr(ALIST_NODE *list, ALIST_SUB curr, ALIST_SUB node) {
    list[node].next = list[curr].next;
    list[node].prev = curr;
    list[list[curr].next].prev = node;
    list[curr].next = node;
    return node;
}

ALIST_SUB alist_add_before_curr(ALIST_NODE *list, ALIST_SUB curr, ALIST_SUB node) {
    list[node].next = curr;
    list[node].prev = list[curr].prev;
    list[list[curr].prev].next = node;
    list[curr].prev = node;
    return node;
}

ALIST_SUB alist_del_curr_go_after(ALIST_NODE *list, ALIST_SUB curr) {
    list[list[curr].prev].next = list[curr].next;
    list[list[curr].next].prev = list[curr].prev;
    return list[curr].next;
}

ALIST_SUB alist_del_curr_go_before(ALIST_NODE *list, ALIST_SUB curr) {
    list[list[curr].prev].next = list[curr].next;
    list[list[curr].next].prev = list[curr].prev;
    return list[curr].prev;
}
           

目前試用正常，如有錯誤，請回複指出，謝謝。

原文出自：https://blog.csdn.net/u011833609/article/details/86669616      

謝謝關注。