devbox
一键难忘520
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构(Data Structure)——线性表ADT(C/C++语言)_返回l中第1个与e满足关系compore()的数据元素的位序。 若这样的数据元素不存

作者：一键难忘520 | 2024-07-09 06:06:07

赞

踩

返回l中第1个与e满足关系compore()的数据元素的位序。 若这样的数据元素不存

1.线性表定义:

       线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。
       在稍复杂的线性表中，一个数据元素可由多个数据项（item）组成，此种情况下常把数据元素称为记录（record），含有大量记录的线性表又称文件（file）。
       线性表中的个数n定义为线性表的长度，n=0时称为空表。在非空表中每个数据元素都有一个确定的位置，如用ai表示数据元素，则i称为数据元素ai在线性表中的位序。

       线性表的相邻元素之间存在着序偶关系。如用（a1，…，ai-1，ai，ai+1，…，an）表示一个顺序表，则表中ai-1领先于ai，ai领先于ai+1，称ai-1是ai的直接前驱元素，ai+1是ai的直接后继元素。当i=1,2，…，n-1时，ai有且仅有一个直接后继，当i=2，3，…，n时，ai有且仅有一个直接前驱。

初期工作:

  1. #define OK 1
  2. #define ERROR 0
  3. #define OVERFLOW -1
  4. #define TRUE 1
  5. #define FALSE 0
  6.  
  7. #define List_INIT_SPACE 100 //存储空间初始分配量
  8. #define List_INC_SPACE 10 //存储空间分配增量
  9.  
  10. typedef int ElemType;//指定顺序表中数据类型
  11. typedef int Status;

线性表定义:

  1. typedef struct
  2. {
  3. 	ElemType *elem;  //存储空间基址
  4. 	int length;  //当前长度
  5. 	int listsize; //当前分配的存储容量（以sizeof（ElemType）为单位）
  6. }List;

2.基本操作:

单个线性表的构造、销毁、清空、判空、返回长度、返回定位、返回前驱、返回后继、插入、删除、遍历。

  1. /*操作结果:构造一个空的线性表。*/
  2. Status InitList(List &L);
  3.  
  4. /*初始条件:线性表L已存在。*/
  5. /*操作结果:销毁线性表L。*/
  6. Status DestroyList(List &L);
  7.  
  8. /*初始条件:线性表L已存在。*/
  9. /*操作结果:将L置为空表。*/
  10. Status ClearList(List &L);
  11.  
  12. /*初始条件:线性表L已存在。*/
  13. /*操作结果:若L为空，则返回TRUE，否则返回FALSE。*/
  14. Status ListEmpty(List &L);
  15.  
  16. /*初始条件:线性表L已存在。*/
  17. /*操作结果:返回L中数据元素个数。*/
  18. Status ListLength(List &L);
  19.  
  20. /*初始条件:线性表L已存在,1≤i≤ListLength(L)。*/
  21. /*操作结果:用e返回L中第i个元素的值。*/
  22. Status GetElem(List L, int i, Status &e);
  23.  
  24. /*初始条件：线性表L已存在,compare()是数据元素判断函数。*/
  25. /*操作结果：返回L中第1个与e满足关系compaer()的数据元素的位序。若这样的数据元素不存在，则返回0。*/
  26. Status LocateElem(List L, Status e, Status(*compare)(const void *, const void *));
  27.  
  28. /*初始条件：线性表L已存在。*/
  29. /*操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义。*/
  30. Status PriorElem(List L, Status cur_e, Status &pre_e);
  31.  
  32. /*初始条件：线性表L已存在。*/
  33. /*操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后续，否则操作失败，next_e无定义。*/
  34. Status NextElem(List L, Status cur_e, Status &next_e);
  35.  
  36. /*初始条件：线性表L已存在,1≤i≤ListLength(L)+1。*/
  37. /*操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1。*/
  38. Status ListInsert(List &L, int i, Status e);
  39.  
  40. /*初始条件：线性表L已存在且非空，1≤i≤ListLength(L)。*/
  41. /*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1。*/
  42. Status ListDelete(List &L, int i, Status &e);
  43.  
  44. /*初始条件：线性表L已存在。*/
  45. /*操作结果:依次对L的每个数据元素调用函数visit()。一旦visit()操作失败，则操作失败。*/
  46. Status ListTraverse(List L, Status(*visit)());

