数据结构上机实践第四周项目2 - 建设“单链表”算法库

 

本次实践的目的以多文件组织的形式建设“单链表算法库”，以便在后续的工程中使用。

文中的多文件组织方式不再细说，可以点击此处参照多文件组织建设的博文。

文件组织的文件视角如下：

 


依靠这个体系完成算法的构建

下面是main.cpp的文件源码（用于存放测试函数）

[cpp] view plain copy 01.<span style="color:#ff0000;">//*Copyright  (c)2017,烟台大学计算机与控制工程学院*        

02.//*All rights reservrd.*        

03.//*文件名称 ：linklist.h.cpp*        

04.//*作者：张文畅*     

05.//*完成时间：2017年9月28日*         

06.//*版本号：v1.0*     

07.//*问题描述:建立单链表算法构建头文件*        

08.//*输入描述:无*        

09.//*程序输出:无* 

10.#ifndef LINKLIST_H_INCLUDED 

11.#define LINKLIST_H_INCLUDED 

12. 

13.typedef int ElemType; 

14.typedef struct LNode        //定义单链表结点类型 

15.{ 

16.    ElemType data; 

17.    struct LNode *next;     //指向后继结点 

18.}LinkList; 

19.void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表 

20.void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表 

21.void InitList(LinkList *&L);  //初始化线性表 

22.void DestroyList(LinkList *&L);  //销毁线性表 

23.bool ListEmpty(LinkList *L);  //判断线性表是否为空 

24.int ListLength(LinkList *L);  //求线性表长度 

25.void DispList(LinkList *L);  //输出线性表 

26.bool GetElem(LinkList *L,int i,ElemType &e);  //求线性表某个数据元素值 

27.int LocateElem(LinkList *L,ElemType e);  //按元素值查找 

28.bool ListInsert(LinkList *&L,int i,ElemType e);  //插入数据元素 

29.bool ListDelete(LinkList *&L,int i,ElemType &e);  //删除数据元素 

30. 

31.#endif // LINKLIST_H_INCLUDED</span> 

 

下面是linklist.cpp的文件源码（用于存放各类实现函数）

[cpp] view plain copy 01.<span style="color:#ff0000;">//*Copyright  (c)2017,烟台大学计算机与控制工程学院*        

02.//*All rights reservrd.*        

03.//*文件名称 ：linklist.cpp*        

04.//*作者：张文畅*     

05.//*完成时间：2017年9月28日*         

06.//*版本号：v1.0*     

07.//*问题描述:建立单链表算法构建函数源文件*        

08.//*输入描述:无*        

09.//*程序输出:无* 

10.#include <stdio.h> 

11.#include <malloc.h> 

12.#include "linklist.h" 

13. 

14. 

15.void CreateListF(LinkList *&L,ElemType a[],int n)//头插法建立单链表 

16.{ 

17.    LinkList *s; 

18.    int i; 

19.    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点 

20.    L->next=NULL; 

21.    for (i=0; i<n; i++) 

22.    { 

23.        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点 

24.        s->data=a[i]; 

25.        s->next=L->next;            //将*s插在原开始结点之前,头结点之后 

26.        L->next=s; 

27.    } 

28.} 

29. 

30.void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法建立单链表 

31.{ 

32.    LinkList *s,*r; 

33.    int i; 

34.    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点 

35.    L->next=NULL; 

36.    r=L;                    //r始终指向终端结点,开始时指向头结点 

37.    for (i=0; i<n; i++) 

38.    { 

39.        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点 

40.        s->data=a[i]; 

41.        r->next=s;          //将*s插入*r之后 

42.        r=s; 

43.    } 

44.    r->next=NULL;           //终端结点next域置为NULL 

45.} 

46. 

47.void InitList(LinkList *&L) 

48.{ 

49.    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点 

50.    L->next=NULL; 

51.} 

52.void DestroyList(LinkList *&L) 

53.{ 

54.    LinkList *p=L,*q=p->next; 

55.    while (q!=NULL) 

56.    { 

57.        free(p); 

58.        p=q; 

59.        q=p->next; 

60.    } 

61.    free(p);    //此时q为NULL,p指向尾结点,释放它 

62.} 

63.bool ListEmpty(LinkList *L) 

64.{ 

65.    return(L->next==NULL); 

66.} 

67.int ListLength(LinkList *L) 

68.{ 

69.    LinkList *p=L; 

70.    int i=0; 

71.    while (p->next!=NULL) 

72.    { 

73.        i++; 

74.        p=p->next; 

75.    } 

76.    return(i); 

77.} 

78.void DispList(LinkList *L) 

79.{ 

80.    LinkList *p=L->next; 

81.    while (p!=NULL) 

82.    { 

83.        printf("%d ",p->data); 

84.        p=p->next; 

85.    } 

86.    printf("\n"); 

87.} 

88.bool GetElem(LinkList *L,int i,ElemType &e) 

89.{ 

90.    int j=0; 

91.    LinkList *p=L; 

92.    while (j<i
9bca
&& p!=NULL) 

93.    { 

94.        j++; 

95.        p=p->next; 

96.    } 

97.    if (p==NULL)            //不存在第i个数据结点 

98.        return false; 

99.    else                    //存在第i个数据结点 

100.    { 

101.        e=p->data; 

102.        return true; 

103.    } 

104.} 

105.int LocateElem(LinkList *L,ElemType e) 

106.{ 

107.    LinkList *p=L->next; 

108.    int n=1; 

109.    while (p!=NULL && p->data!=e) 

110.    { 

111.        p=p->next; 

112.        n++; 

113.    } 

114.    if (p==NULL) 

115.        return(0); 

116.    else 

117.        return(n); 

118.} 

119.bool ListInsert(LinkList *&L,int i,ElemType e) 

120.{ 

121.    int j=0; 

122.    LinkList *p=L,*s; 

123.    while (j<i-1 && p!=NULL) //查找第i-1个结点 

124.    { 

125.        j++; 

126.        p=p->next; 

127.    } 

128.    if (p==NULL)    //未找到位序为i-1的结点 

129.        return false; 

130.    else            //找到位序为i-1的结点*p 

131.    { 

132.        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s 

133.        s->data=e; 

134.        s->next=p->next;                        //将*s插入到*p之后 

135.        p->next=s; 

136.        return true; 

137.    } 

138.} 

139.bool ListDelete(LinkList *&L,int i,ElemType &e) 

140.{ 

141.    int j=0; 

142.    LinkList *p=L,*q; 

143.    while (j<i-1 && p!=NULL)    //查找第i-1个结点 

144.    { 

145.        j++; 

146.        p=p->next; 

147.    } 

148.    if (p==NULL)                //未找到位序为i-1的结点 

149.        return false; 

150.    else                        //找到位序为i-1的结点*p 

151.    { 

152.        q=p->next;              //q指向要删除的结点 

153.        if (q==NULL) 

154.            return false;           //若不存在第i个结点,返回false 

155.        e=q->data; 

156.        p->next=q->next;        //从单链表中删除*q结点 

157.        free(q);                //释放*q结点 

158.        return true; 

159.    } 

160.}</span> 

运行结果截图如下：