数据结构_练习_双向链表

数据结构_练习_双向链表

#include <iostream>
#include "预定义.h"

//此处用于修改ElemType的值
typedef int ElemType;

typedef struct DuLNode
{
    ElemType data;
    struct DuLNode* prior;
    struct DuLNode* next;
} DuLNode, * DuLinKList;


//双向链表的初始化
Status InintDuList(DuLinKList &duL);

//链表的销毁
Status DestroyDuL(DuLinKList &duL);

//双向链表, 目标节点后插入新节点
Status DuListInsert(DuLinKList &duL, int i, ElemType e);

//双向链表, 目标节点前插入新节点
Status LinkInsert_DuL(DuLinKList &L, int i, ElemType e);

//链表单个节点的销毁
Status LinkDelet_DuL(DuLinKList &L, int i, ElemType &e);

//打印链表, 遍历单链表
Status PrintLinkList(DuLinKList duL);

int main()
{
    DuLinKList duL = NULL;
    if (!InintDuList(duL))
    {
        printf_s("初始化未成功\n");
        return -1;
    }
    FILE* fp = NULL;
    fopen_s(&fp, "test.txt","r");
    ElemType e;
    int E;
    printf_s("请输入你想添加的数字个数的数字: \n");
    scanf_s("%d", &e);
    getchar();

    if (!DuListInsert(duL, 1, e))
    {
        printf_s("未成功添加新元素\n");
        return -1;
    }
//    if (!DuListHeadInsert(duL, e))
//    {
//        printf_s("未成功添加新元素\n");
//        return -1;
//    }

    if (PrintLinkList(duL))
        return 1;
    else
        return -3;
}

//双向链表的初始化
Status InintDuList(DuLinKList &duL)
{
    duL = (DuLinKList) malloc(sizeof(DuLNode));
    if (!duL)
        return 0;
    duL->prior = NULL, duL->next = NULL;
    return 1;
}

//获取目标数据节点的位置, 在链表不为空的情况下
DuLinKList GetElemP_DuL(DuLinKList L, int i)
{
    DuLinKList p = L->next;
    int j = 1;
    while (p && j < i)
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
        return NULL;
    return p;
}

//双向链表, 目标节点后插入新节点
Status DuListInsert(DuLinKList &duL, int i, ElemType e)
{
    if (!duL)
        return ERROR;
    DuLinKList p = duL;
    int j = 0;
    while (p && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (!p || j > i - 1)
        return ERROR;
    DuLinKList s;
    if (!(s = (DuLinKList) malloc(sizeof(DuLNode))))
        return ERROR;
    s->data = e;
    s->next = s->prior = NULL;

    s->next = p->next;
    s->prior = p;
    p->next = s;
    if (s->next)  //此处要特别注意: 因为可能在最后一个节点后面添加新节点, 所以要判断是否为NULL
        s->next->prior = s;
    return TRUE;
}

//双向链表, 目标节点前插入新节点
Status LinkInsert_DuL(DuLinKList &L, int i, ElemType e)
{
    if (!L)
        return ERROR;
    DuLinKList p;
    if (!(p = GetElemP_DuL(L, i)))
        return ERROR;
    DuLinKList s;
    if (!(s = (DuLinKList) malloc(sizeof(DuLNode))))
        return ERROR;
    s->data = e;
    //注意: 此处应有四组指针地址变换交换.
    s->prior = p->prior;
    p->prior->next = s;
    s->next = p;
    p->prior = s;
    return OK;
}

//打印链表
Status PrintLinkList(DuLinKList duL)
{
    if (!duL)
        return ERROR;
    DuLinKList p = duL->next;
    while (p)
    {
        printf_s("%d\n", p->data);
        p = p->next;
    }
    return TRUE;
}

//链表的销毁
Status DestroyDuL(DuLinKList &duL)
{
    if (!duL)
        return ERROR;
    DuLinKList p = duL;
    while (p)
    {
        DuLinKList q = p->next;
        free(p);
        p = q;
    }
    duL = NULL;
    return TRUE;
}

//链表的头插入
Status DuListHeadInsert(DuLinKList &duL, ElemType e)
{
    if (!duL)
        return ERROR;
    DuLinKList p = (DuLinKList) malloc(sizeof(DuLNode));
    p->data = e;
    p->prior = p->next = NULL;

    p->prior = duL, p->next = duL->next;
    duL->next = p;
    if (p->next)  //判断p的下一节点是否为空
        p->next->prior = p;
    return TRUE;
}

//链表的头删除
Status DuListHeadDelete(DuLinKList &duL, ElemType &e)
{
    if (!duL || !duL->next)
        return ERROR;
    DuLinKList p = duL->next;
    e = p->data;

    if (!p->next)
        duL->next = NULL;
    duL->next = p->next;
    p->next->prior = duL;
    free(p);
    return TRUE;

}

//链表单个节点的销毁
Status LinkDelet_DuL(DuLinKList &L, int i, ElemType &e)
{
    DuLinKList p;
    if (!(p = GetElemP_DuL(L, i)))
        return ERROR;
    e = p->data;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    free(p);
    return OK;
}