数据结构 双向链表和循环链表

一、双向链表

1. LinkList.h

#ifndef _LINKLIST_H
#define _LINKLIST_H

#define FAILURE  10000
#define SUCCESS  10001
#define TRUE     10002
#define FALSE    10003

typedef int ElemType;

struct node
{
    ElemType data;  /*数据域*/
    struct node *next;  /*指针域,指向后一个*/
    struct node *prior; /*指向前一个*/
};

typedef struct node Node;

int LinkInit(Node **l);
int LinkInsert(Node *l, int n, ElemType e);
int LinkTraverse(Node *l, void (*p)(ElemType));
int LinkLength(Node *l);
int LinkEmpty(Node *l);
int GetElem(Node *l, int p, ElemType *e);
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType));
int LinkDelete(Node *l, int p, ElemType *e);
int LinkClear(Node *l);
int LinkDestroy(Node **l);

#endif

2. LinkList.c

#include "LinkList.h"
#include <stdlib.h>

/*初始化*/
int LinkInit(Node **l)
{
    *l = (Node *)malloc(sizeof(Node) * 1); /*分配头结点，l是头指针*/
    if(NULL == *l)
    {
        return FAILURE;
    }

    (*l)->next = NULL; /*头结点指针域为空*/
    (*l)->prior = NULL;

    return SUCCESS;
}

/*插入*/
int LinkInsert(Node *l, int n, ElemType e) /*n插入位置,k移动次数*/
{
    Node *p = l;
    int k = 1;

    if(NULL == l)
    {
        return FAILURE;
    }

    while(k < n && p != NULL)
    {
        p = p->next;
        k++;
    }

    if(k > n || p == NULL)
    {
        return FAILURE;
    }

    Node *q = (Node *)malloc(sizeof(Node) * 1);
    if(NULL == q)
    {
        return FAILURE;
    }

    q->data = e; /*先给新指针赋值*/
    q->prior = p;
    q->next = p->next;
    p->next = q;
    if(NULL != q->next)  /*如果q不是最后一个*/
    {
        q->next->prior = q;
    }

    return SUCCESS;
}

/*遍历*/
int LinkTraverse(Node *l, void (*p)(ElemType))
{
    if(NULL == l)
    {
        return FAILURE;
    }
    Node *q = l;

    while (q->next)
    {
        q = q->next;
        p(q->data);
    }

    return SUCCESS;
}

/*求长度*/
int LinkLength(Node *l)
{
    if(NULL == l)
    {
        return FAILURE;
    }

    int len = 0;
    Node *p = l->next;

    while(p)
    {
        len++;
        p = p->next;
    }

    return len;
}

/*判断是否为空*/
int LinkEmpty(Node *l)
{
    return (l->next == NULL) ? TRUE : FALSE;
}

/*获取p位置的元素*/
int GetElem(Node *l, int p, ElemType *e)  /*p位置*/
{
    if(NULL == l || p < 1)  /*入参判断 p不能小于0*/
    {
        return FAILURE;
    }

    Node *q = l;
    int i;

    for(i = 0; i < p && q != NULL; i++)  /*循环p次 同时满足p不为空*/
    {
        q = q->next;
    }

    if(!q)  /*如果q为空，说明p(位置)大于长度*/
    {
        return FAILURE;
    }

    *e = q->data;  /*q已经指向第p个结点*/

    return SUCCESS;
}

/*查找元素e的位置*/
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType))
{
    if(NULL == l)
    {
        return FAILURE;
    }

    Node *q = l->next;
    int len = 1;

    while(q)
    {
        if(p(e, q->data) == TRUE)
        {
            return len;
        }
        q = q->next;
        len++;
    }

    return FAILURE;
}

/*删除*/
int LinkDelete(Node *l, int p, ElemType *e)
{
    int k = 1;
    Node *q = l;

    if(NULL == l)
    {
        return FAILURE;
    }

    while(k < p && q != NULL)
    {
        q = q->next;
        k++;
    }

    if(k > p || q == NULL)
    {
        return FAILURE;
    }

    Node *n = q->next;
    *e = n->data;
    q->next = n->next;
    if(n->next != NULL) /**/
    {
        n->next->prior = q;
    }
    else
    {
        q->next = NULL;
    }
    free(n);

    return SUCCESS;
}

/*清空*/
int LinkClear(Node *l)
{
    if(NULL == l)
    {
        return FAILURE;
    }

    Node *p = l->next;

    while(p)
    {
        l->next = p->next;
        free(p);
        p = l->next;
    }

    return SUCCESS;
}

/*销毁*/
int LinkDestroy(Node **l)
{
    if(NULL == l)
    {
        return FAILURE;
    }
    free(*l);
    (*l) = NULL;

    return SUCCESS;
}

3. TestLinkList.c (main函数) 

#include "LinkList.h"
#include <stdio.h>
/*带头结点的双向链表*/
void print(ElemType e)
{
    printf("%d ", e);
}

