DList双向链表

//
// DList.h
// Algorithms&Data_structures
//
// Created by TTc on 15-2-2.
// Copyright (c) 2015年 TTc. All rights reserved.
//

#ifndef __Algorithms_Data_structures__DList__
#define __Algorithms_Data_structures__DList__

#include <stdlib.h>

/* define a structure for doubly_linked list */
typedef struct DlistElmt_{
    void *data;
    struct DlistElmt_ *prev;
    struct DlistElmt_ *next;
}DlistElmt;

typedef struct Dlist_{
    int size;
    int(*match)(void *key1,void *key2);
    void(*destroy)(void *data);
    DlistElmt *head;
    DlistElmt *tail;
}Dlist;


/* public Interfaces*/

void dlist_init(Dlist *dlist,void(*destroy)(void *data));

void dlist_destroy(Dlist *dlist);

int dlist_ins_next(Dlist *dlist,DlistElmt *element,const void *data);

int dlist_ins_prev(Dlist *dlist,DlistElmt *element,const void *data);

int dlist_remove(Dlist *dlist,DlistElmt *element, void **data);


#define dlist_size(dlist) ((dlist)->size)
#define dlist_head(dlist) ((dlist) ->head)
#define dlist_tail(dlist) ((dlist) ->tail)

#define dlist_is_head(dlist) ((element) ->prev == NULL? 1:0)
#define dlist_is_tail(dlist) ((element) ->next == NULL? 1:0)


#define dlist_data(dlist) ((dlist) ->data)
#define dlist_next(dlist) ((dlist) ->next)
#define dlist_prev(dlist) ((dlist) ->prev)

#endif /* defined(__Algorithms_Data_structures__DList__) */

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56

//
// DList.c
// Algorithms&Data_structures
//
// Created by TTc on 15-2-2.
// Copyright (c) 2015年 TTc. All rights reserved.
//

#include "dlist.h"
#include <stdlib.h>
#include <string.h>


void
dlist_init(Dlist *dlist,void(*destroy)(void *data)){
    dlist->size = 0;
    dlist->head = NULL;
    dlist->tail = NULL;
    dlist->destroy = destroy;
}

void
dlist_destroy(Dlist *dlist){
    void *data;
    /*remove each element*/
    while (dlist_size(dlist) > 0) {
        if((dlist_remove(dlist, dlist_tail(dlist), (void**) &data) == 0)
                && dlist->destroy != NULL){
            dlist->destroy(data);
        }
    }
    //清空dlist 结构体
    memset(dlist, 0, sizeof(Dlist));
}

/*1: 将新元素插入到双链表中 由参数element所指向的元素 之后 2： 同单链表最大的区别在于：除了要管理next 指针外，还必须管理prev指针，以保证链表的 反向链接关系 正确 */
/* 插入成功返回0 ，反之返回 -1 */
/* O(1)*/
int
dlist_ins_next(Dlist *dlist,DlistElmt *element,const void *data){
    DlistElmt *new_element;
    //do not allow a NULL unless the list is empty
    if(element == NULL && dlist_size(dlist) != 0){
        return -1;
    }
    if((new_element = (DlistElmt*)malloc(sizeof(DlistElmt))) == NULL){
        return -1;
    }
    //fill the data to the element
    new_element->data = (void*)data;
    //如果当前链表为 空表，再插入新元素 的情况
    if(dlist_size(dlist) == 0){
        new_element->prev = NULL; //链表的头元素 的 前驱指针 指向NULL
        new_element->next = NULL; //链表的头元素 的 后驱指针 指向NULL(当前情况 链表中只要这一个元素)
        dlist->head = new_element;
        dlist->tail = new_element;//链表的尾指针也指向 当前元素
    } else {
        //如果当前链表为 非空表，再插入新元素 的情况

        if(element->next == NULL){
            dlist->tail = new_element;
        } else{
            //否则 将当前目标元素的 后一位置的元素 的 前驱指针 指向 要插入的元素
            element->next->prev = new_element;
        }

        new_element->next = element->next; //要插入的元素的 next指针 指向 当前目标元素 后一位置 元素
        new_element->prev = element;//要插入元素的 前驱函数 指向 当前目标元素
        //如果 当前目标元素的 是当前链表的 尾元素,则 将 链表的尾元素 置为 新插入的元素（把链表的尾指针 tail 指向 要插入的元素）
        //当前目标元素 的后驱指针 指向 要初入的元素
        element->next = new_element;
    }
    dlist->size ++;
    return 0;
}

