单链表

  1. #include "stdio.h"
  2. #include "string.h"
  3. #include "ctype.h"
  4. #include "stdlib.h"
  5. #include "math.h"
  6. #include "time.h"
  8. #define OK 1
  9. #define ERROR 0
  10. #define TRUE 1
  11. #define FALSE 0
  12. #define MAXSIZE 20     /* 存储空间初始分配量 */
  14. typedef int Status;    /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  15. typedef int ElemType;  /* ElemType类型根据实际情况而定，这里假设为int */
  17. typedef struct Node {  /* 线性表的单链表存储结构 */
  18. 	ElemType data;
  19. 	struct Node *next;
  20. } Node;
  22. typedef struct Node *LinkList; /* 定义LinkList */
  24. /*打印某个数*/
  25. Status visit(ElemType c) {
  26. 	printf("%d ", c);
  27. 	return OK;
  28. }
  30. /* 初始化顺序线性表 */
  31. //申请的结果有两种
  32. //1、失败：return ERROR
  33. //2、成功：设定指针域为空、return OK
  34. Status InitList(LinkList *L) {
  35. 	*L = (LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
  36. 	if (!(*L)) /* 存储分配失败 */
  37. 		return ERROR;
  38. 	(*L)->next = NULL; /* 指针域为空 */
  39. 	return OK;
  40. }
  42. /* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
  43. Status ListEmpty(LinkList L) {
  44. 	if (L->next)
  45. 		return FALSE;
  46. 	else
  47. 		return TRUE;
  48. }
  50. /* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
  51. Status ClearList(LinkList *L) {
  52. 	LinkList p, q;
  53. 	p = (*L)->next;         /*  p指向第一个结点 */
  54. 	while (p)               /*  没到表尾 */
  55. 	{
  56. 		q = p->next;        /*  用q保存p的下一节点*/
  57. 		free(p);            /*  释放p节点的空间*/
  58. 		p = q;
  59. 	}
  60. 	(*L)->next = NULL;      /*  最后，头结点指针域为空 */
  61. 	return OK;
  62. }
  64. /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
  65. int ListLength(LinkList L) {
  66. 	int i = 0;              /* 计数器 */
  67. 	LinkList p = L->next;   /* important：p指向第一个结点 */
  68. 	while (p) {
  69. 		i++;
  70. 		p = p->next;
  71. 	}
  72. 	return i;
  73. }
  75. /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
  76. /* 操作结果：用e返回L中第i个数据元素的值 */
  77. Status GetElem(LinkList L, int i, ElemType *e) {
  78. 	int j;
  79. 	LinkList p;  /* 声明一结点p */
  80. 	p = L->next; /* 让p指向链表L的第一个结点 */
  81. 	j = 1;       /* j为计数器 */
  82. 	while (p && j < i) /* p不为空或者计数器j还没有等于i时，循环继续 */
  83. 	{
  84. 		p = p->next;   /* 让p指向下一个结点 */
  85. 		++j;
  86. 	}
  87. 	if (!p || j > i)
  88. 		return ERROR; /*  第i个元素不存在 */
  89. 	*e = p->data;     /*  取第i个元素的数据 */
  90. 	return OK;
  91. }
  93. /* 初始条件：顺序线性表L已存在 */
  94. /* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
  95. /* 若这样的数据元素不存在，则返回值为0 */
  96. int LocateElem(LinkList L, ElemType e) {
  97. 	int i = 0;
  98. 	LinkList p = L->next;
  99. 	while (p) {
  100. 		i++;
  101. 		if (p->data == e) /* 找到这样的数据元素 */
  102. 			return i;
  103. 		p = p->next;
  104. 	}
  106. 	return 0;
  107. }
  109. /* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
  110. /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
  111. Status ListInsert(LinkList *L, int i, ElemType e) {
  112. 	int j;
  113. 	LinkList p, s;
  114. 	p = *L;
  115. 	j = 1;
  116. 	while (p && j < i) /* 寻找第i个结点 */
  117. 	{
  118. 		p = p->next;
  119. 		++j;
  120. 	}
  121. 	if (!p || j > i)
  122. 		return ERROR; /* 第i个元素不存在 */
  126. 	s = (LinkList)malloc(sizeof(Node)); /*  生成新结点(C语言标准函数) */
  127. 	s->data = e;
  128. 	s->next = p->next; /* 将p的后继结点赋值给s的后继  */
  129. 	p->next = s; /* 将s赋值给p的后继 */
  130. 	return OK;
  131. }
  133. /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
  134. /* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
  135. Status ListDelete(LinkList *L, int i, ElemType *e) {
  136. 	int j;
  137. 	LinkList p, q;
  138. 	p = *L;
  139. 	j = 1;
  140. 	while (p->next && j < i) /* 遍历寻找第i个元素 */
  141. 	{
  142. 		p = p->next;
  143. 		++j;
  144. 	}
  145. 	if (!(p->next) || j > i)
  146. 		return ERROR; /* 第i个元素不存在 */
  147. 	//插入和删除的前面这部分相同。
  150. 	q = p->next;
  151. 	p->next = q->next; /* 将q的后继赋值给p的后继 */
  152. 	*e = q->data; /* 将q结点中的数据给e */
  153. 	free(q); /* 让系统回收此结点，释放内存 */
  154. 	return OK;
  155. }
  157. /* 初始条件：顺序线性表L已存在 */
  158. /* 操作结果：依次对L的每个数据元素输出 */
  159. Status ListTraverse(LinkList L) {
  160. 	LinkList p = L->next;
  161. 	while (p) {
  162. 		visit(p->data);
  163. 		p = p->next;
  164. 	}
  165. 	printf("
");
  166. 	return OK;
  167. }
  169. /*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
  170. void CreateListHead(LinkList *L, int n) {
  171. 	LinkList p;
  172. 	int i;
  173. 	srand(time(0)); /* 初始化随机数种子 */
  174. 	*L = (LinkList)malloc(sizeof(Node));
  175. 	(*L)->next = NULL; /*  先建立一个带头结点的单链表 */
  176. 	for (i = 0; i < n; i++) {
  177. 		p = (LinkList)malloc(sizeof(Node)); /*  生成新结点 */
  178. 		p->data = rand() % 100 + 1; /*  随机生成100以内的数字 */
  179. 		p->next = (*L)->next;
  180. 		(*L)->next = p; /*  插入到表头 */
  181. 	}
  182. }
  184. /*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
  185. void CreateListTail(LinkList *L, int n) {
  186. 	LinkList p, r;
  187. 	int i;
  188. 	srand(time(0)); /* 初始化随机数种子 */
  189. 	*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
  190. 	r = *L; /* r为指向尾部的结点 */
  191. 	for (i = 0; i < n; i++) {
  192. 		p = (Node *)malloc(sizeof(Node)); /*  生成新结点 */
  193. 		p->data = rand() % 100 + 1; /*  随机生成100以内的数字 */
  194. 		r->next = p; /* 将表尾终端结点的指针指向新结点 */
  195. 		r = p; /* 将当前的新结点定义为表尾终端结点 */
  196. 	}
  197. 	r->next = NULL; /* 表示当前链表结束 */
  198. }
  200. int main() {
  201. 	LinkList L;
  202. 	ElemType e;
  203. 	Status i;
  204. 	int j, k;
  205. 	i = InitList(&L);
  206. 	printf("初始化L后：ListLength(L)=%d
", ListLength(L));
  207. 	for (j = 1; j <= 5; j++)
  208. 		i = ListInsert(&L, 1, j);
  209. 	printf("在L的表头依次插入1～5后：L.data=");
  210. 	ListTraverse(L);
  212. 	printf("ListLength(L)=%d 
", ListLength(L));
  213. 	i = ListEmpty(L);
  214. 	printf("L是否空：i=%d(1:是 0:否)
", i);
  216. 	i = ClearList(&L);
  217. 	printf("清空L后：ListLength(L)=%d
", ListLength(L));
  218. 	i = ListEmpty(L);
  219. 	printf("L是否空：i=%d(1:是 0:否)
", i);
  221. 	for (j = 1; j <= 10; j++)
  222. 		ListInsert(&L, j, j);
  223. 	printf("在L的表尾依次插入1～10后：L.data=");
  224. 	ListTraverse(L);
  226. 	printf("ListLength(L)=%d 
", ListLength(L));
  228. 	ListInsert(&L, 1, 0);
  229. 	printf("在L的表头插入0后：L.data=");
  230. 	ListTraverse(L);
  231. 	printf("ListLength(L)=%d 
", ListLength(L));
  233. 	GetElem(L, 5, &e);
  234. 	printf("第5个元素的值为：%d
", e);
  235. 	for (j = 3; j <= 4; j++) {
  236. 		k = LocateElem(L, j);
  237. 		if (k)
  238. 			printf("第%d个元素的值为%d
", k, j);
  239. 		else
  240. 			printf("没有值为%d的元素
", j);
  241. 	}
  243. 	k = ListLength(L); /* k为表长 */
  244. 	for (j = k + 1; j >= k; j--) {
  245. 		i = ListDelete(&L, j, &e); /* 删除第j个数据 */
  246. 		if (i == ERROR)
  247. 			printf("删除第%d个数据失败
", j);
  248. 		else
  249. 			printf("删除第%d个的元素值为：%d
", j, e);
  250. 	}
  251. 	printf("依次输出L的元素：");
  252. 	ListTraverse(L);
  254. 	j = 5;
  255. 	ListDelete(&L, j, &e); /* 删除第5个数据 */
  256. 	printf("删除第%d个的元素值为：%d
", j, e);
  258. 	printf("依次输出L的元素：");
  259. 	ListTraverse(L);
  261. 	i = ClearList(&L);
  262. 	printf("
清空L后：ListLength(L)=%d
", ListLength(L));
  263. 	CreateListHead(&L, 20);
  264. 	printf("整体创建L的元素(头插法)：");
  265. 	ListTraverse(L);
  267. 	i = ClearList(&L);
  268. 	printf("
删除L后：ListLength(L)=%d
", ListLength(L));
  269. 	CreateListTail(&L, 20);
  270. 	printf("整体创建L的元素(尾插法)：");
  271. 	ListTraverse(L);
  273. 	return 0;
  274. }





【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zhuzhenfeng/p/4626513.html