有序的双链表

根据data大小排序(递增):

删除all + 删除1 + 添加1 + 打印all

// 双链表 -> 有序双链表(递增)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

typedef enum{
    FALSE = 0,
    TRUE = 1,
}STATUS;

typedef struct _DOUBLE_LINK_NODE
{
    int addr;
    struct _DOUBLE_LINK_NODE* prev;
    struct _DOUBLE_LINK_NODE* next;
}DOUBLE_LINK_NODE;

//1. 删除双向链表
void delete_all_double_link_node(DOUBLE_LINK_NODE** pDLinkNode);
//2. 双向链表中插入数据
STATUS insert_data_into_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int addr);
//3. 双向链表中删除数据
STATUS delete_data_from_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int addr);
//4. 统计双向链表中数据的个数
int count_number_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode);
//5. 打印双向链表中数据
void print_double_link_node(const DOUBLE_LINK_NODE* pDLinkNode);

DOUBLE_LINK_NODE* mb_poll_link;
int main()
{
    print_double_link_node(mb_poll_link);
    insert_data_into_double_link(&mb_poll_link, 11);
    insert_data_into_double_link(&mb_poll_link, 66);
    insert_data_into_double_link(&mb_poll_link, 22);
    insert_data_into_double_link(&mb_poll_link, 33);
    insert_data_into_double_link(&mb_poll_link, 55);
    insert_data_into_double_link(&mb_poll_link, 44);
    insert_data_into_double_link(&mb_poll_link, 77);
    delete_data_from_double_link(&mb_poll_link, 77);
    print_double_link_node(mb_poll_link);
    printf("main end!\n");
    return 0;
}

//static //创建双向链表节点
DOUBLE_LINK_NODE* create_double_link_node(int value) {
    DOUBLE_LINK_NODE* pDLinkNode = NULL;
    pDLinkNode = (DOUBLE_LINK_NODE*)malloc(sizeof(DOUBLE_LINK_NODE));
    assert(NULL != pDLinkNode);

    memset(pDLinkNode, 0, sizeof(DOUBLE_LINK_NODE));
    pDLinkNode->addr = value;
    return pDLinkNode;
}

// static //在双向链表中查找数据
DOUBLE_LINK_NODE* find_data_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode, int addr) {
    DOUBLE_LINK_NODE* pNode = NULL;
    if (NULL == pDLinkNode)
        return NULL;

    pNode = (DOUBLE_LINK_NODE*)pDLinkNode;
    while (NULL != pNode){
        if (addr == pNode->addr)
            return pNode;
        pNode = pNode->next;
    }
    return NULL;
}

//1. 删除双向链表
void delete_all_double_link_node(DOUBLE_LINK_NODE** pDLinkNode)
{
    DOUBLE_LINK_NODE* pNode;
    if (NULL == *pDLinkNode)
        return;
    pNode = *pDLinkNode;
    *pDLinkNode = pNode->next;
    free(pNode);
    delete_all_double_link_node(pDLinkNode);    //调用自身函数循环free
}

//2. 双向链表中插入数据
STATUS insert_data_into_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int addr)
{
    DOUBLE_LINK_NODE* pNode;
    DOUBLE_LINK_NODE* pIndex;

    if(NULL == ppDLinkNode)                                        // 原链表首地址 空        ->FALSE
        return FALSE;

    if(NULL == *ppDLinkNode){                                    // 原链表 空            ->直接加入
        pNode = create_double_link_node(addr);
        assert(NULL != pNode);
        *ppDLinkNode = pNode;
        (*ppDLinkNode)->prev = (*ppDLinkNode)->next = NULL;
        return TRUE;
    }

    if (NULL != find_data_in_double_link(*ppDLinkNode, addr))    // 原链表存在数据data    ->FALSE
        return FALSE;

    pNode = create_double_link_node(addr);                        //
    assert(NULL != pNode);

    pIndex = *ppDLinkNode;                                        // 赋值链表首地址
    #if 0        //添加的先后顺序
    while (NULL != pIndex->next)// 找到最后一个节点
        pIndex = pIndex->next;

    pNode->prev = pIndex;
    pNode->next = pIndex->next;
    pIndex->next = pNode;
    #endif
    #if 1        //递增
    if(pIndex->addr>addr)                // 起始位置 ->OK ?
    {
        *ppDLinkNode = pNode;
        pNode->prev = NULL;
        pNode->next = pIndex;
        pIndex->prev = pNode;
    }
    else
    {
        while (NULL != pIndex->next)// 找到最后一个节点
            pIndex = pIndex->next;
        if(pIndex->addr<addr){            // 结束位置 ->OK ?
            pNode->prev = pIndex;
            pNode->next = pIndex->next;
            pIndex->next = pNode;
        }
        else{                            // 中间位置
            pIndex = *ppDLinkNode;//首地址向后
            while (pIndex->addr<addr)
                pIndex = pIndex->next;
            pNode->prev = pIndex->prev;
            pNode->next = pIndex;
            pIndex->prev->next = pNode;
            pIndex->prev = pNode;
        }
    }
    #endif
    #if 0        //递减
    if(pIndex->addr<addr)                // 起始位置 ->OK ?
    {
        *ppDLinkNode = pNode;
        pNode->prev = NULL;
        pNode->next = pIndex;
        pIndex->prev = pNode;
    }
    else
    {
        while (NULL != pIndex->next)// 找到最后一个节点
            pIndex = pIndex->next;
        if(pIndex->addr>addr){            // 结束位置 ->OK ?
            pNode->prev = pIndex;
            pNode->next = pIndex->next;
            pIndex->next = pNode;
        }
        else{                            // 中间位置
            pIndex = *ppDLinkNode;//首地址向后
            while (pIndex->addr>addr)
                pIndex = pIndex->next;
            pNode->prev = pIndex->prev;
            pNode->next = pIndex;
            pIndex->prev->next = pNode;
            pIndex->prev = pNode;
        }
    }
    #endif

    return TRUE;
}