/*1: 将新元素插入到双链表中 由参数element所指向的元素 之前 2： 同单链表最大的区别在于：除了要管理next 指针外，还必须管理prev指针，以保证链表的 反向链接关系 正确 3: 若element = NULL， 则双向链表应该为空，否则退出并返-1; 若element != NULL，则需要在element->prev位置插入元素，插入的新元素的数据域为第三个参数data.另外还需要考虑当element为head结点时的情况。 */
/* 插入成功返回0 ，反之返回 -1 */
/* O(1)*/
int
dlist_ins_prev(Dlist *dlist,DlistElmt *element,const void *data){
    DlistElmt *new_element;
      //Do not allow a NULL unless the list is empty
    if(element == NULL && dlist_size(dlist) != 0){
        return -1;
    }
    if((new_element = (DlistElmt*)malloc(sizeof(DlistElmt))) == NULL){
        return -1;
    }
    new_element->data = (void*)data;
    //如果当前链表为 空表，再插入新元素 的情况
    if(dlist_size(dlist) == 0){
        dlist->head = new_element;
        dlist->tail = new_element;//链表的尾指针也指向 当前元素
        new_element->prev = NULL; //链表的头元素 的 前驱指针 指向NULL
        new_element->next = NULL;//链表的头元素 的 后驱指针 指向NULL(当前情况 链表中只要这一个元素)
    } else {
        new_element->next = element;
        new_element->prev = element->prev;
        if(element->prev == NULL){
            dlist->head = new_element;
        }
        else{
            element->prev->next = new_element;
        }
        element->prev = new_element;
    }

    dlist->size++;

    return 0;
}

