数据结构4-线性表-双循环链表

已于 2022-07-03 23:03:21 修改
阅读量152 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2022-07-03 22:30:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54591377/article/details/125590556
版权

循环链表

循环链表：是一种头尾相接的链表（即：表中最后一个结点的指针域
指向头结点，整个链表形成一个环）。
单循环链表：
image-20220628203413373

//单循环链表
#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0


typedef struct Node {
    int data;
    struct Node* next;
}Node;


Node* initList() {
    Node* L = (Node*)malloc(sizeof(Node));
    L -> data = 0;
    L -> next = L;
    return L;
}


void headInsert(Node* L, int data) {
    Node* node = (Node*)malloc(sizeof(Node));
    node -> data = data;
    node -> next = L -> next;
    L -> next = node;
    L -> data ++;
}


void tailInsert(Node* L, int data) {
    Node* n = L;
    Node* node = (Node*)malloc(sizeof(Node));
    node -> data = data;
    while(n -> next != L){
        n = n -> next;
    }
    node -> next = L;
    n -> next = node;
    L -> data ++;
}


int delete(Node* L, int data) {
    Node* preNode = L;
    Node* node = L -> next;
    while(node != L){
        if(node -> data == data){
            preNode -> next = node -> next;
            free(node);
            L -> data --;
            return TRUE;
        }
        preNode = node;
        node = node -> next;
    }
    return FALSE;
}

void printList(Node* L) {
    Node* node = L -> next;
    while(node != L){
        printf("%d->", node -> data);
        node = node -> next;
    }
    printf("NULL\n");
}

int main()
{
    Node* L = initList();
    headInsert(L, 1);
    headInsert(L, 2);
    headInsert(L, 3);
    headInsert(L, 4);
    headInsert(L, 5);
    tailInsert(L, 6);
    tailInsert(L, 7);
    printList(L);
    delete(L, 4);
    delete(L, 7);
    printList(L);
    return 0;
}

双循环链表：
在这里插入图片描述

优点：从表中任一结点出发均可找到表中其他结点。

空表：头结点存放自己的地址

判断循环链表的循环结束条件：p!=L ; p-> next != L

带尾指针的循环链表合并：

循环链表是头尾相接的链表(即表中最后一个结点的指针域指向头结点，整个链表形成一个环)(circular linked list)

**优点：**从表中任一结点出发均可访问全部结点

循环链表与单链表的主要差异当链表遍历时，判别当前指针p是否指向表尾结点的终止条件不同。

循环单链表的判别条件为p!=L或p->next!=L。
在这里插入图片描述
在这里插入图片描述
循环链表的定义

typedef struct CLnode
{
    ElemType data;
    CLnode *next;
}*CircList;

循环链表的初始化

void InitList(CircList &L)
{
    L = new CLnode;
    L->next = L;
}

循环链表的基本操作和单链表基本上相同，唯一不同的是，由于循环链表的最后一个结点的next不再是空指针，而是指向头结点，因此，循环中的结束条件要发生变化

单链表--------------循环链表
while(p)--------->while(p!=L)
while(p->next)--->while(p->next!=L)

双循环链表

有两个指针域，一个指向直接前驱，另一个指向直接后继

//双循环链表
//DuLinkList.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>

using std::cin;
using std::cout;
using std::endl;


//函数结果状态代码 
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1

//Status 是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef int ElemType;

typedef struct DuLNode
{
	ElemType data;
	struct DuLNode *prior;
	struct DuLNode *next;

}DuLNode, *DuLinkList;//表示类型
					 
Status InitList_Du(DuLinkList &L);

int ListEmpty_Du(DuLinkList L);

Status DestroyList_Du(DuLinkList &L);

Status ClearList_Du(DuLinkList &L);

int ListLength_Du(DuLinkList &L);

Status GetElem_Du(DuLinkList &L, int i, ElemType &e);

int  LocateELem_Du(DuLinkList L, ElemType e);

Status Listlnsert_Du(DuLinkList &L, int i, ElemType e);

Status Headlnsert_Du(DuLinkList &L, ElemType e);

Status ListDelete_Du(DuLinkList &L, int i, ElemType &e);

