devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

华清数据结构day5 24-7-22

作者：喵喵爱编程 | 2024-07-27 23:12:37

赞

踩

华清数据结构day5 24-7-22

1>使用栈，完成进制转换输入：一个整数，进制数输出：该数的对应的进制数

seqstack.h

  1. #ifndef SEQSTACK_H
  2. #define SEQSTACK_H
  3. #define MAX 10
  4. #include"myhead.h"
  5. typedef int datatype;
  6.  
  7. typedef struct 
  8. {
  9. 	datatype *data;
  10. 	int top;
  11. }Stack,*StackPtr;
  12. //创建栈
  13. StackPtr stack_create();
  14. //判空
  15. int stack_empty(StackPtr S);
  16. //判满
  17. int stack_full(StackPtr S);
  18. //入栈
  19. void stack_push(StackPtr S, datatype e);
  20. //出栈
  21. void stack_pop(StackPtr S);
  22. //遍历栈
  23. void stack_show(StackPtr S);
  24. //获取栈顶元素
  25. datatype* stack_get_top(StackPtr S);
  26. //求栈的大小
  27. int stack_size(StackPtr S);
  28. //销毁栈
  29. void stack_destroy(StackPtr S);
  30. //进制转换
  31. void base_conversion(StackPtr S);
  32. #endif

seqstack.c

  1. #include"seqstack.h"
  2.  
  3. StackPtr stack_create()
  4. {
  5. 	StackPtr S = (StackPtr)malloc(sizeof(Stack));
  6. 	if(NULL == S)
  7. 	{
  8. 		printf("创建失败\n");
  9. 		return NULL;
  10. 	}
  11. 	S->data = (datatype *)malloc(sizeof(datatype)*MAX);
  12. 	if(NULL == S->data)
  13. 	{
  14. 		printf("创建失败\n");
  15. 		return NULL;
  16. 	}
  17. 	memset(S->data,0,sizeof(datatype)*MAX);
  18. 	S->top = -1;
  19. 	return S;
  20. }
  21.  
  22. int stack_empty(StackPtr S)
  23. {
  24.  	return S->top == -1;
  25. }
  26.  
  27. int stack_full(StackPtr S)
  28. {
  29. 	return S->top == MAX-1;
  30. }
  31.  
  32. void stack_push(StackPtr S,datatype e)
  33. {
  34. 	if(NULL == S||stack_full(S))
  35. 	{
  36. 		printf("入栈失败\n");
  37. 		return;
  38. 	}
  39. 	S->top++;
  40. 	S->data[S->top] = e;
  41. }
  42.  
  43. void stack_pop(StackPtr S)
  44. {
  45. 	if(NULL == S||stack_empty(S))
  46. 	{
  47. 		printf("出栈失败\n");
  48. 		return;
  49. 	}
  50. 	S->top--;
  51. }
  52.  
  53. void stack_show(StackPtr S)
  54. {
  55. 	if(NULL == S|| stack_empty(S))
  56. 	{
  57. 		printf("遍历失败\n");
  58. 		return;
  59. 	}
  60. 	for(int i = S->top;i>=0;i--)
  61. 	{
  62. 		printf("%c\t",S->data[i]+48);
  63. 	}
  64. 	printf("\n");
  65. }
  66.  
  67. datatype* stack_get_top(StackPtr S)
  68. {
  69. 	if(NULL == S||stack_empty(S))
  70. 	{
  71. 		printf("操作失败\n");
  72. 		return NULL;
  73. 	}
  74. 	return &S->data[S->top];
  75. }
  76.  
  77. int stack_size(StackPtr S)
  78. {
  79. 	if(NULL == S)
  80. 	{
  81. 		printf("操作失败\n");
  82. 	}
  83. 	return S->top+1;
  84. }
  85.  
  86. void stack_destroy(StackPtr S)
  87. {
  88.  	if(S!=NULL)
  89. 	{
  90. 		free(S->data);
  91. 		free(S);
  92. 		S=NULL;
  93. 	}
  94. }
  95.  
  96. void base_conversion(StackPtr S)
  97. {
  98. 	int num = 0,base = 0;
  99. 	printf("请输入一个数(10进制):");
  100. 	scanf("%d",&num);
  101. 	printf("请输入你想要将他转换成为的进制:");
  102. 	scanf("%d",&base);
  103. 	while(num)
  104. 	{
  105. 		if (num%base >9)
  106. 		{
  107. 			stack_push(S,num%base+7);
  108. 		}
  109. 		else
  110. 		{
  111. 				stack_push(S,num%base);
  112. 		}	
  113. 		num=num/base;
  114. 	}
  115. 		stack_show(S);
  116. }