int equal(ElemType e1, ElemType e2)
{
    return (e1 == e2) ? TRUE : FALSE;
}

int main()
{
    int ret, i;
    Node *first = NULL; /*头指针*/

    srand(time(NULL));

    /*初始化*/
    ret = LinkInit(&first);
    if(ret == FAILURE)
    {
        printf("Init Failure!\n");
    }
    else
    {
        printf("Init Success!\n");
    }

    /*插入*/
    for(i = 0; i < 10; i++)
    {
        ret = LinkInsert(first, i + 1, rand() % 20);
        if(ret == FAILURE)
        {
            printf("Insert Failure!\n");
        }
        else
        {
            printf("Insert Success!\n");
        }
    }

    /*遍历*/
    ret = LinkTraverse(first, print);
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    /*求长度*/
    ret = LinkLength(first);
    if(ret == FAILURE)
    {
        printf("Get Length Failure!\n");
    }
    else
    {
        printf("Length is %d\n", ret);
    }

    /*判断是否为空*/
    ret = LinkEmpty(first);
    if(ret == TRUE)
    {
        printf("List is empty!\n");
    }
    else if(ret == FALSE)
    {
        printf("List is not empty!\n");
    }

    /*获取第p个元素*/
    int p = 3;
    ElemType e;
    ret = GetElem(first, p, &e);
    if(ret == FAILURE)
    {
        printf("Get element failure!\n");
    }
    else
    {
        printf("The %dth element is %d\n", p, e);
    }

    /*判断元素10的位置*/
    e = 10;
    ret = LocateElem(first, e, equal);
    if(FAILURE == ret)
    {
        printf("%d not exist!\n");
    }
    else
    {
        printf("%d is %dth element!\n", e, ret);
    }

    /*删除*/
    p = 3;
    ret = LinkDelete(first, p, &e);
    if(ret == FAILURE)
    {
        printf("Delete Failure!\n");
    }
    else
    {
        printf("Delete %d Success!\n", e);
    }

    /*删除后再次遍历*/
    ret = LinkTraverse(first, print);
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    /*清空*/
    ret = LinkClear(first);
    if(ret == SUCCESS)
    {
        printf("Clear Success!\n");
    }
    else
    {
        printf("Clear Failure!\n");
    }

    /*销毁*/
    ret = LinkDestroy(&first);
    if(ret == SUCCESS)
    {
        printf("Destroy Success!\n");
    }
    else
    {
        printf("Destroy Failure!\n");
    }

    return 0;
}

二、双向循环链表 

1. LinkList.h

#ifndef _LINKLIST_H
#define _LINKLIST_H

#define FAILURE  10000
#define SUCCESS  10001
#define TRUE     10002
#define FALSE    10003

typedef int ElemType;

struct node
{
    ElemType data;  /*数据域*/
    struct node *next;  /*指针域,指向后一个*/
    struct node *prior; /*指向前一个*/
};

typedef struct node Node;

int LinkInit(Node **l);
int LinkInsert(Node *l, int n, ElemType e);
int LinkTraverse(Node *l, void (*p)(ElemType));
int LinkLength(Node *l);
int LinkEmpty(Node *l);
int GetElem(Node *l, int p, ElemType *e);
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType));
int LinkDelete(Node *l, int p, ElemType *e);
int LinkClear(Node *l);
int LinkDestroy(Node **l);

#endif

2. LinkList.c 

#include "LinkList.h"
#include <stdlib.h>
/*双向循环链表*/
/*初始化*/
int LinkInit(Node **l)
{
    *l = (Node *)malloc(sizeof(Node) * 1); /*分配头结点，l是头指针*/
    if(NULL == *l)
    {
        return FAILURE;
    }

    (*l)->next = (*l); /*头结点指针域为空*/
    (*l)->prior = (*l);

    return SUCCESS;
}

/*插入*/
int LinkInsert(Node *l, int n, ElemType e) /*n插入位置,k移动次数*/
{
    Node *p = l;
    int k = 1;

    if(NULL == l)
    {
        return FAILURE;
    }

    if(n > LinkLength(l) + 1)
    {
        return FAILURE;
    }

    while(k < n)
    {
        p = p->next;
        k++;
    }

    if(k > n)
    {
        return FAILURE;
    }

    Node *q = (Node *)malloc(sizeof(Node) * 1);
    if(NULL == q)
    {
        return FAILURE;
    }

    q->data = e; /*先给新指针赋值*/
    q->prior = p;
    q->next = p->next;
    p->next = q;
    if(l != q->next)  /*如果q不是最后一个*/
    {
        q->next->prior = q;
    }

    return SUCCESS;
}

/*遍历*/
int LinkTraverse(Node *l, void (*p)(ElemType))
{
    if(NULL == l)
    {
        return FAILURE;
    }
    Node *q = l;

    while (q->next != l)
    {
        q = q->next;
        p(q->data);
    }

    return SUCCESS;
}

/*求长度*/
int LinkLength(Node *l)
{
    if(NULL == l)
    {
        return FAILURE;
    }

    int len = 0;
    Node *p = l->next;

    while(p != l)
    {
        len++;
        p = p->next;
    }

    return len;
}

