线性表->链式存储->循环链表

文字描述

  循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点,整个链表形成一个环。由此,从表中任一结点出发均可找到表中其他结点。

示意图

算法分析

插入、删除、查找等同单链表。

代码实现

  1 //
  2 // Created by lady on 19-1-27.
  3 //
  4
  5 #include <stdio.h>
  6 #include <stdlib.h>
  7
  8 //线性表的单向循环链表存储结构
  9 typedef struct ElemType{
 10     char data[10];
 11 }ElemType;
 12 typedef struct CNode{
 13     ElemType e;
 14     struct CNode *next;
 15 }CNode;
 16 typedef struct {
 17     CNode *head;//指向第一个指针
 18     CNode *tail;//指向最后一个指针
 19     int length;//表示链表数据元素个数
 20 }CLinkNode, *CLinkList;
 21
 22 //构造一个空的线性表
 23 static int InitList_CL(CLinkList *L)
 24 {
 25     (*L) = (CLinkList)malloc(sizeof(CLinkNode));
 26     (*L)->length = 0;
 27     (*L)->head = NULL;
 28     (*L)->tail = NULL;
 29 }
 30
 31 //销毁线性表
 32 static int Destory_CL(CLinkList *L)
 33 {
 34     if(L == NULL || (*L) == NULL){
 35         return -1;
 36     }
 37     CNode *p = (*L)->head;
 38     CNode *q;
 39     while(p){
 40         q = p;
 41         p = p->next;
 42         free(q);
 43         if(p == (*L)->head)
 44             break;
 45     }
 46     free(*L);
 47     (*L) = NULL;
 48 }
 49
 50 //返回1表示空, 0表示非空
 51 static int ListEmpty_CL(CLinkList L)
 52 {
 53     return L->length ? 0: 1;
 54 }
 55
 56 //返回线性表L中的数据元素个数
 57 static int ListLength_CL(CLinkList L)
 58 {
 59     return L->length;
 60 }
 61
 62 //在线性表末尾插入数据元素e
 63 static int ListInsert_CL(CLinkList *L,ElemType e)
 64 {
 65     CNode *new = (CNode *)malloc(sizeof(CNode));
 66     if(new == NULL){
 67         return -1;
 68     }
 69     CNode *p;
 70     new ->e = e;
 71     new->next = NULL;
 72     if(ListEmpty_CL(*L)){
 73         (*L)->length += 1;
 74         new->next = new;
 75         (*L)->head = new;
 76         (*L)->tail = new;
 77     }else{
 78         (*L)->length +=1;
 79         new->next = (*L)->head;
 80         (*L)->tail->next = new;
 81         (*L)->tail = new;
 82     }
 83     return 0;
 84 }
 85
 86 //删除L中的第loc个数据元素,并将被删元素的值存放在e中
 87 static int ListDelete_CL(CLinkList *L, int loc, ElemType *e)
 88 {
 89     CNode *p = (*L)->head;
 90     CNode *q = NULL;
 91     int i = 1;
 92     int f = 0;
 93     while(p){
 94         if(i == loc){
 95             f = 1;
 96             break;
 97         }
 98         i += 1;
 99         q = p;
100         p = p->next;
101         if(p == (*L)->head){
102             f = -1;
103             break;
104         }
105     }
106     if(f<1)
107         return -1;
108     (*L)->length -= 1;
109     (*e) = p->e;
110     if((*L)->length == 0){
111         free(p);
112         (*L)->head = NULL;
113         (*L)->tail = NULL;
114     }
115     if(q == NULL){
116         q = p->next;
117         free(p);
118         (*L)->tail->next = q;
119     }else{
120         q->next = p->next;
121         free(p);
122     }
123     return 0;
124 }
125
126 //依次对L的每个数据元素调用函数fun
127 static int ListTraverse_CL(CLinkList L, int (*fun)(ElemType,int), char note[])
128 {
129     printf("遍历循环链表%s:", note);
130     CNode *p = L->head;
131     int i = 0;
132     while(p){
133         if(fun(p->e, ++i)){
134             return -1;
135         }
136         p = p->next;
137         if(p == L->head)
138             break;
139     }
140     printf("\n");
141     return 0;
142 }
143
144 static int print(ElemType e, int loc)
145 {
146     printf("%3d=%-10s", loc, e.data);
147     return 0;
148 }
149
150 //创建一个长度为n的链表
151 static int CreateList_CL(CLinkList *L, int n, char note[])
152 {
153     printf("创建一个长度为%d的循环链表%s!\n", n, note);
154     InitList_CL(L);
155     ElemType e;
156     int i = 0;
157     for(i=0; i<n; i++){
158         printf("输入第%d个元素:", i+1);
159         scanf("%s[^\\n]", e.data);
160         ListInsert_CL(L, e);
161     }
162 }
163
164 int main(int argc, char *argv[])
165 {
166     CLinkList L;
167     ElemType e;
168     int location = 0;
169
170     CreateList_CL(&L, 5, "L:");
171     ListTraverse_CL(L, print, "L");
172
173     printf("输入删除元素的位置:");
174     scanf("%d", &location);
175     ListDelete_CL(&L, location, &e);
176     printf("位于%d的元素%s已经从循环链表中被删除!\n", location, e.data);
177     ListTraverse_CL(L, print, "L");
178
179     Destory_CL(&L);
180     return 0;
181 }

循环链表

代码运行