void ShowLinkList_Du(DuLinkList L);

//DuLinkList.cpp
#include "DuLinkList.h"

Status InitList_Du(DuLinkList &L)
{
	L = new DuLNode;
	L->data = 0;
	L->next = L->prior = L;
	return OK;
}

int ListEmpty_Du(DuLinkList L)
{
	if (L->next == L && L->prior == L)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

Status DestroyList_Du(DuLinkList &L)//销毁单链表L
{
	DuLNode * p;
	DuLNode * q;
	p = L->next;
	while (p && p != L)
	{
		q = p->next;
		delete p;
		p = q;
	}
	L->prior = L->next = L;
	delete L;
	return OK;
}

Status ClearList_Du(DuLinkList &L)
{
	DuLNode * p;
	DuLNode * q;
	p = L->next;
	while (p && p != L)
	{
		q = p->next;
		delete p;
		p = q;
	}
	L->prior = L->next = L;
	return OK;

}

int ListLength_Du(DuLinkList &L)
{
	DuLNode * p = L->next;
	int i = 0;
	while (p && p!=L)
	{
		p = p->next;
		i++;
	}
	return i;
}

Status GetElem_Du(DuLinkList &L, int i, ElemType &e)
{
	DuLNode * p = L->next;
	int j = 1;
	//初始化
	while (p && j < i)
	{
		p = p->next;
		++j;
	}
	if (!p || j > i)return ERROR;//第i个元素不存在
	e = p->data;//取第1个元素
	return OK;
}


int  LocateELem_Du(DuLinkList L, ElemType e)
{
	DuLNode * p = L->next;
	int j = 1;
	//初始化
	while (p && p->data != e)
	{
		p = p->next;
		++j;
	}
	if (p)
	{
		return j;
	}
	else
	{
		return 0;
	}
}

Status Listlnsert_Du(DuLinkList &L, int i, ElemType e)
{


	DuLNode * p = L;
	int j = 0;
	//初始化
	while (p->next && j < i - 1)
	{
		p = p->next;
		++j;
	}

	DuLNode *s = new DuLNode;
	s->data = e;

	s->next = p->next;
	s->prior = p;
	p->next = s;
	p->next->prior = s;
	return OK;
}

Status Headlnsert_Du(DuLinkList &L, ElemType e)
{
	DuLNode *s = new DuLNode;
	s->data = e;

	s->next = L->next;
	s->prior = L->prior;

	L->next->prior = s;
	L->next = s;
	return OK;

}

Status ListDelete_Du(DuLinkList &L, int i, ElemType &e)
{
	DuLNode * p = L;
	int j = 0;
	//初始化
	while (p->next && j < i - 1)
	{
		p = p->next;
		++j;
	}
	DuLNode * pfree = p->next;
	e = pfree->data;

	p->next = p->next->next;
	p->next->next->prior = p;

	delete pfree;
	return OK;
}

void ShowLinkList_Du(DuLinkList L)
{
	DuLNode *p = L->next;
	while (p && p != L)
	{
		printf("%d, ", p->data);
		p = p->next;
	}
	printf("\n");
}

void test01()
{
	DuLinkList M;
	InitList_Du(M);
	if (M)
	{
		printf("链表初始化完成\n");
	}

	Listlnsert_Du(M, 1, 1);
	Listlnsert_Du(M, 2, 3);
	Listlnsert_Du(M, 3, 4);
	Listlnsert_Du(M, 2, 2);
	Listlnsert_Du(M, 1, 0);

	printf("双向循环链表的长度为：%d\n", ListLength_Du(M));
	ShowLinkList_Du(M);

	ElemType elem = 0;
	ListDelete_Du(M, 1, elem);
	printf("删除第一个元素%d  后链表为\n", elem);
	ShowLinkList_Du(M);

	printf("使用头插法添加6后链表为\n");
	Headlnsert_Du(M, 6);
	ShowLinkList_Du(M);


	ClearList_Du(M);
	if (ListEmpty_Du(M))
	{
		cout << "链表已经清空" << endl;
	}
	DestroyList_Du(M);

}
int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;

}