main.c

  1. #include"seqstack.h"
  2. #include<myhead.h>
  3. int main(int argc, const char *argv[])
  4. {
  5. 	StackPtr S = stack_create();
  6. 	if(NULL == S)
  7. 	{
  8. 		return -1;
  9. 	}
  10. 	base_conversion(S);
  11.     //调用销毁函数
  12.     stack_destroy(S);
  13.     S = NULL;
  14.  
  15. 	return 0;
  16. }

2> 将双向链表和循环链表自己实现一遍，至少要实现创建、增、删、改、查、销毁工作

双向链表

doublelinklist.h

  1. #ifndef DOUBLELINKLIST_H
  2. #define DOUBLELINKLIST_H
  3. #include"myhead.h"
  4. typedef char datatype;
  5.  
  6. typedef struct Node
  7. {
  8. 	union
  9. 	{
  10. 		int len;
  11. 		datatype data;
  12. 	};
  13. 	struct Node *prio;
  14. 	struct Node *next;
  15. }Node,*NodePtr;
  16.  
  17. NodePtr list_create();
  18.  
  19. int list_empty(NodePtr L);
  20.  
  21. NodePtr apply_node(datatype e);
  22.  
  23. int list_insert_head(NodePtr L,datatype e);
  24.  
  25. int list_show(NodePtr L);
  26.  
  27. NodePtr list_search_pos(NodePtr L ,int  pos);
  28.  
  29. int list_delete_pos(NodePtr L,int pos);
  30.  
  31. void list_destroy(NodePtr L);
  32. int list_update_pos(NodePtr L, int pos, datatype e);
  33. #endif

doublellinklist.c

  1. #include"doublelinklist.h"
  2.  
  3. NodePtr list_create()
  4. {
  5. 	NodePtr L = (NodePtr)malloc(sizeof(Node));
  6. 	if(L == NULL)
  7. 	{
  8. 		printf("申请失败\n");
  9. 		return NULL;
  10. 	}
  11. 	L->len = 0;
  12. 	L->prio = NULL;
  13. 	L->next = NULL;
  14. 	printf("创建成功\n");
  15. 	return L;
  16. }
  17.  
  18. int list_empty(NodePtr L)
  19. {
  20. 	return L->next == NULL;
  21. }
  22.  
  23. NodePtr apply_node(datatype e)
  24. {
  25. 	NodePtr p = (NodePtr)malloc(sizeof(Node));
  26. 	if(NULL == p)
  27. 	{
  28. 		printf("节点申请失败\n");
  29. 		return NULL;
  30. 	}
  31. 	p->data = e;
  32. 	p->prio == NULL;
  33. 	p->next == NULL;
  34. 	return p;
  35. }
  36.  
  37.  
  38. int list_insert_head(NodePtr L,datatype e)
  39. {
  40. 	if(NULL == L)
  41. 	{
  42. 		printf("插入失败\n");
  43. 	}
  44. 	NodePtr p = apply_node(e);
  45. 	if(NULL == p)
  46. 	{
  47. 		return -1;
  48. 	}
  49. 	if(list_empty(L))
  50. 	{
  51. 		p->prio = L;
  52. 		L->next = p;
  53. 	}
  54. 	else
  55. 	{
  56. 		p->prio = L;
  57. 		p->next = L->next;
  58. 		L->next->prio = p;
  59. 		L->next = p;
  60. 	}
  61. 	L->len++;
  62. 	printf("插入成功\n");
  63. 	return 0;
  64. }
  65.  
  66. int list_show(NodePtr L)
  67. {
  68. 	if(NULL == L||list_empty(L))
  69. 	{
  70. 		printf("遍历失败\n");
  71. 		return -1;
  72. 	}
  73. 	NodePtr q = L->next;
  74. 	while(q)
  75. 	{
  76. 		printf("%c\t",q->data);
  77. 		q=q->next;
  78. 	}
  79. 	printf("\n");
  80. 	return 0;
  81. }
  82.  
  83. NodePtr list_search_pos(NodePtr L ,int  pos)
  84. {
  85. 	if(NULL == L|| list_empty(L) ||pos<0 || pos>L->len)
  86. 	{
  87. 		printf("查找失败\n");
  88. 		return NULL;
  89. 	}
  90. 	NodePtr q = L;
  91. 	for(int i=0;i<pos;i++)
  92. 	{
  93. 		q=q->next;
  94. 	}
  95. 	return q;
  96. }
  97. int list_update_pos(NodePtr L, int pos, datatype e)
  98. {
  99. 	if (NULL == L || list_empty(L)|| pos<0||pos>L->len)
  100. 	{
  101. 		printf("修改失败\n");
  102. 		return -1;
  103. 	}
  104. 	NodePtr p = list_search_pos(L,pos);
  105. 	p->data = e;
  106. 	printf("修改成功\n");
  107. 	return 0;
  108. }
  109. int list_delete_pos(NodePtr L,int pos)
  110. {   
  111. 	if(NULL == L|| list_empty(L) || pos<0||pos>L->len)
  112. 	{
  113. 		printf("删除失败\n");
  114. 		return -1;
  115. 	}
  116. 	NodePtr p = list_search_pos(L,pos);
  117. 	if(NULL == p->next)
  118. 	{
  119. 		p->prio->next = NULL;
  120. 		free(p);
  121. 	}
  122. 	else
  123. 	{
  124. 		p->prio->next = p->next;
  125. 		p->next->prio = p->prio;
  126. 		free(p);
  127. 	}
  128. 	L->len--;
  129. 	printf("删除成功\n");
  130. 	return 0;
  131. }
  132.  
  133. void list_destroy(NodePtr L)
  134. {
  135. 	if(NULL == L)
  136. 	{
  137. 		printf("删除失败\n");
  138. 		return;
  139. 	}
  140. 	while(!list_empty(L))
  141. 	{
  142. 		list_delete_pos(L,1);
  143. 	}
  144. 	free(L);
  145. 	L=NULL;
  146. 	printf("链表释放成功\n");
  147. 	return;
  148. }