3.具体函数的实现:

构造一个空的线性表L：

  1. /*构造一个空的线性表L*/
  2. /*操作结果:构造一个空的线性表。*/
  3. Status InitList(List &L)
  4. {
  5. 	L.elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
  6. 	if (!L.elem)	exit(OVERFLOW);//内存申请失败，异常退出
  7. 	L.length = 0;//空表长度为0
  8. 	L.listsize = LIST_INIT_SIZE;
  9. 	printf("构造一个空的线性表L成功！\n");
  10. 	return OK;
  11. }


销毁线性表L：

  1. /*销毁线性表L*/
  2. /*初始条件:线性表L已存在。*/
  3. /*操作结果:销毁线性表L。*/
  4. Status DestroyList(List &L)
  5. {
  6. 	if (L.elem)free(L.elem);//释放内存空间
  7. 	L.elem = NULL;
  8. 	L.length = 0;
  9. 	L.listsize = 0;
  10. 	return OK;
  11. }


将L置为空表：

  1. /*初始条件:线性表L已存在。*/
  2. /*操作结果:将L置为空表。*/
  3. Status ClearList(List &L)
  4. {
  5. 	L.length = 0;
  6. 	return OK;
  7. }


判断线性表L是否为空：

  1. /*判断线性表是否为空*/
  2. /*初始条件:线性表L已存在。*/
  3. /*操作结果:若L为空，则返回TRUE，否则返回FALSE。*/
  4. Status ListEmpty(List &L)
  5. {
  6. 	if (!L.length)return TRUE;
  7. 	else return FALSE;
  8. }


返回L中数据元素个数：

  1. /*初始条件:线性表L已存在。*/
  2. /*操作结果:返回L中数据元素个数。*/
  3. Status ListLength(List &L)
  4. {
  5. 	return L.length;
  6. }

用e返回L中第i个元素的值：

  1. /*初始条件:线性表L已存在,1≤i≤ListLength(L)。*/
  2. /*操作结果:用e返回L中第i个元素的值。*/
  3. Status GetElem(List L, int i, Status &e)
  4. {
  5. 	if (i<1 || i>L.length)return ERROR;
  6. 	else
  7. 	{
  8. 		e = L.elem[i - 1];
  9. 		return OK;
  10. 	}
  11. }

返回L中第1个与e满足关系compaer()的数据元素的位序：

  1. /*初始条件：线性表L已存在,compare()是数据元素判断函数。*/
  2. /*操作结果：返回L中第1个与e满足关系compaer()的数据元素的位序。若这样的数据元素不存在，则返回0。*/
  3. Status LocateElem(List L, Status e, Status(*compare)(ElemType, ElemType))
  4. {
  5. 	ElemType i, *p;
  6. 	i = 1;				//i的初值为第一个元素的位序
  7. 	p = L.elem;			//p的初值为第一个元素的存储位置
  8. 	while (i <= L.length&&!(*compare)(*p++, e)) ++i;
  9. 	if (i <= L.length)return i;
  10. 	else return 0;	
  11. }

返回指定元素的前驱：

  1. /*初始条件：线性表L已存在。*/
  2. /*操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义。*/
  3. Status PriorElem(List L, Status cur_e, Status &pre_e)
  4. {
  5. 	for (int i = 1; i < L.length; i++)
  6. 	{
  7. 		if (L.elem[i]==cur_e)
  8. 		{
  9. 			pre_e = L.elem[i - 1];
  10. 			return OK;
  11. 		}
  12. 		else
  13. 		{
  14. 			if (i >= L.length)	return ERROR;
  15. 		}
  16. 	}
  17. }

