0x00数据结构——C语言实现（双链表）

0x00数据结构——C语言实现（双链表）

/*filename:double_linked_list.h*/
/*
 双链表(double linked list)

 Functions:
 （在链表中增加附加头结点的版本）
    创建一个空线性表
    将链表置为空表
    计算表长度
    返回附加头结点的地址
    搜索函数：找x在表中的位置，返回表项位置
    定位函数：返回第i个表项在表中的位置
    取第i个表项的值
    用x修改第i个表项的内容
    插入x在表中第i个表项之后，函数返回成功标志
    删除表中第i个表项，通过x返回删除表项的值，函数返回成功标志
    判断表空，空返回真，否则返回假
    判断表满：满返回真，否则返回假
    输出
    对当前的表排序

*/

#ifndef DOUBLE_LINKED_LIST
#define DOUBLE_LINKED_LIST

//假定每个表项的类型为T
typedef int T;
#define MAXLEN 100
typedef enum {
    false = 0,
    true
} BOOL;

//双链表结点的数据结构。
struct node;
typedef struct node dnode;
typedef struct node *to_node;
typedef to_node d_list;
typedef to_node pos;

//创建一个空链表
d_list create_list(void);

//将链表置为空表
BOOL set_empty(d_list l);

//计算表长度
int calc_length(d_list l);

//返回附加头结点的地址
d_list head_addr(d_list l);

//搜索函数：找x在表中的位置，返回表项位置
pos search(d_list l, T x);

//定位函数：返回第i个表项在表中的位置
pos locate(d_list l, int i);

//取第i个表项的值
T get_val(d_list l, int i);

//用x修改第i个表项的内容
BOOL change_val(d_list l, int i, const T x);

//插入x在表中第i个表项之后，函数返回成功标志
BOOL insert_val(d_list l, int i, const T x);

//删除表中第i个表项，通过x返回删除表项的值，函数返回成功标志
BOOL delete_val(d_list l, int i, T *x);

//判断表空，空返回真，否则返回假
BOOL isempty(d_list l);

//输出
void output(d_list l);

//对当前的表排序
BOOL sort(d_list l);

#endif

/*filename:double_linked_list.c*/
#include <stdio.h>
#include <stdlib.h>
#include "double_linked_list.h"


/*
单链表结点的数据结构
*/
struct node{
    T val;
    struct node *prev;
    struct node *next;
};
/*
struct node;
typedef struct node dnode;
typedef struct node *to_node;
typedef to_node d_list;
typedef to_node pos;
*/

//创建一个空单链表
d_list create_list(void)
{
    d_list l = (d_list)malloc(sizeof(dnode));
    l->next = NULL;
    l->prev = NULL;
    l->val = 0;
    return l;
}
//该双链表带头节点，头节点的val域存储链表的长度

//将链表置为空表
BOOL set_empty(d_list l)
{
    pos tmp = l->next, ttemp;
    while(tmp!=NULL){
        ttemp = tmp->next;
        free(tmp);
        tmp = ttemp;
        }
    l->next = NULL;
    l->prev = NULL;
    l->val = 0;
    return true;
}

//计算表长度
int calc_length(d_list l)
{
    return l->val;
}

//返回附加头结点的地址
pos head_addr(d_list l)
{
    return l;
}

//搜索函数：找x在表中的位置，返回表项位置
pos search(d_list l, T x)
{
    int i = 1;
    pos tmp;
    tmp = l->next;
    while(tmp != NULL && tmp->val != x && i<=l->val){
        tmp = tmp->next;
        i++;
    }
    if(i>l->val) return NULL;
    else return tmp;
}

//定位函数：返回第i个表项在表中的位置
pos locate(d_list l, int i)
{
    if(i<=l->val && i>0){
        pos tmp;
        tmp = l;
        while(--i>=0 && tmp!=NULL){
            tmp = tmp->next;
        }
        return tmp;
    } else {
        printf("can not access the %d'th element\n", i);
        return NULL;
    }
}

//取第i个表项的值
T get_val(d_list l, int i)
{
    if(i<=l->val && i>0){
        pos tmp;
        tmp = l;
        while(--i>=0 && tmp!=NULL){
            tmp = tmp->next;
        }
        return tmp->val;
    } else {
        printf("can not access the %d'th element\n", i);
        return -1;
    }
}

//用x修改第i个表项的内容
BOOL change_val(d_list l, int i, const T x)
{
    if(i<=l->val && i>0){
        pos tmp;
        tmp = l;
        while(--i>=0 && tmp!=NULL){
            tmp = tmp->next;
        }
        tmp->val = x;
        return true;
    } else {
        return false;
    }
}

//插入x在表中第i个表项之后，函数返回成功标志
BOOL insert_val(d_list l, int i, const T x)
{
    if(i<=l->val && i>=0){
        pos tmp;
        tmp = l;
        while(--i>=0 && tmp!=NULL){
            tmp = tmp->next;
        }
        pos t = (pos)malloc(sizeof(dnode));
        t->next = tmp->next;
        if(tmp->next != NULL)
            (tmp->next)->prev = t;
        t->prev = tmp;
        tmp->next = t;
        t->val = x;
        l->val++;
        return true;
    } else {
        return false;
    }
}

//删除表中第i个表项，通过x返回删除表项的值，函数返回成功标志
BOOL delete_val(d_list l, int i, T *x)
{
    if(i<=l->val && i>0){
        i--;
        pos tmp;
        tmp = l;
        while(--i>=0 && tmp!=NULL){
            tmp = tmp->next;
        }
        *x = (tmp->next)->val;

        tmp->next = (tmp->next)->next;
        (tmp->next)->prev = tmp;
        l->val--;
        return true;
    } else {
        return false;
    }
}

//判断表空，空返回真，否则返回假
BOOL isempty(const d_list l)
{
    return (l->val == 0 ? true:false);
}

//输出
void output(const d_list l)
{
    pos tmp = NULL;
    int i = 1;
    tmp = l->next;
    while(tmp!=NULL){
        printf("the %dth element is %d\n", i++, tmp->val);
        tmp = tmp->next;
    }
}

//对当前的表排序
BOOL sort(const d_list l)
{
    if(l->val < 2)
        return true;
    //冒泡排序
    pos tmp, tmp1, tmp2;
    int i;
    tmp = locate(l, l->val);
    while(tmp->prev != l) {

        tmp1 = l->next;
        tmp2 = tmp1->next;
        while(tmp1 != tmp) {
            if(tmp1->val > tmp2->val) {
                i = tmp1->val;
                tmp1->val = tmp2->val;
                tmp2->val = i;
            }
            tmp1 = tmp1->next;
            tmp2 = tmp2->next;
        }

        tmp = tmp->prev;
    }
    return true;

    //快速排序

    //归并排序

}