main.c

  1. #include"doublelinklist.h"
  2.  
  3. int main(int argc, const char *argv[])
  4. {
  5. 	NodePtr L = list_create();
  6. 	if(NULL == L)
  7. 	{
  8. 		return -1;
  9. 	}
  10. 	list_insert_head(L,'Q');
  11. 	list_insert_head(L,'W');
  12. 	list_insert_head(L,'E');
  13. 	list_insert_head(L,'R');
  14. 	list_show(L);
  15. 	list_update_pos(L,2,'F');
  16. 	list_show(L);
  17. 	list_delete_pos(L,4);
  18. 	list_show(L);
  19. 	list_destroy(L);
  20. 	return 0;
  21. }

循环链表

looplinklist.h

  1. #ifndef LOOPLINKLIST_H
  2. #define LOOPLINKLIST_H
  3. #include"myhead.h"
  4. typedef char datatype;
  5.  
  6. typedef struct Node
  7. {
  8. 	union
  9. 	{
  10. 		int len;
  11. 		datatype data;
  12. 	};
  13. 	struct Node *prio;
  14. 	struct Node *next;
  15. }Node,*NodePtr;
  16. //链表创建
  17. NodePtr list_create();
  18. //链表判空
  19. int list_empty(NodePtr L);
  20. //链表申请空间封装节点
  21. NodePtr apply_node(datatype e);
  22. //按位置查找
  23. NodePtr list_search_pos(NodePtr L ,int pos);
  24. //链表尾插
  25. int list_insert_tail(NodePtr L,datatype e);
  26. //链表输出
  27. int list_show(NodePtr L);
  28. //链表头删
  29. int list_delete_head(NodePtr L);
  30. //链表任意位置删除
  31. int list_delete_pos(NodePtr L, int pos);
  32. //链表按位置进行修改
  33. int list_update_pos(NodePtr L, int pos, datatype e);
  34. //链表销毁
  35. void list_destory(NodePtr L);
  36. #endif