返回指定元素的后继：

  1. /*初始条件：线性表L已存在。*/
  2. /*操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后续，否则操作失败，next_e无定义。*/
  3. Status NextElem(List L, Status cur_e, Status &next_e)
  4. {
  5. 	for (int i = 0; i < L.length-1; i++)
  6. 	{
  7. 		if (L.elem[i] == cur_e)
  8. 		{
  9. 			next_e = L.elem[i + 1];
  10. 			return OK;
  11. 		}
  12. 		else
  13. 		{
  14. 			if (i >= L.length-1)
  15. 			{
  16. 				return ERROR;
  17. 			}
  18. 		}
  19. 	}
  20. }


在L中第i个位置之前插入新的数据元素e：

  1. /*初始条件：线性表L已存在,1≤i≤ListLength(L)+1。*/
  2. /*操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1。*/
  3. Status ListInsert(List &L, int i, Status e)
  4. {
  5. 	ElemType *q, *p, *newbase;
  6. 	if (i<1 || i>L.length + 1) return ERROR;//i值不合法
  7. 	if (L.length>=L.listsize)				//当前存储空间已满，增加分配
  8. 	{
  9. 		newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT)*sizeof(ElemType));
  10. 		if (!newbase) exit(OVERFLOW);		//存储分配失败
  11. 		L.elem = newbase;					//新基址
  12. 		L.listsize += LISTINCREMENT;		//增加存储容量
  13. 	}
  14. 	q = &(L.elem[i - 1]);					//q为插入位置
  15. 	for (p = &(L.elem[L.length - 1]); p >= q; --p)
  16. 	{
  17. 		*(p + 1) = *p;						//将插入位置及之后的元素右移
  18. 	}
  19. 	*q = e;									//插入e
  20. 	++L.length;								//表长增1
  21. 	return OK;
  22. }

删除L的第i个数据元素：

  1. /*初始条件：线性表L已存在且非空，1≤i≤ListLength(L)。*/
  2. /*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1。*/
  3. Status ListDelete(List &L, int i, Status &e)
  4. {
  5. 	ElemType *q, *p;
  6. 	if (i<1 || i>L.length)return ERROR;	//i值不合法
  7. 	p = &(L.elem[i - 1]);				//p为被删除元素位置
  8. 	e = *p;								//将删除元素的值赋给e
  9. 	q = L.elem + L.length - 1;			//表尾元素的位置
  10. 	for (++p; p <= q; ++p)				//将被删除元素之后的元素左移
  11. 	{
  12. 		*(p - 1) = *(p);
  13. 	}
  14. 	--L.length;							//表长减1
  15. 	return OK;
  16. 	
  17. }

依次对L的每个数据元素调用函数visit()：

  1. /*初始条件：线性表L已存在。*/
  2. /*操作结果:依次对L的每个数据元素调用函数visit()。一旦visit()操作失败，则操作失败。*/
  3. Status ListTraverse(List L, Status(*visit)(List L))
  4. {
  5. 	(*visit)(L);
  6. 	return OK;
  7. }


