实现循环双链表各种基本运算的算法

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>

typedef int ElemType;
typedef struct DNode
{
ElemType data;//数据域
struct DNode *prior;//指向前驱结点
struct DNode *next;//指向后继结点
}DLinkNode;// 声明循环双链表结点类型

/*---------------------头插法建立循环双链表------------------------*/
static void create_list_front(DLinkNode *&L, ElemType a[], int n)// 指针的引用
{
DLinkNode *s;
int i;

// 创建头结点
L = (DLinkNode *)malloc(sizeof(DLinkNode));
L->next = NULL;
for(i = 0; i < n; i++)
{
// 创建新结点
s = (DLinkNode *)malloc(sizeof(DLinkNode));
s->data = a[i];

// 将结点s插入到原开始结点之前,头结点之后
s->next = L->next;
if(L->next != NULL)
L->next->prior = s;
L->next = s;
s->prior = L;
}
s = L->next;
// 查找尾结点,由s指向它
while(s->next != NULL)
s = s->next;
// 尾结点next域指向头结点
s->next = L;
// 头结点的prior域指向尾结点
L->prior = s;
}

/*---------------------尾插法建立循环双链表------------------------*/
static void create_list_rear(DLinkNode *&L, ElemType a[], int n)
{
int i;
DLinkNode *s, *r;

// 创建头结点
L = (DLinkNode *)malloc(sizeof(DLinkNode));//分配内存空间
L->next = NULL;
// r始终指向尾结点,开始时指向头结点
r = L;

for(i = 0; i < n; i++)
{
// 创建新结点
s = (DLinkNode *)malloc(sizeof(DLinkNode));
s->data = a[i];
// 将新结点s插入到结点r之后
r->next = s;
s->prior = r;
r = s;
}
// 尾结点next域指向头结点
r->next = L;
// 头结点的prior域指向尾结点
L->prior = r;
}

/*---------------------初始化线性表------------------------*/
static void init_list(DLinkNode *&L)//指针的引用
{
// 创建头结点
L = (DLinkNode *)malloc(sizeof(DLinkNode));
L->prior = L->next = L;
}

/*---------------------销毁线性表------------------------*/
static void destroy_list(DLinkNode *&L)// 指针的引用
{
DLinkNode *pre = L, *p = pre->next;

while(p != L)
{
free(pre);
// pre,p同步后移一个结点
pre = p;
p = pre->next;
}
// 此时p=L,pre指向尾结点,释放它
free(pre);
}

/*---------------------判断线性表是否为空表------------------------*/
static bool list_empty(DLinkNode *L)
{
return (L->next == L);
}

/*---------------------求线性表的长度------------------------*/
static int list_length(DLinkNode *L)
{
int i = 0;
DLinkNode *p = L;

while(p->next != L)
{
i++;
p = p->next;
}

// 循环结束,p指向尾结点,其序号i为结点个数
return i;
}

/*---------------------输出线性表------------------------*/
static void display_list(DLinkNode *L)
{
DLinkNode *p = L->next;

while(p != L)
{
printf("%c ", p->data);
p = p->next;
}

printf("\n");
}
/*---------------------求线性表中第i个元素值------------------------*/
static bool get_elem(DLinkNode *L, int i, ElemType &e)
{
int j = 1;
DLinkNode *p = L->next; // p指向第1个结点

// i错误或者L为空表返回假
if(i <= 0 || L->next == L)
return false;
// i = 1作为特殊情况处理
if(i == 1)
{
// 提取数据域
e = L->next->data;
return true;
}
// i不为1时
else
{
// 查找第i个结点p
while(j <= i - 1 && p != L)
{
j++;
p = p->next;
}
// 没有找到第i个结点,返回假
if(p == L)
return false;
else // 找到第i个结点,返回true
{
// 提取数据域
e = p->data;
return true;
}
}
}

/*---------------------查找第一个值域为e的元素序号------------------------*/
static int locate_elem(DLinkNode *L, ElemType e)
{
int i = 1;
DLinkNode *p = L->next;

while(p != NULL && p->data != e)
{
i++;
p = p->next;
}
// 不存在值为e的结点,返回0
if(p == NULL)
return 0;
//存在值为e的结点,返回其逻辑序号i
else
return i;
}