looplinklist.c

  1. #include"looplinklist.h"
  2. //链表创建
  3. NodePtr list_create()
  4. {
  5. 	NodePtr L = (NodePtr)malloc(sizeof(Node));
  6. 	if(NULL == L)
  7. 	{
  8. 		printf("创建失败\n");
  9. 		return NULL;
  10. 	}
  11. 	L->len=0;
  12. 	L->next = L;
  13. 	printf("创建成功\n");
  14. 	return L;
  15. }
  16. //链表判空
  17. int list_empty(NodePtr L)
  18. {
  19. 	return L->next==L;
  20. }
  21. //链表申请空间封装节点
  22. NodePtr apply_node(datatype e)
  23. {
  24. 	NodePtr p = (NodePtr)malloc(sizeof(Node));
  25. 	if(NULL == p)
  26. 	{
  27. 		printf("创建失败\n");
  28. 		return NULL;
  29. 	}
  30. 	p->data = e;
  31. 	p->next = NULL;
  32. 	return p;
  33. }
  34. //按位置查找
  35. NodePtr list_search_pos(NodePtr L ,int pos)
  36. {
  37. 	if(NULL == L|| pos<0 ||pos>L->len)
  38. 	{
  39. 		printf("查找失败\n");
  40. 		return NULL;
  41. 	}
  42. 	NodePtr q = L;
  43. 	for(int i= 0;i<pos;i++)
  44. 	{
  45. 		q=q->next;
  46. 	}
  47. 	return q;
  48. }
  49. //链表尾插
  50. int list_insert_tail(NodePtr L,datatype e)
  51. {
  52. 	if(NULL == L)
  53. 	{
  54. 		printf("插入失败\n");
  55. 		return -1;
  56. 	}
  57. 	NodePtr q = list_search_pos(L,L->len);
  58. 	
  59. 	NodePtr p = apply_node(e);
  60.  
  61. 	if(NULL == L)
  62. 	{
  63. 		return -1;
  64. 	}
  65. 	p->next = q->next;
  66. 	q->next = p;
  67.  
  68. 	L->len++;
  69. 	printf("插入成功\n");
  70. 	return 0;
  71. }
  72. //链表输出
  73. int list_show(NodePtr L)
  74. {
  75. 	if(NULL== L||list_empty(L))
  76. 	{
  77. 		printf("遍历失败\n");
  78. 		return -1;
  79. 	}
  80. 	NodePtr q = L->next;
  81. 	while(q!=L)
  82. 	{
  83. 		printf("%c\t",q->data);
  84. 		q=q->next;
  85. 	}
  86. 	printf("\n");
  87. }
  88. //链表头删
  89. int list_delete_head(NodePtr L)
  90. {
  91. 	if(NULL==L || list_empty(L))
  92. 	{
  93. 		printf("删除失败\n");
  94. 		return -1;
  95. 	}
  96. 	NodePtr q = L->next;
  97. 	L->next = q->next;
  98. 	free(q);
  99. 	q=NULL;
  100. 	L->len--;
  101. 	printf("删除成功\n");
  102. }
  103. //链表销毁
  104. void list_destory(NodePtr L)
  105. {
  106. 	if(NULL == L)
  107. 	{
  108. 		printf("释放失败\n");
  109. 		return;
  110. 	}
  111. 	while(!list_empty(L))
  112. 	{
  113. 		list_delete_head(L);
  114. 	}
  115. 	free(L);
  116. 	L = NULL;
  117. 	printf("销毁成功\n");
  118. }
  119. //链表任意位置删除
  120. int list_delete_pos(NodePtr L, int pos)
  121. {
  122. 	if (NULL == L||pos<0 ||pos>L->len||list_empty(L))
  123. 	{
  124. 		printf("删除失败\n");
  125. 		return -1;
  126. 	}
  127. 	NodePtr p = list_search_pos(L,pos-1);
  128. 	NodePtr q = p->next;
  129. 	p->next = q->next;
  130. 	free(q);
  131. 	q=NULL;
  132. 	printf("删除成功\n");
  133. 	L->len--;  
  134. 	return 0;
  135. }
  136. //链表按位置进行修改
  137. int list_update_pos(NodePtr L, int pos, datatype e)
  138. {
  139. 	if (NULL == L||pos<0 ||pos>L->len||list_empty(L))
  140. 	{
  141. 		printf("修改失败\n");
  142. 		return -1;
  143. 	}
  144. 	NodePtr p = list_search_pos(L,pos);
  145. 	p->data = e;
  146. 	printf("修改成功\n");
  147. 	return 0;
  148. }