/* 1: remove操作将指定得元素从 双链表中删除；同单链表最大的区别在于：除了要管理next 指针外，还必须管理prev指针，以保证链表的 反向链接关系 正确 2: 对于双链表还有一个不同于 单链表 的地方在于 :该接口 移除当前指定的元素，而不是移除指定元素之后的那个元素，因为每个元素都有一个指向其前驱的指针 3: element代表 目标节点， 删除操作针对 element节点 */
/* 删除成功返回0 ，反之返回 -1 */
/* O(1)*/
int dlist_remove(Dlist *dlist,DlistElmt *element, void **data){
    /* Don't allow a NULL element or removal from an empty dlist */
    if(element == NULL || dlist_size(dlist) == 0){
        return -1;
    }
    *data = element->data;
    /* handle removal from the head of the dlist */
    // 若为 删除节点为 链表的 头节点
    if(element == dlist->head){
        //将链表头节点的 指针 指向 目标元素的 next指针（目标元素的下一个位置 元素）
        dlist->head = element->next;
        //若链表的head指针 指向NULL 则 tail 也必须指向NULL，删除元素后，可能为空表
        if(dlist->head == NULL){
            dlist->tail = NULL;
        } else{
            //若 head 指针 不为NULL ，则将必须将 目标元素的 前驱指针的 prev指向NULL(其实这个时候 element->next 就是 链表的 第一个元素 ，这个时候 第一元素的 前驱指针必须置为 NULL)
            element->next->prev = NULL;
        }
    } else {
        /* handle removal from other than the head of the dlist */
        //将 当前要删除的元素的 前一个位置的元素 的 next指针 指向 当前元素的 next指针（也就是当前位置元素 的后一个位置的 元素）
        element->prev->next = element->next;
        //
        if(element->next == NULL){
            dlist->tail = element->prev;
        }else{
            //将 当前位置要删除元素的 后一个位置的元素 的前驱指针prev 指向 当前元素的前驱指针（也就是当前元素的 前一个位置的元素）
            element->next->prev = element->prev;
        }
    }
    free(element);
    dlist->size --;
    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132
• 133
• 134
• 135
• 136
• 137
• 138
• 139
• 140
• 141
• 142
• 143
• 144
• 145
• 146
• 147
• 148
• 149
• 150
• 151
• 152
• 153
• 154
• 155
• 156
• 157
• 158
• 159
• 160
• 161
• 162
• 163
• 164
• 165
• 166
• 167
• 168
• 169

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132
• 133
• 134
• 135
• 136
• 137
• 138
• 139
• 140
• 141
• 142
• 143
• 144
• 145
• 146
• 147
• 148
• 149
• 150
• 151
• 152
• 153
• 154
• 155
• 156
• 157
• 158
• 159
• 160
• 161
• 162
• 163
• 164
• 165
• 166
• 167
• 168
• 169

//
// test_dlist_main.c
// 
//
// Created by TTc on 16/5/25.
//
//
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include "dlist.h"

typedef struct Cuboid_
{
    int length;
    int width;
    int height;
}Cuboid;

Cuboid *cube_instance(const int length, const int width, const int height)
{
    Cuboid *cb_ptr;
    cb_ptr = (Cuboid *)malloc(sizeof(Cuboid));
    if( cb_ptr == NULL )
        return NULL;

    cb_ptr->length = length;
    cb_ptr->width = width;
    cb_ptr->height = height;

    return cb_ptr;
}

/*destroy */
void destroy(void *data)
{
    free(data);
    return;
}


/* main */
int main(int argc, char **argv)
{
    int i;
    Dlist dlist_exp;
    DlistElmt *p = NULL;
    Cuboid *cb1_ptr, *cb2_ptr, *cb3_ptr, *cb4_ptr, *cb5_ptr;
    Cuboid *cb_ptr;

    //cb1_ptr ~ cb5_ptr are the data of the 5 elements.
    cb1_ptr = cube_instance(1,2,3);
    cb2_ptr = cube_instance(6,10,8);
    cb3_ptr = cube_instance(5,20,30);
    cb4_ptr = cube_instance(17,100,25);
    cb5_ptr = cube_instance(3,6,9);

    //init the double linked list.
    dlist_init(&dlist_exp, destroy);

    //insert the 5 elements into the dlist
    dlist_ins_next(&dlist_exp, NULL, (void *)cb1_ptr );  //insert data:cb1
    p = dlist_head(&dlist_exp); //get the address of the first element
    dlist_ins_next(&dlist_exp, p , (void *)cb2_ptr );   //insert data:cb2 cb1- cb2
    p = dlist_next(p);          //pointer to the element containing the data cb2.
    dlist_ins_prev(&dlist_exp, p, (void *)cb3_ptr );    //insert data:cb3 cb1- cb3- cb2
    dlist_ins_prev(&dlist_exp, p, (void *)cb4_ptr );    //insert data:cb4 cb1- cb3- cb4- cb2
    p = dlist_prev(p);          //pointer to the element conatining the data cb4.
    dlist_ins_prev(&dlist_exp, p, (void *)cb5_ptr );      //insert data:cb5 cb1- cb3- cb5- cb4- cb2

    //now the sequence is: head->cb1->cb3->cb5->cb4->cb2
    printf("traverse and print:\n");
    p = dlist_head(&dlist_exp); //get the head element;
    for( i = 0; i < dlist_size(&dlist_exp); i++ )
    {
        cb_ptr = (Cuboid *)dlist_data(p); //get the element's data, every data is a Cuboid's pointer.
        printf("i = %d: ",i);
        printf("length = %d, width = %d, height = %d\n",
               cb_ptr->length,
               cb_ptr->width,
               cb_ptr->height);
        p = dlist_next(p); //pointer to next element;
    }

    //we'll remove the third element:that's containing the data of cb5(3,6,9)
    p = dlist_head(&dlist_exp);
    p = dlist_next(p);
    p = dlist_next(p);
    dlist_remove(&dlist_exp, p, (void **)&cb_ptr);
    printf("the data of the third element: length = %d, width = %d, height = %d\n",
           cb_ptr->length,
           cb_ptr->width,
           cb_ptr->height);
    destroy(cb_ptr); //free the memory

    //now we'll show you the remained elements,the sequence is :(head)cb1->cb3->cb4->cb2(tail)
    printf("after remove the third elements:\n");
    p = dlist_head(&dlist_exp);
    for(i = 0; i < dlist_size(&dlist_exp); i++ )
    {
        cb_ptr = (Cuboid *)dlist_data(p);
        printf("i = %d: ",i);
        printf("length = %d, width = %d, height = %d\n",
               cb_ptr->length,
               cb_ptr->width,
               cb_ptr->height);
        p = dlist_next(p);
    }

    //destroy the double linked list
    dlist_destroy(&dlist_exp);
    printf("after destroy the list,its size = %d\n", dlist_size(&dlist_exp));
    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116