顺序表和链表的比较

  • 链式存储结构的优点：
    结点空间可以动态申请和释放；
    数据元素的逻辑次序靠结点的指针来指示，插入和删除时不需要移动数据元素。

  • 链式存储结构的缺点：
    存储密度小，每个结点的指针域需额外占用存储空间。当每个结点的数据域所占字节不多时，指针域所占存储空间的比重显得很大。

    链式存储结构是非随机存取结构。对任一结点的操作都要从头指针依指针链查找到该结点，这增加了算法的复杂度。

存储密度是指结点数据本身所占的存储量和整个结点结构中
所占的存储量之比，即：
存储密度=-结点数据本身占用的空间 / 结点占用的空间总量

Dev晚风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构学习笔记(5.线性表之双向循环链表)
haierboos
08-26 105
在前两节的基础上，实现双向循环链表。 本节知识点： 1.双向循环链表的结构： 上面就是双向循环链表的结构图，对于双向链表的插入有3个位置，A、B、C。 但是在插入第一个元素的时候(其实插入第一个元素的时候，就是循环建立的时候)，有些特殊，所以就画了一个图，如下： 本节代码： DcLinkList.c： /************************************...
链表 -- 双向循环链表(线性表）
weixin_30678349的博客
09-05 99
1，双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 2,构建节点类 public class DNode<E> { Object item; DNode<E> ...
双向循环链表
鳄鱼儿
06-29 263
typedef int ElemType; /* 定义结点类型 */ typedef struct DuLNode { ElemType data; //数据域 DuLNode *prior; //直接前驱指针 DuLNode *next; //直接后继指针 } DuLNode,*DuLinkList; ...
线性表-双向循环链表
君上的博客
10-14 183
双向链表其实就是在单线链表上的基础上多加了一个前驱的结点，用来指向上一个元素的地址。
数据结构学习笔记 --- 线性表 （双向链表、循环链表）
whz_zb的专栏
02-05 2097
1. 引言 本文讨论双向链表、循环链表的一些基本操作。 2. 双向链表 2.1 双向链表的存储结构 typedef struct DuLNode { ElemType data; DuLNode *prior,*next; }DuLNode,*DuLinkList; 2.2 双向链表的基本操作（带头结点）
数据结构c版（1）-线性表之双向带头循环链表代码
最新发布
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
数据结构小练习-线性表（下）
06-25
线性表作为数据结构的基础类型，是我们理解和学习数据结构的起点。在本练习中，我们将聚焦线性表的下半部分，探讨其特性和常见操作。 线性表是由n（n≥0）个相同类型元素构成的有限序列，它可以顺序存储或链式存储...
数据结构-线性表09
01-20
线性表是数据结构中的基础概念，它是一个包含零个或多个数据元素的有限序列，这些元素遵循特定的顺序规则。在线性表中，每个元素要么是序列的开头（无直接前驱），要么位于中间（有一个直接前驱和一个直接后继），...
漫话数据结构-线性表的链式存储.pptx
11-03
同时，双链表和循环链表是单链表的变体，它们提供了更灵活的操作方式，比如双向遍历和循环访问。理解这些概念对于理解和实现复杂的数据结构，如树和图，以及在实际编程中优化算法性能都是至关重要的。
双向链表
Wenleon
09-29 512
双向链表的结点中有两个指针域：直接后继（next）和直接前驱（prior）。 空双向链表的判定：h->next = h->prior = h; 双向链表的结束判定：p->next = h。   #include #include #include #define OK 0 #define ERROR -1 typedef char elemtype; typedef str
小猪的数据结构辅助教程——2.7 线性表中的双向循环链表
热门推荐
Coder-Pig的猪栏
12-26 18万+
小猪的数据结构辅助教程——2.7 线性表中的双向循环链表标签（空格分隔）： 数据结构本节学习路线图与学习要点学习要点： 1.了解引入双向循环链表的原因 2.熟悉双向循环链表的特点以及存储结构 3.掌握双向循环链表的一些基本操作的实现逻辑 4.掌握逆序输出双向循环链表元素逻辑 1.双向循环链表的引入2.双向循环链表的存储结构双向循环链表的特点： 上面也说了，空间换时间，比起循
数据结构系列4-双循环链表
NICHUN12345的博客
11-17 530
实现功能： 双循环链表的创建 双循环链表的插入（头插法、尾插法） 双循环链表的删除 双循环链表的遍历 代码实现： //双循环链表 #include <stdio.h> #include <stdlib.h> //定义链表节点的结构体 typedef struct node_st { int data; //数据域 struct node_st *prev; //前驱指针 struct node_st *next; //后继指针 }list; /*
线性表（三）
qq_45878427的博客
02-03 1427
循环链表 循环链表是另-种形式的链式存储结构。其特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 由此，从表中任一-结点出发均可找到表中其他结点，图2.17所示为单链的循环链表。 循环单链表的操作和单链表基本一致，差别仅在于:当链表遍历时，判别当前指针p是否指向表尾结点的终止条件不同。在单链表中，判别条件为p!=NULL或p->next!=NULL.而循环单链表的判别条件为p...
(理解)单链表算法循环条件while(p)和while(p-＞next)有什么区别？
sunshine_r_007的博客
11-18 5367
【问题】 //在带头节点的单链表L中，删除指定位置i p = L; j = 1; while(p->next && j<i) { p = p->next; j++; } //在带头结点的单链表L中，指定位置i插入值e p = L; j = 1; while(p && j<i) { p = p->next; j++; } 单链表的删除算法中循环条件(p->next&&j<i)和插入
线性表——双向循环链表的C语言实现
qq_41536160的博客
12-17 618
在双向链表的结点中有两个指针域，一个指向直接后继， 另一个指向直接前驱。 双向循环链表的C语言实现 头文件 #include<stdio.h> #include<stdlib.h> //结果函数状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define MAXSIZE 100 //顺序表可能达到的最大长度
2.6循环单链表
WithoutEndFree的博客
05-23 926
2.6循环单链表 单链形式的循环链表结构是首尾相接的单链表，即最后一个结点的指针指 向链表的表头结点或第一个结点。 判别当前结点 p 是否为循环单链表 L 的表尾结点的判别条件： p->next!=L， 即 p->next 是否指回到头，与一般单链表 p->next 是否为 NULL 不同。 在循环单链表中，也可只设置一个头结点，这样，空循环链表仅由一个自成循环的头结点表示。 循环链表： 定义： 即首尾相接的链表。 结构： 尾结点的指针域指向头结点或表的首元结点； 特点：表中所有结点都链
DS第三篇(下)：线性表之链表——循环链表、双向链表、顺序表和链表的比较。
m0_46156900的博客
03-17 325
上接：DS第三篇(中)：线性表之链表——单链表 开篇口水话： 无论是学习单链表、还是循环、双向链表， 掌握 节点的“增、删”操作很重要，难的就是指针域的指来指去 不能乱序 循环链表 1.单链循环链表，如此定义 和单链表，大同小异 也就是在单链表基础上，最后一个结点的指针域，指向头结点（或者第一个结点） 2.于是乎，循环链表可以 从任意节点出发，都可以遍历其他结点 但，不能死循环。 那么就让循环单链表，结束循环判别条件：p->next !=L / p!=L 类似的，还有多重链的循环链表…
循序渐进学习数据结构之线性表
weixin_30408165的博客
11-26 199
一、思维导图 二、线性表的基本概念 1.名词解释： 线性表：由n个数据特性相同的元素构成的有限序列，有顺序存储和链式存储两种表示形式。 空表：线性表中元素的个数n=0的表。 线性表的链式存储结构：特点是用一组任意的存储单元存储线性表的数据元素，包括两个域，其中存储数据元素信息的域称为数据域，存储直接后继存储位置的域称为指针域。 循环单链表：是另一种形式的链式存储结构。它的特点是表中最后一个结点...
中国科学技术大学计算机学院数据结构课件-线性表详解
线性表的应用部分，强调了指针处理的关键性，如链表的合并与分解，有序表的合并，以及使用双向循环链表进行自身变换。这些操作在实际编程中非常常见，对于理解和掌握数据结构至关重要。 这份数据结构课件全面地介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值