数据结构 - 双链表基本操作 - C语言

• 数据结构 - 双链表基本操作 - C++
• • • 1. 结构
    • 2. 初始化
    • • 2.1 判空
    • 3. 插入
    • • 3.1 后插
      • 3.2 前插
    • 4. 删除
    • • 4.1 删除结点
      • 4.2 销毁链表
    • 5. 遍历
    • • 5.1 后向遍历
      • 5.2 前向遍历
      • • 不跳过头结点
        • 跳过头结点
    • 6. 查找
    • • 6.1 按值查找
      • 6.2 按位查找

参考 王道考研数据结构

本程序使用带头结点的双链表，头结点不存储数据

typedef struct DNode {				// 定义双链表结点类型
    ElemType data;					// 数据域
    struct DNode *prior, *next;		// 前驱和后继指针
} DNode, *Dlinklist;

Dlinklist <=等价=> DNode *

bool InitDlinklist(Dlinklist &L) {
    L = (DNode *) malloc(sizeof(DNode));	// 分配一个头结点
    if (L==NULL)							// 内存不足，分配失败
        return false;
    L->prior = NULL;						// 头结点的prior永远指向NULL
    L->next = NULL;							// 头结点之后暂时还没有结点
    return true;
}

// 带头结点的双链表
bool Empty(Dlinklist L) {
	if (L->next == NULL)
        return true;
    else
        return false;
}

// p结点后插入s结点
bool InsertNextDNode(DNode *p, DNode *s) {
    if (p == NULL || s == NULL) // 非法参数
        return false;
    s->next = p->next; // 1
    if (p->next != NULL) // 注意！p结点可能没有后继节点
        p->next->prior = s; // 2
    s->prior = p; // 3
    p->next = s; // 4 1,2两步必须在4步之前
    return true;
}

p结点前驱后插

// p结点前插入s结点（假设p结点的前驱结点是q结点）
bool InsertPriorDNode(DNode *p, DNode *s) {
	if (p == NULL || s == NULL) // 非法参数
        return false;
    if (p->prior != NULL)
        return InsertNextDNode(p->prior, s); // 调用后插
    return InsertNextDNode(p, s); // p->prior为空说明是p头结点，这时要插入到头结点之后
}

// 删除p结点的后继结点
bool DeleteNextDNode(DNode *p) {
	if (p == NULL) return false;
    DNode *q = p->next; // 获得要删除的结点
    if (q == NULL) return false; // p没有后继
    p->next = q->next; // 绿线
    if (q->next != NULL) // 若q结点有后继
    	q->next->prior = p; // 黄线
    free(q); // 释放空间
    return true;
}

void DestroyList(Dlinklist &L) {
    // 循环释放各结点
    while (L->next != NULL)
        DeleteNextDNode(L);
    free(L); // 释放头结点
    L=NULL; // 头指针指向NULL
}

while (p != NULL) {
    // Operations...
    p = p->next; // 后继结点
}

while (p != NULL) {
    // Operations...
    p = p->prior; // 前驱节点
}

while (p->prior != NULL) { // p->prior == NULL 说明p指向了头结点
    // Operations...
    p = p->prior; // 前驱节点
}

双链表不可随机存取，按位查找、按值查找都只能遍历，时间复杂度O(n)

DNode *GetElemByValue(Dlinklist &L, ElemType item) {
    DNode *p = L->next;
    while (p != NULL) {
        if (p->data == item) {
            return p;
        }
        p = p->next;
    }
    return NULL;
}

DNode *GetElemByIndex(Dlinklist &L, int index) {
    // 下标从1开始，index == 0返回头结点
    DNode *p = L;
    while (index--) { // 每减1，相当于计数1，p指针前移1
        p = p->next;
        if (p == NULL) {
            return NULL; // 下标超过链表长度
        }
    }
    return p;
}