环形链表解约瑟夫环

 最近在研究c算法，所以写了点东西；不过对数据结构还不是很了解，我无语了我，为了准备某某东西嘛，就不说出来了，因为是新手，而且和也可能和我的学习方法以及悟性有关

感觉一直很颓废，写起来没有那么生动，思考的时候容易遇到瓶颈，而且我感觉算法和数据结构这种东西不是突击就可以出来的，

不过最近我又开始加班了，以后打算长期写下去，希望这个家可以长久一点，一开始本来是在本地计算机的虚拟机里搭建WP的，只是想有个稳定点的家而已。

关于链表的结构还是比较清晰的，就是类似数组类型的简单数据结构，但是在运算以及存储操作等方法上要优于数组，特别是在使用

C/CPP这样的比较接近底层的语言中，因为语言本身没有比较好的高级数据结构，不过就链表的实现来说还是很方便的，在我书写的过程中，主要遇到的困难是，链表指针的传递问题，有好几次我的指针都不知道指向了什么地方，经过相当长时间的刻苦调试终于有了进展，不过参看别人的链表结构我感觉自己的结构还是相当幼稚的，这是我今天做的总结。

下面上程序，希望自己能快点进步，能成为一名ios开发者，加油！

Code:

1. #include <stdlib.h>  
2. #include <stdio.h>  
3. #include <malloc.h>  
4. //约瑟夫环  
5. struct joseph{  
6.                 int number;  
7.                 joseph * next;  
8.   
9.                 };  
10.     struct joseph * create(int i)  
11.         {  
12.                 joseph * h;  
13.                 joseph * f;  
14.                 joseph * b;  
15.                 if(i>1)  
16.                 h=(joseph*)malloc(sizeof(joseph));  
17.                 else printf("error");  
18.                 //h->next=f;  
19.                 f=h;  
20.   
21.             for(int n=0;n<i;n++)  
22.                 {  
23.                     joseph * temp=(joseph*)malloc(sizeof(joseph));  
24.                 //  printf("创建");  
25.                 //  while(!temp)  
26.                 //      {  
27.                             if(n==(i))  
28.                                 {  
29.                                     f=temp;  
30.                                     f->next=h;  
31.                                 //  printf("调试");  
32.                                 //  return h;  
33.                                 }  
34.                             else{  
35.                                     b=temp;  
36.                                     f->next=b;  
37.                                     b->next=NULL;  
38.                                     f=b;  
39.                         //      }  
40.                         //  temp=NULL;  
41.                         }             
42.                 }  
43.     return h;  
44. }  
45.   
46. void init_joseph(joseph * h)  
47.     {  
48.         //joseph * n;  
49.         int i=1;  
50.       
51.         while(h->next)  
52.             {  
53.             //  n=h;  
54.                 h->number=i++;  
55.                 h=h->next;  
56.             }  
57.     }  
58. //删除链表节点操作函数  
59.     void delete_joseph(joseph* h,int round)  
60.         {     
61.             int i=1;  
62.             joseph * temp;  
63.             for(;i<round-1;i++)  
64.                 {  
65.                     temp=h;  
66.                     h=h->next;  
67.                 }  
68.           
69.             if(temp!=NULL)  
70.                 {  
71.                     temp->next=temp->next->next;  
72.                 }  
73.   
74.         }  
75.   
76.     joseph* joseph_function(joseph* h,int i,int sum)  
77.         {  
78.             int n=i-1;  
79.             int temp=n;;  
80.             joseph * j;  
81.             joseph * p;  
82.             while(1)  
83.             {     
84.                         while(temp--)  
85.                         {  
86.                             //j=h  
87.                             h=h->next;  
88.                               
89.                               
90.                         }  
91.                         temp=n;  
92.                 h->next=h->next->next; sum--;  
93.                 if(sum==1)  
94.                     break;  
95.             }  
96.             return h;  
97. }  
98.   
99.   
100.     int main(int argc,char ** argv)  
101.     {  
102.           
103.         int jos;  
104.         int step;  
105.         printf("生成约瑟夫换");  
106.         printf("/n");  
107.         scanf("%d",&jos);  
108.         printf("输入步长");  
109.         printf("/n");  
110.         scanf("%d",&step);  
111.   
112.         joseph* m=create(jos);  
113.         printf("链表的首地址%o",m);  
114.         printf("/n");  
115.         init_joseph(m);  
116.         joseph * temp=m;  
117.   
118.         while(temp->next!=NULL)  
119.             {  
120.                 //temp=m;  
121.                 printf("%d",temp->number);  
122.                 printf(" ");  
123.                 temp=temp->next;  
124.             }  
125.         printf("/n");  
126.     joseph * h;  
127.     h=joseph_function(m,step,jos);  
128.     printf("/n");  
129.     printf("最后的胜利者是%d",h->number);  
130.     printf("/n");  
131.   
132.   
133.           
134. }