main.c

  1. #include"looplinklist.h"
  2. #include<myhead.h>
  3. int main(int argc, const char *argv[])
  4. {
  5. 	NodePtr L = list_create();
  6. 	if(NULL == L)
  7. 	{
  8. 		return -1;
  9. 	}
  10. 	list_insert_tail(L,'Q');
  11. 	list_insert_tail(L,'W');
  12. 	list_insert_tail(L,'E');
  13. 	list_insert_tail(L,'R');
  14. 	list_insert_tail(L,'T');
  15. 	list_show(L);
  16. 	list_update_pos(L,2,'P');
  17. 	list_show(L);
  18. 	list_delete_pos(L,3);
  19. 	list_show(L);
  20. 	list_destory(L);
  21. 	L=NULL;
  22. 	return 0;
  23. }

3> 使用循环链表完成约瑟夫环问题

looplinklist.h

  1. #ifndef LOOPLINKLIST_H
  2. #define LOOPLINKLIST_H
  3. #include"myhead.h"
  4. typedef char datatype;
  5.  
  6. typedef struct Node
  7. {
  8. 	union
  9. 	{
  10. 		int len;
  11. 		datatype data;
  12. 	};
  13. 	struct Node *prio;
  14. 	struct Node *next;
  15. }Node,*NodePtr;
  16. //链表创建
  17. NodePtr list_create();
  18. //链表判空
  19. int list_empty(NodePtr L);
  20. //链表申请空间封装节点
  21. NodePtr apply_node(datatype e);
  22. //按位置查找
  23. NodePtr list_search_pos(NodePtr L ,int pos);
  24. //链表尾插
  25. int list_insert_tail(NodePtr L,datatype e);
  26. //链表输出
  27. int list_show(NodePtr L);
  28. //链表头删
  29. int list_delete_head(NodePtr L);
  30. //链表任意位置删除
  31. int list_delete_pos(NodePtr L, int pos);
  32. //链表按位置进行修改
  33. int list_update_pos(NodePtr L, int pos, datatype e);
  34. //链表销毁
  35. void list_destory(NodePtr L);
  36. //约瑟夫
  37. void Josephus_problem(NodePtr L);
  38. #endif

