HNCU1328：算法2-18~2-19：双向循环链表

http://hncu.acmclub.com/index.php?app=problem_title&id=111&problem_id=1328

题目描述

双向链表是在结点中既保存了后一个结点指针又保存了前一个结点指针的链表。这种链表较单向链表而言能够快速查找某一结点的前后结点。下面给出双向链表的定义、插入以及删除算法描述。

图1：双向链表示例

（a）结点结构；（b）空的双向循环链表；（c）含有三个结点的双向循环链表

图2：双向链表的定义以及创建

双向链表在插入与删除时一定要注意其操作步骤的顺序。下面给出双向链表在插入与删除时的图示。

图3：双向链表插入与删除的图示

（a）双向链表的删除操作；（b）双向链表的插入操作

图4：双向链表的查找以及插入

图5：双向链表的删除操作

输入格式

输入数据只有一组，包含很多行。每行有1~3个整数。第一个整数如果是0，则表示输出双向链表中的所有元素；第一个整数如果是1，表示插入1个整数，其后跟2个整数i、e代表在第i个位置插入e；第一个整数如果是2，表示删除1个整数，其后跟1个整数i，表示删除的位置为i。
起始双向链表为空表。保证链表中每个元素不会重复，同时所有的操作都合法。

输出

当需要输出双向链表中的所有元素时输出，每次输出一行。整数间用一个空格隔开。

样例输入

1 1 2
0
1 2 7
0
2 1
0
1 2 4
1 3 5
1 2 6
0
2 3
0

样例输出

2
2 7
7
7 6 4 5
7 6 5

 

 

#include<string.h>
#include<malloc.h> /* malloc()等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<stdlib.h> /* atoi() */
#include<math.h> /* floor(),ceil(),abs() */
/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
typedef int ElemType;

typedef struct DuLNode
{
    ElemType data;
    struct DuLNode *prior,*next;
} DuLNode,*DuLinkList;

Status InitList(DuLinkList *L)
{
    /* 产生空的双向循环链表L */
    *L=(DuLinkList)malloc(sizeof(DuLNode));
    if(*L)
    {
        (*L)->next=(*L)->prior=*L;
        return OK;
    }
    else
        return OVERFLOW;
}

Status GetElem(DuLinkList L,int i,ElemType *e)
{
    /* 当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
    int j=1; /* j为计数器 */
    DuLinkList p=L->next; /* p指向第一个结点 */
    while(p!=L&&j<i) /* 顺指针向后查找,直到p指向第i个元素或p指向头结点 */
    {
        p=p->next;
        j++;
    }
    if(p==L||j>i) /* 第i个元素不存在 */
        return ERROR;
    *e=p->data; /* 取第i个元素 */
    return OK;
}

int ListLength(DuLinkList L)
 { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
   int i=0;
   DuLinkList p=L->next; /* p指向第一个结点 */
   while(p!=L) /* p没到表头 */
   {
     i++;
     p=p->next;
   }
   return i;
 }

DuLinkList GetElemP(DuLinkList L,int i) /* 另加 */
 { /* 在双向链表L中返回第i个元素的位置指针(算法2.18、2.19要调用的函数) */
   int j;
   DuLinkList p=L;
   for(j=1;j<=i;j++)
     p=p->next;
   return p;
 }

Status ListInsert(DuLinkList L,int i,ElemType e) /* 改进算法2.18 */
{
    /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */
    DuLinkList p,s;
    if(i<1||i>ListLength(L)+1) /* i值不合法 */
        return ERROR;
    p=GetElemP(L,i-1); /* 在L中确定第i-1个元素的位置指针p */
    if(!p) /* p=NULL,即第i-1个元素不存在 */
        return ERROR;
    s=(DuLinkList)malloc(sizeof(DuLNode));
    if(!s)
        return OVERFLOW;
    s->data=e; /* 在第i-1个元素之后插入 */
    s->prior=p;
    s->next=p->next;
    p->next->prior=s;
    p->next=s;
    return OK;
}

Status ListDelete(DuLinkList L,int i,ElemType *e) /* 算法2.19 */
{
    /* 删除带头结点的双链循环线性表L的第i个元素,i的合法值为1≤i≤表长+1 */
    DuLinkList p;
    if(i<1||i>ListLength(L)) /* i值不合法 */
        return ERROR;
    p=GetElemP(L,i);  /* 在L中确定第i个元素的位置指针p */
    if(!p) /* p=NULL,即第i个元素不存在 */
        return ERROR;
    *e=p->data;
    p->prior->next=p->next;
    p->next->prior=p->prior;
    free(p);
    return OK;
}

void ListShow(DuLinkList L)
{
    DuLinkList p = L->next;
    int i = 0;
    while(p != L)                 // 注意这里的结束条件
    {
        if(i++)
        {
            putchar(' ');
        }
        printf("%d", p->data);
        p = p->next;
    }
    putchar('\n');                // 注意换行
}

int main()
{

    int s, i, e;        // 定义存储指令、下标以及元素的变量
    DuLinkList L;
    InitList(&L);
    while(scanf("%d", &s) != EOF)
    {
        switch(s)
        {
        case 0:                // show
            ListShow(L);
            break;
        case 1:                // insert
            scanf("%d%d", &i, &e);
            ListInsert(L, i, e);
            break;
        case 2:                // delete
            scanf("%d", &i);
            ListDelete(L, i, &e);
            break;
        }
    }

    return 0;
}