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

谢谢关注。