4--Cycle Chain List

1, Basic Concepts

definition of a circular list: the last data element in a single linked list is Next The pointer points to the first element

The circular list has all the operations of a single-linked list:

Create a linked list

Destroy linked list

Get the chain table length

Empty list

Get the first POS element Operations

Insert element to position POS

Delete location POS the element at

Definition of Cursorsin a circular list, you can define a "current" pointer, which is often called a cursor that iterates through all the elements in a linked list.

New operation of circular list:

Gets the data element that the current cursor points to

Resets a cursor to the first data element in a linked list

Move the cursor to the next data element in the linked list

Directly specify to delete a data element in a linked list

2, design and implementation

Analysis of inserted elements

1. Normal position Insert Element
2. Add first element ( insert element for first time )
3. The last place to insert an element
4. First position insert Element ():

Add first element

Insert an element at the last position

Delete a node

3, advantages and disadvantages

Advantages: The function is strong. the circular link list is only on the basis of a single linked list to do a strengthening, the circular link list can completely replace the use of single-linked list, the Next and current list of loops operations can efficiently traverse all elements in a linked list

Disadvantages: code complexity has improved

Joseph Question-Typical application of circular list

N the individual is surrounded by a circle, first 1 individual from 1 start a person by a person clockwise, report to the first m individuals to make them out. And then from the next person starting from 1 clockwise count, report to the first m person, then make it out, ..., so go, ask for the order of the dequeue.

CircleList.h #ifndef _circlelist_h_#define _circlelist_h_typedef void circlelist;/*typedef struct _tag_circlelistnode Circlelistnode;struct _tag_circlelistnode{circlelistnode* next;}; */typedef struct _tag_circlelistnode{struct _tag_circlelistnode * NEXT;} Circlelistnode; circlelist* circlelist_create (); void Circlelist_destroy (circlelist* list); void Circlelist_clear (circlelist* list); int circlelist_length (circlelist* list), int circlelist_insert (circlelist* list, circlelistnode* node, int pos); circlelistnode* circlelist_get (circlelist* list, int pos); circlelistnode* circlelist_delete (circlelist* list, int pos);//addcirclelistnode* Circlelist_deletenode (CircleList* List, circlelistnode* node); circlelistnode* circlelist_reset (circlelist* list); circlelistnode* circlelist_current (circlelist* list); circlelistnode* circlelist_next (circlelist* list); #endif

