双循环链表

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3
  4 #define OK 1
  5 #define ERROR 0
  6
  7 typedef int Elemtype;
  8 typedef int Status;
  9
 10 typedef struct Node{
 11     Elemtype data;
 12     struct Node* prior;
 13     struct Node* next;
 14 }Node;
 15 typedef struct Node* DolLinkList;
 16
 17 Status InitDolLinkList(DolLinkList *DL){
 18     *DL = (DolLinkList)malloc(sizeof(struct Node));
 19     if(!(*DL))
 20         return ERROR;
 21     (*DL)->next = *DL;
 22     (*DL)->prior = *DL;
 23     return OK;
 24 }
 25 Status ClearDolLinkList(DolLinkList DL){
 26 //将双向循环链表清为空表
 27     DolLinkList s,f = DL->next;
 28     while(f != DL){
 29         s = f;
 30         f = f->next;
 31         free(s);
 32     }
 33     DL->next = DL;
 34     DL->prior = DL;
 35     return OK;
 36 }
 37 Status DestoryDolLinkList(DolLinkList DL){
 38     ClearDolLinkList(DL);
 39     free(DL);
 40     DL = NULL;
 41 }
 42 int Length_DolLinkList(DolLinkList DL){
 43     int length = 0;
 44     DolLinkList t = DL->next;
 45     while(t != DL){
 46         t = t->next;
 47         length++;
 48     }
 49     return length;
 50 }
 51 Status GetElement_DolLinkList(DolLinkList DL,int position,int *value){
 52     int count = 0;
 53     int length = Length_DolLinkList(DL);
 54     if(position < 1 || position > length){
 55         return ERROR;
 56     }
 57     else{
 58         while(count < position){
 59             DL = DL->next;
 60             count++;
 61         }
 62         *value = DL->data;
 63         return OK;
 64     }
 65 }
 66 Status LocateElement_DolLinkList(DolLinkList DL,Elemtype value,int *position){
 67     *position = 1;
 68     DolLinkList t = DL->next;
 69     while(t != DL){
 70         if(t->data == value){
 71             return OK;
 72         }
 73         t = t->next;
 74         (*position)++;
 75     }
 76     return ERROR;
 77 }
 78 Status GetPriorElement_DolLinkList(DolLinkList DL,int currentElement,int *priorElement){
 79     int r1;
 80     int count = 0;
 81     if(LocateElement_DolLinkList(DL,currentElement,&r1)){
 82         while(count < r1){
 83             count++;
 84             DL = DL->next;
 85         }
 86         if(count == 1)
 87             *priorElement = DL->prior->prior->data;
 88         else
 89             *priorElement = DL->prior->data;
 90         return OK;
 91     }
 92     else
 93         return ERROR;
 94 }
 95 Status GetNextElement_DolLinkList(DolLinkList DL,int currentElement,int *nextElement){
 96     int r1;
 97     if(LocateElement_DolLinkList(DL,currentElement,&r1)){
 98         int count = 0;
 99         while(count < r1){
100             count++;
101             DL = DL->next;
102         }
103         if(count == Length_DolLinkList(DL))
104             *nextElement = DL->next->next->data;
105         else
106             *nextElement = DL->next->data;
107         return OK;
108     }
109     else
110         return ERROR;
111 }
112 Status Insert_DolLinkList(DolLinkList DL,int position,int value){
113     if(position < 1 || position > Length_DolLinkList(DL) + 1)
114         return ERROR;
115     else{
116         int count = 0;
117         while(count < position){
118             count++;
119             DL = DL->next;
120         }
121         DolLinkList new = (DolLinkList)malloc(sizeof(struct Node));
122         new->data = value;
123         new->prior = DL->prior;
124         DL->prior->next = new;
125         new->next = DL;
126         DL->prior = new;
127         return OK;
128     }
129 }
130 Status Delete_DolLinkList(DolLinkList DL,int position,int *value){
131     if(position < 1 || position > Length_DolLinkList(DL))
132         return ERROR;
133     else{
134         int count = 0;
135         while(count < position){
136             count++;
137             DL = DL->next;
138         }
139         *value = DL->data;
140         DL->next->prior = DL->prior;
141         DL->prior->next = DL->next;
142         free(DL);
143     }
144 }
145 Status CreateDolLinkList_TailInsert(DolLinkList DL,int number){
146     DolLinkList new;
147     int i;
148     printf("PLEASE ENTER %d ELEMNET!\n",number);
149     for(i = 1; i <= number; i++){
150         new = (DolLinkList)malloc(sizeof(struct Node));
151         if(!new)
152             return ERROR;
153         printf("please enter element%d:   ",i);
154         scanf("%d",&(new->data));
155         new->prior = DL->prior;
156         new->next = DL;
157         DL->prior->next = new;
158         DL->prior = new;
159     }
160     return OK;
161 }
162 void DisplayDolLinkList(DolLinkList DL){
163     DolLinkList temp = DL;
164     while(temp->next != DL){
165         temp = temp->next;
166         printf("%d ",temp->data);
167     }
168     printf("\nDisplay Executed!\n\n");
169 }
170 int main(){
171     DolLinkList DL;
172     InitDolLinkList(&DL);
173     CreateDolLinkList_TailInsert(DL,5);
174     printf("the length of list is %d\n",Length_DolLinkList(DL));
175     DisplayDolLinkList(DL);
176
177     int r1,r2;
178     if(GetElement_DolLinkList(DL,3,&r1))
179         printf("the element of postion 3 is %d\n",r1);
180     else
181         printf("Error:getElement:position\n");
182     if(GetElement_DolLinkList(DL,6,&r2))
183         printf("the element of postion 6 is %d\n",r2);
184     else
185         printf("Error:getElement:position\n");
186
187     if(LocateElement_DolLinkList(DL,4,&r1))
188         printf("the position of element 4 is %d\n",r1);
189     else
190         printf("Error:LocateElement:value\n");
191     if(LocateElement_DolLinkList(DL,8,&r1))
192         printf("the position of element 8 is %d\n",r1);
193     else
194         printf("Error:LocateElement:value\n");
195
196     if(GetPriorElement_DolLinkList(DL,6,&r1))
197         printf("before the 6 is %d\n",r1);
198     else
199         printf("Error:GetPriorElement:currentElement\n");
200     if(GetPriorElement_DolLinkList(DL,1,&r2))
201         printf("before the 1 is %d\n",r2);
202     else
203         printf("Error:GetPriorElement:currentElement\n");
204
205     if(GetNextElement_DolLinkList(DL,2,&r1))
206         printf("next the 2 is %d\n",r1);
207     else
208         printf("Error:nextElement:currentElement\n");
209     if(GetNextElement_DolLinkList(DL,5,&r1))
210         printf("next the 5 is %d\n",r1);
211     else
212         printf("Error:nextElement:currentElement\n");
213
214     Insert_DolLinkList(DL,3,666);
215     Insert_DolLinkList(DL,7,999);
216     Insert_DolLinkList(DL,1,111);
217     Insert_DolLinkList(DL,9,2222);
218     DisplayDolLinkList(DL);
219
220     Delete_DolLinkList(DL,2,&r1);
221     Delete_DolLinkList(DL,8,&r1);
222     DisplayDolLinkList(DL);
223     return 0;
224 }

