DList双向链表

最新推荐文章于 2023-09-24 23:13:47 发布
「已注销」
最新推荐文章于 2023-09-24 23:13:47 发布
阅读量6.5k
点赞数
分类专栏： Algorithms
本文链接：https://blog.csdn.net/liutianshx2012/article/details/51499577
版权
Algorithms 专栏收录该内容
57 篇文章 0 订阅
订阅专栏
//
//  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
 
 