Circlelist.c#include <stdio.h> #include <malloc.h> #include "CircleList.h" typedef struct _tag_circlelist{ Circlelistnode header; circlelistnode* Slider; int length;} Tcirclelist;  circlelist* circlelist_create ()//O (1) {tcirclelist* ret = (tcirclelist*) malloc (sizeof (tcirclelist)); if (ret = = NULL) { return NULL; } ret->length = 0; Ret->header.next = NULL; Ret->slider = NULL; return ret;} void Circlelist_destroy (circlelist* list)//O (1) {if (list = = NULL) {return;} free (list);}  void Circlelist_clear (circlelist* list)//O (1) {tcirclelist* sList = (tcirclelist*) list; if (sList = = NULL) {return;} slist->length = 0; Slist->header.next = NULL; Slist->slider = NULL;} int circlelist_length (circlelist* list)//O (1) {tcirclelist* sList = (tcirclelist*) list; int ret =-1; if (list = = NULL) {return ret;} RET = slist->length; return ret;} int Circlelist_insert (circlelist* list, circlelistnode* node, int pos)//O (n) {int ret = 0, i=0; tcirclelist* sList = (tcirclelist*) List; if (list = = NULL | | node== NULL | | pos<0) {return-1;}//if (ret) {circlelistnode* current = (circlelistnode*) sLi  St for (i=0; (I<pos) && (current->next! = NULL);  i++) {current = current->next; }//current->next the address of node # No. 0 node->next = current->next; 1 current->next = node;  2//If first insert node if (slist->length = = 0) {slist->slider = node;  } slist->length++; If the head interpolation if (current = = (circlelistnode*) sList) {//Gets the last element circlelistnode* = Circlelist_get (SList, Slist->l   ENGTH-1); Last->next = current->next; 3}} return ret;} circlelistnode* circlelist_get (circlelist* list, int pos)//O (n) {tcirclelist* sList = (tcirclelist*) list; circlelistnode* ret = NULL; int i = 0; if (List==null | | pos<0) {return NULL;}//if ((sList! = NULL) && (pos >= 0) && (slist->length  > 0) {circlelistnode* current = (circlelistnode*) sList; For (i=0, i<pos; i++) {current= current->next; } ret = current->next; } return ret;} circlelistnode* circlelist_delete (circlelist* list, int pos)//O (n) {tcirclelist* sList = (tcirclelist*) list; circlelistnode* ret = NULL; int i = 0; if (sList! = NULL) && (pos >= 0) && (slist->length > 0)) {circlelistnode* current = (Circleli  stnode*) SList;  circlelistnode* last = NULL;  For (i=0, i<pos; i++) {current = current->next;  }//If the first element is removed if (current = = (circlelistnode*) sList) {last = (circlelistnode*) circlelist_get (SList, Slist->length  -1);  }//To remove the element ret = current->next;  Current->next = ret->next;  slist->length--;   Determines whether the linked list is empty if (last! = NULL) {Slist->header.next = ret->next;  Last->next = ret->next;  }//If the element being deleted is the element that the cursor refers to if (Slist->slider = = ret) {Slist->slider = ret->next;   }//If the element is deleted, the list length is 0 if (slist->length = = 0) {slist->header.next = NULL;  Slist->slider = NULL; }} return ret;} Circlelistnode* Circlelist_deletenode (circlelist* list, circlelistnode* node)//O (n) {tcirclelist* sList = (tcirclelist*) list; circlelistnode* ret = NULL; int i = 0;   if (sList! = NULL) {circlelistnode* current = (circlelistnode*) sList; Find the position of node in the circular list I for (i=0; i<slist->length; i++) {if (Current->next = = node) {ret = Current->next    ;   Break  } current = current->next;  }//If RET finds, according to I go to remove if (ret! = NULL) {circlelist_delete (sList, i); }} return ret;} circlelistnode* circlelist_reset (circlelist* list)//O (1) {tcirclelist* sList = (tcirclelist*) list; circlelistnode* ret = NULL;  if (sList! = NULL) {Slist->slider = slist->header.next; RET = slist->slider; } return ret;} circlelistnode* circlelist_current (circlelist* list)//O (1) {tcirclelist* sList = (tcirclelist*) list; circlelistnode* ret = NULL; if (sList! = NULL) {ret = slist->slider;} return ret;} circlelistnode* circlelist_next (circlelist* list)//O (1) {tcirclelist* sList = (TCIRCLelist*) List; circlelistnode* ret = NULL;  if (sList! = null) && (Slist->slider! = null)) {ret = slist->slider; Slist->slider = ret->next; } return ret;}

#include <stdio.h> #include <stdlib.h> #include "CircleList.h" struct value{circlelistnode header; int v;}; void Main () {int i = 0; circlelist* list = Circlelist_create (); struct Value v1; struct Value v2; struct Value v3; struct Value v4; struct Value v5; struct Value V6; struct Value v7; struct Value V8; V1.V = 1; V2.V = 2; V3.V = 3; V4.V = 4; V5.V = 5; V6.V = 6; V7.V = 7; V8.V = 8; Circlelist_insert (list, (circlelistnode*) &v1, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v2, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v3, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v4, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v5, 5); Circlelist_delete (list, 0);  for (i=0; i<2*circlelist_length (list); i++) {struct value* PV = (struct value*) circlelist_get (list, i); printf ("%d\n", pv->v); } printf ("\ n"); while (Circlelist_length (list) > 0) {struct value* PV = (stRuct value*) circlelist_delete (list, 0); printf ("%d\n", pv->v); } printf ("\ n"); Circlelist_insert (list, (circlelistnode*) &v1, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v2, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v3, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v4, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v5, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v6, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v7, Circlelist_length (list)); Circlelist_insert (list, (circlelistnode*) &v8, Circlelist_length (list));  for (i=0; i<circlelist_length (list); i++) {struct value* PV = (struct value*) circlelist_next (list); printf ("%d\n", pv->v); } printf ("\ n"); Circlelist_reset (list);  while (Circlelist_length (list) > 0) {struct value* PV = NULL;  for (I=1; i<3; i++) {circlelist_next (list); } PV = (struct Value*) circlelist_current (list);  printf ("%d\n", pv->v); Circlelist_deletenode (list, (circlelistnode*) PV); } Circlelist_destroy (list); System ("pause"); return;}

4--Cycle Chain List