//3. 双向链表中删除数据
STATUS delete_data_from_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int addr)
{
    DOUBLE_LINK_NODE* pNode;
    if (NULL == ppDLinkNode || NULL == *ppDLinkNode)                // "原链表首地址"或“原链表” 空        ->FALSE
        return FALSE;

    pNode = find_data_in_double_link(*ppDLinkNode, addr);
    if (NULL == pNode)
        return FALSE;

    if (pNode == *ppDLinkNode){                                        // 赋值链表首地址
        if (NULL == (*ppDLinkNode)->next){
            *ppDLinkNode = NULL;
        }
        else{
            *ppDLinkNode = pNode->next;
            (*ppDLinkNode)->prev = NULL;
        }
    }
    else{
        if (pNode->next)
            pNode->next->prev = pNode->prev;                        // 下一个节点的 prev = 节点的prev
        pNode->prev->next = pNode->next;                            // 前一个节点的 next = 节点的next
    }

    free(pNode);
    return TRUE;
}

//4. 统计双向链表中数据的个数
int count_number_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode)
{
    int count = 0;
    DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode;

    while (NULL != pNode){
        count++;
        pNode = pNode->next;
    }
    return count;
}

//5. 打印双向链表中数据
void print_double_link_node(const DOUBLE_LINK_NODE* pDLinkNode)
{
    DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode;
    printf("print_double_link -> start\n");
    while (NULL != pNode){
        printf("%d\n", pNode->addr);
        pNode = pNode->next;
    }
    printf("print_double_link -> end\n");
}

时间： 2024-08-01 02:01:01

有序的双链表的相关文章

有序的双链表的实现

描述定义有序的双链表类,链表中存储整型数据,创建带头结点的有序双链表,要求包含以下成员函数: 双链表的构造函数(非空的链表,输入数据为0,表示输入结束) 插入操作(将一个数据元素插入到有序的双链表中,插入之后链表仍然有序,输入数据为0表示插入操作结束) 按值删除节点(考虑有重复值的情况) 双链表的遍历操作双链表的析构输入输入链表中的元素,根据输入元素,创建有序双链表(非空的链表,输入数据为0,表示输入结束)输入要插入的值(可以插入多个值,0表示输入结束,)输入要删除的值(可以删除多个值,0

[数据结构]双链表

[cpp] view plaincopy typedef struct NODE{ struct NODE *fwd; struct NODE *bwd; int value; }Node; 双链表的根节点的bwd指针指向双链表的最后一个节点,fwd指针指向双链表的第一个节点,双链表的value字段为空以下程序是将一个值插入到一个有序的双链表中,如果链表中已经有和该值相同的节点则不插入 [cpp] view plaincopy #include <stdio.h> #include <

双链表&链表合并&多项式相加算法

//单链表的合并 //链表合并 //两个链表必须是有序的 #define Maxsize 5 typedef int elemtype; typedef struct linklist { elemtype data; struct linklist *next; }Linklist; //建立链表1 Linklist *CreateList1 () { int i,data ; Linklist *head, *p, *q; head=p=(Linklist *)malloc(sizeof

双链表操作

处理完了单链表,这次处理双链表. 在一个双链表中,每个节点都包含两个指针,指向前一个节点的指针和指向后一个节点的指针.这可以使我们以任何方式遍历双链表,甚至可以忽略前后地在双链表中访问.下面的图示展示了一个双链表: 下面是节点类型的声明文件: double_linked_list_node.h #ifndef _DOUBLE_LINKED_LIST #define _DOUBLE_LINKED_LIST typedef struct NODE{ struct NODE * fwd; struct

双链表的实现

双链表:可以从一个表结点出发,在线性表中随意访问它的前驱结点和后继结点,双链表有两个指针. 双链表结template<class Elem> class Link private: static Link<Elem>* freelist ;//Head of the freelis public: Elem element;//value for this node Link *next;//pointer to next node in list Link *

优先双链表

题目: 设有一个双链表,每个结点中除有prior,data和 next这3个域外,还有一个访问频度域 freq,在链表被启用前其值均初始化为0.每当在在链表上进行一次查找操作Locate(L, x)时,令元素值为x的结点中的freq域的值增加1,并使此链表中的结点保持按访问频度域递减的顺序排列,以便使频繁访问的结点总是靠近表头 (1)首先创建一个双链表. (2) 设计一个符合上述要求的Locate(L, x)函数. (3) 具有输出显示访问频度功能. (4) 要求程序通过一个主菜单进行控制,在主

1216.1——双链表

双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱.所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点.一般我们都构造双向循环链表. typedef struct node{ struct node *pre; //前驱指针 int age; struct node *next; //后驱指针 }Node; int main(int argc, const char * argv[]) { Node * phead =

双链表优先队列ADT的实现与测试

源代码如下: #include <stdlib.h> #include <stdio.h> typedef struct pq* PQ; typedef struct PQnode* PQlink; struct Item{int data;char c;}; struct PQnode{Item key;PQlink prev,next;}; struct pq{PQlink head,tail;}; PQ PQinit(){ PQ pq = (PQ)malloc(sizeof*

双链表删除/插入节点

//双链表删除节点 dnode *del(dnode *head, int num) { dnode *p1, *p2; p1 = head; while (num != p1->data && p1->next != NULL) { p1 = p1->next; } if (num == p1->data) { if (p1 == head) { head = head->next; head->pre = NULL; free(p1); } else