C :

#include <stdio.h>
#include <stdlib.h>

typedef enum { OK, ERROR } Status;
typedef int ElemType;
typedef struct DuLNode {
  ElemType data;
  struct DuLNode *prior;
  struct DuLNode *next;
} DuLNode, *DuLinkList;

void ListCreate_DuL(DuLinkList *L)
{
  *L = (DuLinkList) malloc(sizeof(DuLNode));
  (*L)->prior = *L;
  (*L)->next = *L;
}

DuLinkList GetElemP_DuL(DuLinkList L, int i)
{
  DuLinkList p;
  int j;

  p = L->next;
  j = 1;
  while (p != L && j < i) {
    p = p->next;
    ++j;
  }
  if (p == L && j < i) {
    return NULL;
  }
  else {
    return p;
  }
}

Status ListInsert_DuL(DuLinkList *L, int i, ElemType e)
{
  DuLinkList p, s;

  if (!(p = GetElemP_DuL(*L, i))) {
    return ERROR;
  }
  if (!(s = (DuLinkList) malloc(sizeof(DuLNode)))) {
    return ERROR;
  }
  s->data = e;
  s->prior = p->prior;
  p->prior->next = s;
  s->next = p;
  p->prior = s;
  return OK;
}

Status ListDelete_DuL(DuLinkList *L, int i, ElemType *e)
{
  DuLinkList p;

  if (!(p = GetElemP_DuL(*L, i))) {
    return ERROR;
  }
  *e = p->data;
  p->prior->next = p->next;
  p->next->prior = p->prior;
  free(p);
  return OK;
}

void ListPrint_DuL(DuLinkList L)
{
  DuLinkList p;

  for (p = L->next; p->next != L; p = p->next) {
    printf("%d ", p->data);
  }
  if (p != L) {
    printf("%d\n", p->data);
  }
}

int main(void)
{
  int cmd, i, e;
  DuLinkList L;

  ListCreate_DuL(&L);
  while (scanf("%d", &cmd) != EOF) {
    switch (cmd) {
    case 0:
      ListPrint_DuL(L);
      break;
    case 1:
      scanf("%d %d", &i, &e);
      ListInsert_DuL(&L, i, e);
      break;
    case 2:
      scanf("%d", &i);
      ListDelete_DuL(&L, i, &e);
      break;
    }
  }
  return 0;
}

C++ :

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;
typedef int Status;
#define OK 1
#define ERROR 0

/*********双向链表以及其结点类型定义**************/
typedef struct DuLNode{
	ElemType data; // 数据域
	struct DuLNode *prior; // 前一结点的指针域
	struct DuLNode *next; // 后一结点的指针域
} DuLNode, *DuLinkList;

/*********创建双向循环链表***********/
void ListCreate_DuL(DuLinkList &L) {
	L = (DuLinkList) malloc(sizeof(DuLNode)); // 创建一个头结点
	L->prior = L; // 开始时前后指针都指向自身
	L->next = L;
}

DuLinkList GetElemP_DuL(DuLinkList L, int i) {
	// L为带头结点的单链表的头指针。
	// 当第i个元素存在时，返回其地址，否则返回NULL
	DuLinkList p;
	p = L->next;
	int j = 1; // 初始化，p指向第一个结点，j为计数器
	while (p != L && j < i) { //顺指针向后查找，直到p指向第i个元素或p为空
		p = p->next;
		++j;
	}
	if (p == L && j < i)
		return NULL; // 第i个元素不存在
	else
		return p;
} // GetElem_L

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

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

/******显示双向链表中的数据**********/
void ListShow_DuL(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;
	ListCreate_DuL(L);
	while(scanf("%d", &s) != EOF){
		switch(s){
		case 0:		// show
			ListShow_DuL(L);
			break;
		case 1:		// insert
			scanf("%d%d", &i, &e);
			ListInsert_DuL(L, i, e);
			break;
		case 2:		// delete
			scanf("%d", &i);
			ListDelete_DuL(L, i, e);
			break;
		}
	}

	return 0;
}