/*---------------------插入第i个元素------------------------*/
static bool list_insert(DLinkNode *&L, int i, ElemType e)
{
int j = 1;
DLinkNode *p = L, *s;

// i错误返回假
if(i <= 0)
return false;
// 原双链表为空表时
if(p->next == L)
{
// 创建新结点s
s = (DLinkNode *)malloc(sizeof(DLinkNode));
s->data = e;
p->next = s;
s->next = p;
p->prior = s;
s->prior = p;
return true;
}
else if(i == 1) // L不为空,i = 1作为特殊情况处理
{
// 创建新结点s
s = (DLinkNode *)malloc(sizeof(DLinkNode));
s->data = e;
// 将结点s插入到结点p之后
s->next = p->next;
p->next = s;
s->next->prior = s;
s->prior = p;
return true;
}
else // i不为1时
{
p = L->next;
// 查找第i-1个结点p
while(j <= i - 2 && p != L)
{
j++;
p = p->next;
}
// 未找到第i - 1个结点
if(p == L)
return false;
else
{
// 找到第i - 1个结点p
// 创建新结点s
s = (DLinkNode *)malloc(sizeof(DLinkNode));
s->data = e;
// 将结点s插入到结点p之后
s->next = p->next;
if(p->next != NULL)
p->next->prior = s;
s->prior = p;
p->next = s;
return true;
}
}
}

/*---------------------删除第i个元素------------------------*/
static bool list_delete(DLinkNode *&L, int i, ElemType &e)
{
int j = 1;
DLinkNode *p = L, *q;

// i错误或者为空表返回假
if(i <= 0 || L->next == L)
return false;
// i = 1作为特殊情况处理
if(i == 1)
{
// 删除第1个结点
q = L->next;
e = q->data;
L->next = q->next;
q->next->prior = L;
free(q);
return true;
}
else // i不为1时
{
p = L->next;
// 查找到第i - 1个结点p
while(j <= i - 2 && p != NULL)
{
j++;
p = p->next;
}
// 未找到第i - 1个结点
if(p == NULL)
return false;
else // 找到第i - 1个结点p
{
// q指向要删除的结点
q = p->next;
// 不存在第i个结点
if(q == NULL)
return 0;
e = q->data;
// 从单链表中删除q结点
p->next = q->next;
if(p->next != NULL)
p->next->prior = p;
//释放q结点
free(q);
}
}
}

int main(void)
{
DLinkNode *h;
ElemType e;

printf("循环双链表的基本运算如下:\n");
printf("(1)初始化循环双链表h\n");
init_list(h);

printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
list_insert(h, 1, 'a');
list_insert(h, 2, 'b');
list_insert(h, 3, 'c');
list_insert(h, 4, 'd');
list_insert(h, 5, 'e');
printf("(3)输出循环双链表h:");
display_list(h);
printf("(4)循环双链表h长度:%d\n", list_length(h));
printf("(5)循环双链表h为%s\n",(list_empty(h) ? "空" : "非空"));
get_elem(h, 3, e);
printf("(6)循环双链表h的第3个元素:%c\n", e);
printf("(7)元素a的位置:%d\n", locate_elem(h, 'a'));
printf("(8)在第4个元素位置上插入f元素\n");
list_insert(h, 4, 'f');
printf("(9)输出循环双链表h:");
display_list(h);
printf("(10)删除h的第3个元素\n");
list_delete(h, 3, e);
printf("(11)输出循环双链表h:");
display_list(h);
printf("(12)释放循环双链表\h");
destroy_list(h);

return 0;
}

测试结果:

循环双链表的基本运算如下:
(1)初始化循环双链表h
(2)依次采用尾插法插入a,b,c,d,e元素
(3)输出循环双链表h:a b c d e
(4)循环双链表h长度:5
(5)循环双链表h为非空
(6)循环双链表h的第3个元素:c
(7)元素a的位置:1
(8)在第4个元素位置上插入f元素
(9)输出循环双链表h:a b c f d e
(10)删除h的第3个元素
(11)输出循环双链表h:a b f d e
(12)释放循环双链表h

实现循环双链表各种基本运算的算法

猜你喜欢