4.完整程序:


  1. #include<stdlib.h>
  2. #include<stdio.h>
  3.  
  4. #define OK 1
  5. #define ERROR 0
  6. #define OVERFLOW -1
  7. #define TRUE 1
  8. #define FALSE 0
  9.  
  10. #define LIST_INIT_SIZE 100 //存储空间初始分配量
  11. #define LISTINCREMENT 10 //存储空间分配增量
  12.  
  13. typedef int ElemType;//指定顺序表中数据类型
  14. typedef int Status;
  15.  
  16. typedef struct
  17. {
  18. 	ElemType *elem;  //存储空间基址
  19. 	int length;  //当前长度
  20. 	int listsize; //当前分配的存储容量（以sizeof（ElemType）为单位）
  21. }List;
  22.  
  23. /*构造一个空的线性表L*/
  24. /*操作结果:构造一个空的线性表。*/
  25. Status InitList(List &L)
  26. {
  27. 	L.elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
  28. 	if (!L.elem)	exit(OVERFLOW);//内存申请失败，异常退出
  29. 	L.length = 0;//空表长度为0
  30. 	L.listsize = LIST_INIT_SIZE;
  31. 	printf("构造一个空的线性表L成功！\n");
  32. 	return OK;
  33. }
  34.  
  35. /*销毁线性表L*/
  36. /*初始条件:线性表L已存在。*/
  37. /*操作结果:销毁线性表L。*/
  38. Status DestroyList(List &L)
  39. {
  40. 	if (L.elem)free(L.elem);//释放内存空间
  41. 	L.elem = NULL;
  42. 	L.length = 0;
  43. 	L.listsize = 0;
  44. 	return OK;
  45. }
  46.  
  47. /*初始条件:线性表L已存在。*/
  48. /*操作结果:将L置为空表。*/
  49. Status ClearList(List &L)
  50. {
  51. 	L.length = 0;
  52. 	return OK;
  53. }
  54.  
  55. /*判断线性表是否为空*/
  56. /*初始条件:线性表L已存在。*/
  57. /*操作结果:若L为空，则返回TRUE，否则返回FALSE。*/
  58. Status ListEmpty(List &L)
  59. {
  60. 	if (!L.length)return TRUE;
  61. 	else return FALSE;
  62. }
  63.  
  64. /*初始条件:线性表L已存在。*/
  65. /*操作结果:返回L中数据元素个数。*/
  66. Status ListLength(List &L)
  67. {
  68. 	return L.length;
  69. }
  70.  
  71. /*初始条件:线性表L已存在,1≤i≤ListLength(L)。*/
  72. /*操作结果:用e返回L中第i个元素的值。*/
  73. Status GetElem(List L, int i, Status &e)
  74. {
  75. 	if (i<1 || i>L.length)return ERROR;
  76. 	else
  77. 	{
  78. 		e = L.elem[i - 1];
  79. 		return OK;
  80. 	}
  81. }
  82.  
  83. /*初始条件：线性表L已存在,compare()是数据元素判断函数。*/
  84. /*操作结果：返回L中第1个与e满足关系compaer()的数据元素的位序。若这样的数据元素不存在，则返回0。*/
  85. Status LocateElem(List L, Status e, Status(*compare)(ElemType, ElemType))
  86. {
  87. 	ElemType i, *p;
  88. 	i = 1;				//i的初值为第一个元素的位序
  89. 	p = L.elem;			//p的初值为第一个元素的存储位置
  90. 	while (i <= L.length&&!(*compare)(*p++, e)) ++i;
  91. 	if (i <= L.length)return i;
  92. 	else return 0;	
  93. }
  94.  
  95. /*初始条件：线性表L已存在。*/
  96. /*操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义。*/
  97. Status PriorElem(List L, Status cur_e, Status &pre_e)
  98. {
  99. 	for (int i = 1; i < L.length; i++)
  100. 	{
  101. 		if (L.elem[i]==cur_e)
  102. 		{
  103. 			pre_e = L.elem[i - 1];
  104. 			return OK;
  105. 		}
  106. 		else
  107. 		{
  108. 			if (i >= L.length)	return ERROR;
  109. 		}
  110. 	}
  111. }
  112.  
  113. /*初始条件：线性表L已存在。*/
  114. /*操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后续，否则操作失败，next_e无定义。*/
  115. Status NextElem(List L, Status cur_e, Status &next_e)
  116. {
  117. 	for (int i = 0; i < L.length-1; i++)
  118. 	{
  119. 		if (L.elem[i] == cur_e)
  120. 		{
  121. 			next_e = L.elem[i + 1];
  122. 			return OK;
  123. 		}
  124. 		else
  125. 		{
  126. 			if (i >= L.length-1)
  127. 			{
  128. 				return ERROR;
  129. 			}
  130. 		}
  131. 	}
  132. }
  133.  
  134. /*初始条件：线性表L已存在,1≤i≤ListLength(L)+1。*/
  135. /*操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1。*/
  136. Status ListInsert(List &L, int i, Status e)
  137. {
  138. 	ElemType *q, *p, *newbase;
  139. 	if (i<1 || i>L.length + 1) return ERROR;//i值不合法
  140. 	if (L.length>=L.listsize)				//当前存储空间已满，增加分配
  141. 	{
  142. 		newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT)*sizeof(ElemType));
  143. 		if (!newbase) exit(OVERFLOW);		//存储分配失败
  144. 		L.elem = newbase;					//新基址
  145. 		L.listsize += LISTINCREMENT;		//增加存储容量
  146. 	}
  147. 	q = &(L.elem[i - 1]);					//q为插入位置
  148. 	for (p = &(L.elem[L.length - 1]); p >= q; --p)
  149. 	{
  150. 		*(p + 1) = *p;						//将插入位置及之后的元素右移
  151. 	}
  152. 	*q = e;									//插入e
  153. 	++L.length;								//表长增1
  154. 	return OK;
  155. }
  156.  
  157. /*初始条件：线性表L已存在且非空，1≤i≤ListLength(L)。*/
  158. /*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1。*/
  159. Status ListDelete(List &L, int i, Status &e)
  160. {
  161. 	ElemType *q, *p;
  162. 	if (i<1 || i>L.length)return ERROR;	//i值不合法
  163. 	p = &(L.elem[i - 1]);				//p为被删除元素位置
  164. 	e = *p;								//将删除元素的值赋给e
  165. 	q = L.elem + L.length - 1;			//表尾元素的位置
  166. 	for (++p; p <= q; ++p)				//将被删除元素之后的元素左移
  167. 	{
  168. 		*(p - 1) = *(p);
  169. 	}
  170. 	--L.length;							//表长减1
  171. 	return OK;
  172. 	
  173. }
  174.  
  175. /*初始条件：线性表L已存在。*/
  176. /*操作结果:依次对L的每个数据元素调用函数visit()。一旦visit()操作失败，则操作失败。*/
  177. Status ListTraverse(List L, Status(*visit)(List L))
  178. {
  179. 	(*visit)(L);
  180. 	return OK;
  181. }
  182.  
  183. /*初始条件：线性表L已存在。*/
  184. /*操作结果：输出线性表*/
  185. Status VisitList(List L)
  186. {
  187. 	for (int i = 0; i < L.length; i++)
  188. 	{
  189. 		printf("%d ", L.elem[i]);
  190. 	}
  191. 	return OK;
  192. }
  193.  
  194. /*初始条件：线性表L已存在。*/
  195. /*操作结果：小到大对顺序表进行排序*/
  196. Status SortList(List &L)
  197. {
  198. 	for (int i = 0; i < L.length - 1; i++)
  199. 	{
  200. 		for (int j = 0; j < L.length - i - 1; j++)
  201. 		{
  202. 			if (L.elem[j]>L.elem[j + 1])
  203. 			{
  204. 				int temp = L.elem[j];
  205. 				L.elem[j] = L.elem[j + 1];
  206. 				L.elem[j + 1] = temp;
  207. 			}
  208. 		}
  209. 	}
  210. 	return OK;
  211. }
  212. int main()
  213. {
  214. 	List L;
  215. 	ElemType e1, e2;
  216. 	Status k;
  217. 	int i, a, b, c, d, e, n, j;
  218. 	printf("******************\n");
  219. 	printf("请选择您所要进行的操作\n");
  220. 	printf("1.排序\n");
  221. 	printf("2.判断线性表是否为空\n");
  222. 	printf("3.线性表中元素的个数\n");
  223. 	printf("4.寻找表中第i个元素\n");
  224. 	printf("5.寻找指定值前驱\n");
  225. 	printf("6.寻找指定值后继\n");
  226. 	printf("7.删除元素\n");
  227. 	printf("8.遍历输出线性表\n");
  228. 	printf("9.清空线性表\n");
  229. 	printf("10.销毁线性表\n");
  230. 	printf("11.插入元素\n");
  231. 	printf("0.退出\n");
  232. 	printf("******************\n\n");
  233. 	//初始化线性表   
  234. 	InitList(L);
  235. 	printf("初始化表元素个数：");
  236. 	scanf("%d", &n);//往线性表插入数据  
  237. 	printf("输入所插入的数据：");
  238. 	for (i = 1; i <= n; i++)
  239. 	{
  240. 		scanf("%d", &a);
  241. 		ListInsert(L, i, a);
  242. 	}
  243. 	printf("请进行下一步的操作：");
  244. 	while (scanf("%d", &c) && c != 0)
  245. 	{
  246. 		switch (c)
  247. 		{
  248. 		case 1:
  249. 			SortList(L);
  250. 			printf("线性表成功由小到大进行排序\n");
  251. 			break;
  252. 		case 2:
  253. 			if (ListEmpty(L))  printf("线性表为空\n");
  254. 			else   printf("线性表不为空\n");
  255. 			break;
  256. 		case 3:
  257. 			printf("线性表的元素个数为%d\n", ListLength(L));
  258. 			break;
  259. 		case 4:
  260. 			printf("输入要查找表中第i个值：");
  261. 			scanf("%d", &i);
  262. 			if (i<1 || i>ListLength(L)){
  263. 				printf("输入数值错误\n");
  264. 				break;
  265. 			}
  266. 			else{
  267. 				GetElem(L, i, e);
  268. 				printf("表中第%d个元素对应的数值为%d\n", i,e);
  269. 			}
  270. 			break;
  271. 		case 5:
  272. 			printf("输入要查找表中第i个值前驱：");
  273. 			scanf("%d", &i);
  274. 			if (i < 2 || i >= ListLength(L)) {
  275. 				printf("输入数值错误\n");
  276. 				break;
  277. 			}
  278. 			else{
  279. 				PriorElem(L, i, e);
  280. 				printf("表中第%d个元素对应的前驱数值为%d\n", i, e);
  281. 			}
  282. 			break;
  283. 		case 6:
  284. 			printf("输入要查找表中第i个值后继：");
  285. 			scanf("%d", &i);
  286. 			if (i <= 1 || i > ListLength(L)-1) {
  287. 				printf("输入数值错误\n");
  288. 				break;
  289. 			}
  290. 			else{
  291. 				NextElem(L, i, e);
  292. 				printf("表中第%d个元素对应的后继数值为%d\n", i, e);
  293. 			}
  294. 			break;
  295. 		case 7:
  296. 			printf("输入删除元素位序：");
  297. 			scanf("%d", &c);
  298. 			if (c<1 || c>L.length)
  299. 				printf("输入错误!!!元素不存在\n");
  300. 			else
  301. 				ListDelete(L, c, e);  
  302. 			printf("删除第%d个元素成功，其值为%d\n", c, e);
  303. 			break;
  304. 		case 8:
  305. 			ListTraverse(L, VisitList);
  306. 			printf("\n遍历输出线性表成功！\n");
  307. 			break;
  308. 		case 9:
  309. 			ClearList(L);
  310. 			printf("清空成功！\n");
  311. 			break;
  312. 		case 10:
  313. 			DestroyList(L);
  314. 			printf("销毁成功！\n");
  315. 			break;
  316. 		case 11:
  317. 			printf("请输入您所想插入的位置以及元素值:");
  318. 			scanf("%d%d", &e, &d);
  319. 			if (ListInsert(L, e, d)) printf("插入成功！\n");
  320. 			else     printf("插入失败！\n");
  321. 			break;
  322. 		default:
  323. 			break;
  324. 		}
  325. 		printf("请进行下一步的操作：");
  326. 	}
  327. 	printf("成功退出！\n");
  328. 	return 0;
  329. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/一键难忘520/article/detail/801663
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号