/home/lady/CLionProjects/untitled/cmake-build-debug/untitled
创建一个长度为5的循环链表L:!
输入第1个元素:WU
输入第2个元素:ZHENG
输入第3个元素:WANG
输入第4个元素:SUN
输入第5个元素:LI
遍历循环链表L:  1=WU          2=ZHENG       3=WANG        4=SUN         5=LI
输入删除元素的位置:2
位于2的元素ZHENG已经从循环链表中被删除!
遍历循环链表L:  1=WU          2=WANG        3=SUN         4=LI        

Process finished with exit code 0

原文地址:https://www.cnblogs.com/aimmiao/p/10392212.html

时间: 2024-11-08 00:17:12

线性表->链式存储->循环链表的相关文章

线性表—链式存储结构

链式存储结构就是一环扣一环的线性结构,好像链条中的每一个人都只知道下一个人的地址,只有从前往后顺序查找才能找到第 j 个人. 链式结构的好处是在插入和删除时不需要移动插入位置后面的元素,但要找到要插入和删除的元素的位置还是得像顺序存储结构一样查找,但这个查找还有所不同,顺序存储结构支持我们使用二分查找之类的方法进行查找插入以及删除的位置,至于链式结构感觉似乎没法使用二分法类似的方法(充分利用有序这一条件进行查找) 链式存储结构适合于插入删除操作比较多的场合,比如飞机航班的乘客信息,至于学校的学生

数据结构-线性表-链式存储

由于顺序表的插入.删除操作需要移动大量的元素,影响了运行效率,由此引入了线性表的链式存储. 链式存储线性表时,不需要使用地址连续的存储单元,即它不要求逻辑上相邻的两个元素在物理位置上也相邻,它是通过“链”建立起数据元素之间的逻辑关系. 因此,对线性表的插入.删除不需要移动元素,而只需要修改指针. 线性表的链式存储又称为单链表,它是指通过一组任意的存储单元来存储线性表中的数据元素.为了建立起数据元素之间的线性关系,对每个链表结点,除了存放元素自身的信息之外,还需要存放一个指向其后继的指针.单链表结

数据结构之线性表-链式存储之单链表(一)

本人文笔较差,语文从来不及格,基础不好,写此类文章仅供自己学习,理解队列及其他知识,高手大神请略过.参考书籍 <数据结构与算法分析-Java语言描述 1.1 单链表简介 线性表的最大的缺点就是插入和删除操作需要移动大量的元素,这是它在内存中的连续存储结构造成的.为了弥补这2个缺点,就出现了链表,即线性表的链式存储. 链表是由一系列的几点组成,这些节点不必在内存中相连.这就意味着元素可以存在内存未被占用的任意位置.如图 这个存储可以想象成元素在内存中成三维空间存储,他们之间可没有像数组那样的下标标

数据结构之线性表-链式存储之静态链表(二)

本人文笔较差,语文从来不及格,基础不好,写此类文章仅供自己学习,理解队列及其他知识,高手大神请略过.参考书籍 <数据结构与算法分析-Java语言描述>.<大话数据结构> 1.1 静态链表简介 用数组描述的链表叫静态链表.官方是这么给的定义.另一种描述方法叫游标实现法.先不管这些无聊的定义.先按我个人理解描述,再来个Java版的实现比较符合我的风格.另有一些树上说早期存在其他的高级语言没有对象,引用或者指针这样的东西,但是需要对于快插快删等批量操作的这种链式存储,这时候静态链表就起了

第三章 线性表---链式存储结构(循环链表)

将单链表中终端结点的指针端由空指针改为指向头结点,就使整个单链表形成一个环,这种头尾相接的单链表称为单循环链表,简称循环链表(circular linked list) 结构模型

线性表 链式存储实现

基本操作 Node* applyNode();   //分配节点Node* addNodeH(Node* Head,Node* InsertNode);       //在头部添加节点Node* addNodeT(Node* Head,Node* InsertNode);       //在尾部添加节点Node* addNodeSort(Node* Head, Node* InsertNode);   //以升序方式添加节点 Node* createList(int n,int choose);

大话数据结构——线性表-链式存储之头插法创建链表

1 #include<iostream> 2 3 #include<time.h> 4 #include <stdlib.h> 5 6 using namespace std; 7 8 #define OK 1 9 #define TRUE 1 10 #define FALSE 0 11 #define ERROR 0 12 13 typedef int status;//返回的状态值 14 typedef int elemtype;//节点里数据的类型 15 16 /

(源代码见大话数据结构)线性表—链式存储结构-&gt;单链表的删除ListDelet(*L,i,*e)

Status ListDelet(LinkList *L,int i,ElemType *e) { int j=1; LinkList p,s; p=*L; while(p&&j<i) { p=p->next; j++; } if(!p||j>i) return ERROR; s=p->next; *e=s->data; p->next=s->next; free(s); return OK; } 个人理解:建立一个新结点可以作为(i-1)个结点的

线性表—链式存储结构—单链表的创建CreasteListHead(*L,int n)-&gt;头插法

void CreasteListHead(LinkList *L,int n) { int i; LinkList p; srand(time(0)); *L=(LinkList)malloc(sizeof(Node)); (*L)->next=NULL;//优先级->大于* !!!!!!!!!!!!! for(i=0;i<n;i++) { p=(Node *)malloc(sizeof(Node)); p->data=rand()%100+1;//1~100之间的数包括一百所以+