第四周项目三 单链表应用-单链表递增

问题及代码：

1. /*    
2. *烟台大学计算机与控制工程学院     
3. *作    者：申鹏鹏
4. *完成日期：2016年9月24日 
5. *问题描述:设计一个算法，判断单链表L是否是递增的。实现这个算法，并完成测试。 
6. */

1、list.h的代码

1. #ifndef LINKLIST_H_INCLUDED  
2. #define LINKLIST_H_INCLUDED  
3.   
4. #include <stdio.h>  
5. #include <malloc.h>  
6. typedef int ElemType;  
7. typedef struct LNode        //定义单链表结点类型  
8. {  
9.     ElemType data;  
10.     struct LNode *next;     //指向后继结点  
11. }LinkList;  
12. void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表  
13. void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表  
14. void InitList(LinkList *&L);  //初始化线性表  
15. void DestroyList(LinkList *&L);  //销毁线性表  
16. bool ListEmpty(LinkList *L);  //判断线性表是否为空  
17. int ListLength(LinkList *L);  //求线性表长度  
18. void DispList(LinkList *L);  //输出线性表  
19. bool GetElem(LinkList *L,int i,ElemType &e);  //求线性表某个数据元素值  
20. int LocateElem(LinkList *L,ElemType e);  //按元素值查找  
21. bool ListInsert(LinkList *&L,int i,ElemType e);  //插入数据元素  
22. bool ListDelete(LinkList *&L,int i,ElemType &e);  //删除数据元素  
23. bool increase(LinkList *L);  
24.   
25. #endif // LINKLIST_H_INCLUDED

2、list.cpp的代码

1. #include"list.h"    
2. void CreateListF(LinkList *&L,ElemType a[],int n)//头插法建立单链表    
3. {    
4.     LinkList *s;    
5.     int i;    
6.     L=(LinkList *)malloc(sizeof(LinkList));    
7.     L->next=NULL;//创建头结点，其next域为NULL    
8.     for(i=0;i<n;i++)    
9.     {    
10.         s=(LinkList *)malloc(sizeof(LinkList));    
11.         s->data=a[i];//创建数据节点*s    
12.         s->next=L->next;    
13.         L->next=s;    
14.     }    
15. }    
16. void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法建立单链表    
17. {    
18.         LinkList *s,*r;    
19.         int i;    
20.         L=(LinkList *)malloc(sizeof(LinkList));    
21.         r=L;    
22.         for(i=0;i<n;i++)    
23.         {    
24.             s=(LinkList *)malloc(sizeof(LinkList));    
25.             s->data=a[i];//创建数据节点*s    
26.             r->next=s;//将*s插在*r之后    
27.             r=s;    
28.         }    
29.         r->next=NULL;    
30. }    
31.     
32.     
33.     
34.     
35. void InitList(LinkList *&L) //初始化线性表    
36. {    
37.     L=(LinkList *)malloc(sizeof(LinkList));    
38.     L->next=NULL;    
39. }    
40. void DestroyList(LinkList *&L)//销毁线性表    
41. {    
42.     LinkList *p=L,*q=p->next;    
43.     while (q!=NULL)    
44.     {    
45.         free(p);    
46.         p=q;    
47.         q=p->next;    
48.     }    
49.     free(p);    //此时q为NULL,p指向尾结点,释放它    
50. }    
51. bool ListEmpty(LinkList *L)  //判断线性表是否为空    
52. {    
53.     return(L->next==NULL);    
54. }    
55. int ListLength(LinkList *L) //求线性表长度    
56. {    
57.     int n=0;    
58.     LinkList *p=L;    
59.     while(p->next!=NULL)    
60.     {    
61.         n++;    
62.         p=p->next;    
63.     }    
64.     return (n);    
65. }    
66.     
67. bool GetElem(LinkList *L,int i,ElemType &e)  //求线性表某个数据元素值    
68. {    
69.     int j=0;    
70.     LinkList *p=L;    
71.     while(j<i&&p!=NULL)    
72.     {    
73.         j++;    
74.         p->next;    
75.     }    
76.     if(p==NULL)    
77.         return false;    
78.     else    
79.     {    
80.         e=p->data;    
81.         return true;    
82.     }    
83. }    
84.     
85. int LocateElem(LinkList *L,ElemType e)  //按元素值查找    
86. {    
87.     int i=1;    
88.     LinkList *p=L->next;    
89.     while(p!=NULL&&p->data!=e)    
90.     {    
91.         p=p->next;    
92.         i++;    
93.     }    
94.     if(p==NULL)    
95.         return (0);    
96.     else    
97.         return(i);    
98. }    
99.     
100. bool ListInsert(LinkList *&L,int i,ElemType e)  //插入数据元素    
101. {    
102.     int j=0;    
103.     LinkList *p=L,*s;//p指向头结点，j置为0    
104.     while(j<i-1&&p!=NULL)    
105.     {    
106.         j++;    
107.         p=p->next;    
108.     }    
109.     if(p==NULL)    
110.         return false;    
111.     else    
112.     {    
113.         s=(LinkList *)malloc(sizeof(LinkList));    
114.         s->data=e;    
115.         s->next=p->next;    
116.         p->next=s;    
117.         return true;    
118.     }    
119. }    
120.     
121. bool ListDelete(LinkList *&L,int i,ElemType &e)  //删除数据元素    
122. {    
123.     int j=0;    
124.     LinkList *p=L,*q;    
125.     while(j<i-1&&p!=NULL)    
126.     {    
127.         j++;    
128.         p=p->next;    
129.     }    
130.     if(p==NULL)    
131.         return false;    
132.     else    
133.     {    
134.         q=p->next;    
135.         if(q==NULL)    
136.             return false;    
137.         e=q->data;    
138.         p->next=q->next;    
139.         free(q);    
140.         return true;    
141.     }    
142. }    
143. void DispList(LinkList *L)  //输出单链表    
144. {    
145.     LinkList *p=L->next;//p开始指向节点    
146.     while(p!=NULL)    
147.     {    
148.         printf("%d ",p->data);    
149.         p=p->next;    
150.     }    
151.     printf("\n");    
152. }    
153. bool increase(LinkList *L)    
154. {    
155.     LinkList *p=L->next,*q;    
156.     if(p!=NULL)    
157.     {    
158.         while(p->next!=NULL)    
159.         {    
160.             q=p->next;//q是p的后继    
161.         if(q->data>p->data) //只要是递增的，就继续考察其后继    
162.     
163.             p=q;    
164.         else    
165.             return false;//只要有一个不是后继大于前驱，便不是递增    
166.     
167.         }    
168.     }    
169.     return true;    
170. }

3、main函数的代码

1. #include"list.h"    
2. int main()    
3. {    
4.     LinkList *A, *B;    
5.     int i;    
6.     ElemType a[]= {1, 3, 2, 9};    
7.     ElemType b[]= {0, 4, 5 ,6, 7, 8};    
8.     InitList(A);    
9.     for(i=3; i>=0; i--)    
10.         ListInsert(A, 1, a[i]);    
11.     InitList(B);    
12.     for(i=5; i>=0; i--)    
13.         ListInsert(B, 1, b[i]);    
14.     printf("A: %c\n", increase(A)?'Y':'N');    
15.     printf("B: %c\n", increase(B)?'Y':'N');    
16.     DestroyList(A);    
17.     DestroyList(B);    
18.     return 0;    
19. }

运行结果：