looplinklist.c

  1. #include"looplinklist.h"
  2. //链表创建
  3. NodePtr list_create()
  4. {
  5. 	NodePtr L = (NodePtr)malloc(sizeof(Node));
  6. 	if(NULL == L)
  7. 	{
  8. 		printf("创建失败\n");
  9. 		return NULL;
  10. 	}
  11. 	L->len=0;
  12. 	L->next = L;
  13. 	printf("创建成功\n");
  14. 	return L;
  15. }
  16. //链表判空
  17. int list_empty(NodePtr L)
  18. {
  19. 	return L->next==L;
  20. }
  21. //链表申请空间封装节点
  22. NodePtr apply_node(datatype e)
  23. {
  24. 	NodePtr p = (NodePtr)malloc(sizeof(Node));
  25. 	if(NULL == p)
  26. 	{
  27. 		printf("创建失败\n");
  28. 		return NULL;
  29. 	}
  30. 	p->data = e;
  31. 	p->next = NULL;
  32. 	return p;
  33. }
  34. //按位置查找
  35. NodePtr list_search_pos(NodePtr L ,int pos)
  36. {
  37. 	if(NULL == L|| pos<0 ||pos>L->len)
  38. 	{
  39. 		printf("查找失败\n");
  40. 		return NULL;
  41. 	}
  42. 	NodePtr q = L;
  43. 	for(int i= 0;i<pos;i++)
  44. 	{
  45. 		q=q->next;
  46. 	}
  47. 	return q;
  48. }
  49. //链表尾插
  50. int list_insert_tail(NodePtr L,datatype e)
  51. {
  52. 	if(NULL == L)
  53. 	{
  54. 		printf("插入失败\n");
  55. 		return -1;
  56. 	}
  57. 	NodePtr q = list_search_pos(L,L->len);
  58. 	
  59. 	NodePtr p = apply_node(e);
  60.  
  61. 	if(NULL == L)
  62. 	{
  63. 		return -1;
  64. 	}
  65. 	p->next = q->next;
  66. 	q->next = p;
  67.  
  68. 	L->len++;
  69. 	printf("插入成功\n");
  70. 	return 0;
  71. }
  72. //链表输出
  73. int list_show(NodePtr L)
  74. {
  75. 	if(NULL== L||list_empty(L))
  76. 	{
  77. 		printf("遍历失败\n");
  78. 		return -1;
  79. 	}
  80. 	NodePtr q = L->next;
  81. 	while(q!=L)
  82. 	{
  83. 		printf("%c\t",q->data);
  84. 		q=q->next;
  85. 	}
  86. 	printf("\n");
  87. }
  88. //链表头删
  89. int list_delete_head(NodePtr L)
  90. {
  91. 	if(NULL==L || list_empty(L))
  92. 	{
  93. 		printf("删除失败\n");
  94. 		return -1;
  95. 	}
  96. 	NodePtr q = L->next;
  97. 	L->next = q->next;
  98. 	free(q);
  99. 	q=NULL;
  100. 	L->len--;
  101. }
  102. //链表销毁
  103. void list_destory(NodePtr L)
  104. {
  105. 	if(NULL == L)
  106. 	{
  107. 		printf("释放失败\n");
  108. 		return;
  109. 	}
  110. 	while(!list_empty(L))
  111. 	{
  112. 		list_delete_head(L);
  113. 	}
  114. 	free(L);
  115. 	L = NULL;
  116. 	printf("销毁成功\n");
  117. }
  118. //链表任意位置删除
  119. int list_delete_pos(NodePtr L, int pos)
  120. {
  121. 	if (NULL == L||pos<0 ||pos>L->len||list_empty(L))
  122. 	{
  123. 		printf("删除失败\n");
  124. 		return -1;
  125. 	}
  126. 	NodePtr p = list_search_pos(L,pos-1);
  127. 	NodePtr q = p->next;
  128. 	p->next = q->next;
  129. 	free(q);
  130. 	q=NULL;
  131. 	printf("删除成功\n");
  132. 	L->len--;  
  133. 	return 0;
  134. }
  135. //链表按位置进行修改
  136. int list_update_pos(NodePtr L, int pos, datatype e)
  137. {
  138. 	if (NULL == L||pos<0 ||pos>L->len||list_empty(L))
  139. 	{
  140. 		printf("修改失败\n");
  141. 		return -1;
  142. 	}
  143. 	NodePtr p = list_search_pos(L,pos);
  144. 	p->data = e;
  145. 	printf("修改成功\n");
  146. 	return 0;
  147. }
  148. void Josephus_problem(NodePtr L)
  149. {
  150. 	int count = 0,num = 0;
  151. 	printf("请输入数到几退出:");
  152. 	scanf("%d",&num);
  153. 	NodePtr p = L;
  154. 	while (!list_empty(L))
  155. 	{	
  156. 		if (p->next == L)
  157. 		{
  158. 			p = p->next;
  159. 		}	
  160. 		if (num ==1)
  161. 		{
  162. 			printf("%c\t",list_search_pos(L,1)->data);
  163. 			list_delete_head(L);
  164. 		}
  165. 		else	if(count == num-1) 
  166. 		{
  167. 			printf("%c\t",p->next->data);
  168. 			NodePtr q = p->next;
  169. 			p->next = q->next;
  170. 			free(q);
  171. 			q=NULL;
  172. 			L->len--;  
  173. 			count = 0;
  174. 		}
  175. 		count++;
  176. 		p = p->next;
  177. 	}
  178. 	printf("\n");
  179. }

main.c

  1. #include"looplinklist.h"
  2. #include<myhead.h>
  3. int main(int argc, const char *argv[])
  4. {
  5. 	NodePtr L = list_create();
  6. 	if(NULL == L)
  7. 	{
  8. 		return -1;
  9. 	}
  10. 	list_insert_tail(L,'Q');
  11. 	list_insert_tail(L,'W');
  12. 	list_insert_tail(L,'E');
  13. 	list_insert_tail(L,'R');
  14. 	list_insert_tail(L,'T');
  15. 	// list_show(L);
  16. 	// list_update_pos(L,2,'P');
  17. 	// list_show(L);
  18. 	// list_delete_pos(L,3);
  19. 	// list_show(L);
  20. 	Josephus_problem(L);
  21. 	list_destory(L);
  22. 	L=NULL;
  23. 	return 0;
  24. }

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

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

  

闽ICP备14008679号