时间: 2024-10-05 10:57:15

双循环链表的相关文章

双循环链表(包含头指针与尾指针)

双循环链表(包含头指针与尾指针) 以及基本功能的实现 list_ d_link_c.h #ifndef _LIST_D_LINK_C_ #define _LIST_D_LINK_C_ #include<iostream> #include<assert.h> using namespace std; #define ElemType int typedef struct Node { ElemType data; struct Node *prio; struct Node *ne

编程算法 - 有序双循环链表的插入 代码(C)

有序双循环链表的插入 代码(C) 本文地址: http://blog.csdn.net/caroline_wendy 有序双循环链表的插入, 需要找到插入位置, 可以采用, 两个指针, 一个在前, 一个在后. 保证前面的小于等于插入值, 后面的大于等于插入值. 特殊情况, 首尾插入(大于或小于整个链表)或单节点, 判断条件为后指针指向首节点. 则需要直接插入. 插入链表头, 需要调整链表头节点. 代码22行. 代码: /* * main.cpp * * Created on: 2014.9.18

循环链表之双循环链表

接着上一篇博文http://12172969.blog.51cto.com/12162969/1918256,把循环链表里的双循环链表的基本操纵按照我个人的理解进行总结一下. 依然沿袭过去的风格,进入双循环链表之前,先提另一种结构,双向链表,先有了双向链表再有了双循环链表.这两种结构和单链表一样都有带头结点和不带头结点之分.我们先来看一下这几种结构的结构图: 双链表 双循环链表 既然单向链表有普通的链表也就是不循环的链表.那么双向链表也一样,也有普通的双向链表和双向循环链表:也有带头结点,不带头

【数据结构】双循环链表(c++)

头文件: #pragma once #include <iostream> #include <assert.h> using namespace std; template<class Type> class List; // 结点类 template<class Type> class NodeList { friend class List<Type>; public: NodeList(); NodeList(Type d, NodeLi

双循环链表(C++)

#ifndef _DCLIST_ #define _DCLIST_ #include<iostream> using namespace std; #include<assert.h> template <class Type>class DCList; template<class Type> class Node { friend class DCList<Type>; public: Node():data(0),prio(NULL),ne

数据结构之—线性表之—双向链表之—浅谈双循环链表

双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱.所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点.一般我们都构造双向循环链表. /********************************************************************** * Copyright (c)2015,WK Studios * Filename: Tw_Node.c * Compiler: GCC,VS,VC6.

【数据结构】用C++实现双循环链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等)

//[数据结构]用C++实现单循环链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等) //头文件 #ifndef _CDLIST_H #define _CDLIST_H #include<iostream> using namespace std; template<class Type> class CDList; template<class Type> class ListNode { friend class CDList<Type>; p

C语言数据结构——双循环链表的插入操作顺序

双向链表与单链表的插入操作的区别 双向链表因为存在前驱指针和后继指针所以需要修改的指针多于单链表,但指针改动的顺序同样重要 单链表的插入 eg:在节点p的后面插入指针s s->next=p->next;//首先要使要插入的指针指向p->next p->next=s;//再将p的后继指向插入的s即可 注意! 顺序不能调换,否则在将p->next指向s后,原来由p->next指向的节点将会迷失在内存中,很难找到! 双向循环链表的插入 eg:将新的节点插入p节点的后面 s-&

双循环链表遍历

void CPage1::RenWuBL(DWORD base) { DWORD pFirstNode=base; wchar_t *name; char * aa=""; _try { DWORD pNextNode = pFirstNode; while (pFirstNode != *(DWORD *)pNextNode) { name=GetAroundName(pNextNode); USES_CONVERSION; aa=W2A((LPCWSTR)name); TRACE(