/*判断是否为空*/
int LinkEmpty(Node *l)
{
    return (l->next == l && l->prior == l) ? TRUE : FALSE;
}

/*获取p位置的元素*/
int GetElem(Node *l, int p, ElemType *e)  /*p位置*/
{
    if(NULL == l || p < 1)  /*入参判断 p不能小于0*/
    {
        return FAILURE;
    }

    Node *q = l->next;/*双向循环链表 q指向第一个结点*/
    int i;

    for(i = 1; i < p && q != NULL; i++)  /*循环p-1次 同时满足p不为空 */
    {
        q = q->next;
    }

    if(q == l)  /*如果q为空，说明p(位置)大于长度*/
    {
        return FAILURE;
    }

    *e = q->data;  /*q已经指向第p个结点*/

    return SUCCESS;
}

/*查找元素e的位置*/
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType))
{
    if(NULL == l)
    {
        return FAILURE;
    }

    Node *q = l->next;
    int len = 1;

    while(q != l)
    {
        if(p(e, q->data) == TRUE)
        {
            return len;
        }
        q = q->next;
        len++;
    }

    return FAILURE;
}

/*删除*/
int LinkDelete(Node *l, int p, ElemType *e)
{
    int k = 1;
    Node *q = l;

    if(NULL == l)
    {
        return FAILURE;
    }

    if(p > LinkLength(l) + 1)  /*判断p位置是否合法*/
    {
        return FAILURE;
    }

    while(k < p)
    {
        q = q->next;
        k++;
    }

    if(k > p)
    {
        return FAILURE;
    }

    Node *n = q->next;
    *e = n->data;
    q->next = n->next;
    n->next->prior = q;
    free(n);

    return SUCCESS;
}

/*清空*/
int LinkClear(Node *l)
{
    if(NULL == l)
    {
        return FAILURE;
    }

    Node *p = l->next;

    while(p != l)
    {
        l->next = p->next;
        free(p);
        p = l->next;
    }

    l->prior = l;
    return SUCCESS;
}

/*销毁*/
int LinkDestroy(Node **l)
{
    if(NULL == l)
    {
        return FAILURE;
    }
    free(*l);
    (*l) = NULL;

    return SUCCESS;
}

3. TestLinkList.c (main函数)

#include "LinkList.h"
#include <stdio.h>
/*双向循环链表*/
void print(ElemType e)
{
    printf("%d ", e);
}

int equal(ElemType e1, ElemType e2)
{
    return (e1 == e2) ? TRUE : FALSE;
}

int main()
{
    int ret, i;
    Node *first = NULL; /*头指针*/

    srand(time(NULL));

    /*初始化*/
    ret = LinkInit(&first);
    if(ret == FAILURE)
    {
        printf("Init Failure!\n");
    }
    else
    {
        printf("Init Success!\n");
    }

    /*插入*/
    for(i = 0; i < 10; i++)
    {
        ret = LinkInsert(first, i + 1, rand() % 20);
        if(ret == FAILURE)
        {
            printf("Insert Failure!\n");
        }
        else
        {
            printf("Insert Success!\n");
        }
    }

    /*遍历*/
    ret = LinkTraverse(first, print);
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    /*求长度*/
    ret = LinkLength(first);
    if(ret == FAILURE)
    {
        printf("Get Length Failure!\n");
    }
    else
    {
        printf("Length is %d\n", ret);
    }

    /*判断是否为空*/
    ret = LinkEmpty(first);
    if(ret == TRUE)
    {
        printf("List is empty!\n");
    }
    else if(ret == FALSE)
    {
        printf("List is not empty!\n");
    }

    /*获取第p个元素*/
    int p = 3;
    ElemType e;
    ret = GetElem(first, p, &e);
    if(ret == FAILURE)
    {
        printf("Get element failure!\n");
    }
    else
    {
        printf("The %dth element is %d\n", p, e);
    }

    /*判断元素10的位置*/
    e = 10;
    ret = LocateElem(first, e, equal);
    if(FAILURE == ret)
    {
        printf("%d not exist!\n");
    }
    else
    {
        printf("%d is %dth element!\n", e, ret);
    }

    /*删除*/
    p = 3;
    ret = LinkDelete(first, p, &e);
    if(ret == FAILURE)
    {
        printf("Delete Failure!\n");
    }
    else
    {
        printf("Delete %d Success!\n", e);
    }

    /*删除后再次遍历*/
    ret = LinkTraverse(first, print);
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    /*清空*/
    ret = LinkClear(first);
    if(ret == SUCCESS)
    {
        printf("Clear Success!\n");
    }
    else
    {
        printf("Clear Failure!\n");
    }

    /*销毁*/
    ret = LinkDestroy(&first);
    if(ret == SUCCESS)
    {
        printf("Destroy Success!\n");
    }
    else
    {
        printf("Destroy Failure!\n");
    }

    return 0;
}