c語言實現--單向循環鏈表操做

1，什麼叫單向循環鏈表。單向循環鏈表是指在單鏈表的基礎上，表的最後一個元素指向鏈表頭結點，再也不是爲空。

2，由圖可知，單向循環鏈表的判斷條件再也不是表爲空了，而變成了是否到表頭。

3，鏈表的結點表示

1 struct LNode
2 {
3     int data;
4     struct LNode * next;
5 };
6 typedef struct LNode * linklist

4，單向循環鏈表的操做集合，還是defs.h裏的操做集合，這裏就不給出了。

5，單循環鏈表的初始化操做。示意圖

             

實現：

1 #include"defs.h"
2 
3 void InitList(linklist *L) //改變尾指針
4 {
5     *L = (linklist)malloc(sizeof(struct LNode)); //分配頭結點
6     if (*L == NULL) //分配失敗
7         exit(0);
8      (*L)->next = *L;  //指針域指向它自己
9 }

6，清空操做最終圖和初始化的結果是同樣的。

 1 #include"defs.h"
 2 
 3 void ClearList(linklist *L) //改變尾指針
 4 {
 5      linklist p, q;
 6      *L = (*L)->next;  //先令尾指針指向頭結點，否則釋放最後一個結點時尾指針，沒法指向頭結點 
 7     p = (*L)->next;  //p指向第一個結點
 8 
 9      while (p != *L) //p未到表頭時
10     {
11          q = p->next;
12          free(p);
13          p = q;
14      }
15      *L->next = *L; //頭結點指針域指向其自己
16 }

7，DestroyList操做。撤銷操做是在清空操做基礎上，釋放了頭結點。

1 #include"defs.h"
2 
3 void DestroyList(linklist *L)
4 {
5      ClearList(&L);
6      free(*L); //釋放頭結點
7     *L = NULL;
8 }

DestroyList.c

8，ListEmpty操做。

1 #include"defs.h"
2 
3 int ListEmpty(linklist L)
4 {
5      if (L->next == L)  //指針域指向它自己，確定就是空了，該結點即爲頭結點
6         return 0;
7      else 
8           return 1;   //非空爲1  
9 }

ListEmpty.c

9，ListLength操做

 1 #include"defs.h"
 2 
 3 int ListLength(linklist L)
 4 {
 5     linklist p = L->next->next;  //p指向第一個結點
 6    int j = 0;
 7 
 8     while (p != L->next) //p未到表頭時
 9    {
10         ++j;
11         p = p->next;
12     }
13     return j;
14 }

ListLength.c

10，GetElem操做

 1 #include"defs.h"
 2 
 3 void GetElem(linklist L, int i, int *e)
 4 {
 5     linklist p = L->next ; //p指向頭結點
 6    int j = 0;
 7     if (i<1 || i>ListLength(L)) //位置不合理
 8        exit(0);
 9     
10     while (j < i)  //位置合理，找到第i個結點
11     {
12         ++j;
13         p = p->next; 
14     }
15     *e = p->data;
16 }

GetElem.c

11，LocateElem操做

 1 #include"defs.h"
 2 
 3 int LocateElem(linklist L, int e)
 4 {
 5      linklist p = L->next->next; //p指向鏈表第一個元素
 6     int j = 0;   
 7 
 8     while (p != L->next) //p未到表頭時
 9     {
10          ++j;
11          if (p->data == e)
12              return j;
13          p = p->next;
14      } 
15     return -1;  //未找到，返回-1
16 }

LocateElem.c

12，PriorElem操做實現

 1 #include"defs.h"
 2 
 3 int PriorElem(linklist L, int cur_e, int *pri_e)
 4 {
 5     linklist p = L->next->next;  //p指向鏈表第一個元素
 6    linklist q;
 7 
 8      while (p != L->next)
 9      {
10          q = p->next;   //q指向p的後繼 
11          if (q != L->next && q->data == cur_e)
12          {
13                    *pri_e = p->data;
14                     return 0;
15          }
16          p = q;
17      }
18      return 0;
19 }

PriorElem.c

13，NextElem操做實現

 1 #include"defs.h"
 2 
 3 int NextElem(linklist L, int cur_e, int *Nex_e) //最後一個元素無後繼
 4 {
 5     linklist p = L->next->next;  //p指向第一個結點
 6    linklist q;
 7 
 8      while (p != L->next)
 9      {
10           q = p->next;
11           if (q != L->next && p->data == cur_e)
12           {
13                    *Nex_e = q->data;
14                     return 0;
15           }
16           p = q;
17      }
18      return 0;
19 }

NextElem.c

14，ListInsert操做實現

 1 #include"defs.h"
 2 
 3 int ListInsert(Linklist *L, int i, int e) //在表尾插入改變尾指針
 4 {
 5     linklist p = (*L)->next;  //p指向表頭
 6    linklist q, s;
 7    int j = 0;
 8 
 9     if (i<1 || i>ListLength(L)+1) //插入位置不合理
10         exit(0);
11      
12      while (j < i-1)  //位置合理，找到第i-1個結點
13      {
14           ++j;
15           p = p->next;
16      }    
17      q  = p->next; //q指向第i個結點
18     s = (linklist)malloc(sizeof(struct LNode));
19      s->data = e;
20      s->next = q;
21      q->next = s;
22      if (p == *L)  
23           *L  = s;
24 }

 15，ListDelete操做實現

 1 #include"defs.h"
 2 
 3 int ListDelete(linklist *L, int i, int *e)
 4 {
 5     linklist p = (*L)->next;
 6     linklist q;
 7     int j = 0;
 8     if (i<1 || i>ListLength(L))
 9         exit(0);
10     
11     while (j<i-1)  //找到第i-1個結點
12     {
13          ++j;
14          p = p->next;
15     }
16     q = p->next;  //q指向第i個結點
17    *e = q->data;
18     p->next = q->next;
19     if (q == *L)   //刪除的是表尾元素，表尾指針發生改變
20         *L = p;
21     free(q);
22     return 0;
23 }

16，TravelList操做實現

 1 #include"defs.h"
 2 
 3 void TravelList(linklist L)
 4 {
 5     linklist p = L->next->next;  //p指向第一個結點
 6    int j = 0;
 7 
 8     while (p != L->next)  //p未到表頭
 9    {
10         ++j;
11         printf("第%d個元素爲：%d\n", j, p->data);
12         p = p->next;
13     }
14 }

TravelList.c