（1）时间：截止9月8日中秋节晚8点
（2）目的：一是为了中秋热闹下，更重要的是数据结构、算法是一个完美程序必不可少的一部分。为了能够学习更多的算法思想，只要回复任何一个和算法相关的程序，可以是自己写的，也可以是别出看到的。可以是你黑马入学测试中的算法题。只要是算法就可以。
（3）要求：
a.说明算法原理
b.回复结构清晰
c.有适当的注释
亲友卷来源：上次黑马币买的，滔哥发来的。

下面举个例子：

1. 
   
2. /*
   
3. * 螺旋矩阵是指一个呈螺旋状的矩阵，它的数字由第一行开始到右边不断变大，向下变大，
   
4. * 向左变大，向上变大，如此循环。
   
5. */
   
6. 
   
7. public class Circle {
   
8.         /**
   
9.          * 接收三个参数，矩阵的行和列，以及起始数字
   
10.          */
    
11.         public static void main(String[] args) {
    
12.                 helix(4,4,1);
    
13.         }
    
14.         /*
    
15.          * 这个是左上角开始，顺时针转的螺旋
    
16.          *
    
17.          * 思想：先给最外层一圈赋值，再给第二圈赋值，直至结束
    
18.          * 循环次数由行和列中较小一个决定，即为大于--较小者一半的---最小整数
    
19.          */
    
20.         public static void helix(int w,int h,int start){
    
21.                 int[][] arr = new int[w][h];
    
22.                 int left=0,top=0,right=w-1,botton=h-1;
    
23.                 int max = w>h?(h+1)/2:(w+1)/2;
    
24.                 for(int i=0;i<max;i++){
    
25.                         for(int x=left;x<=right;x++){
    
26.                                 arr[top][x] = start++;
    
27.                         }
    
28.                         top++;
    
29.                         for(int y=top;y<=botton;y++){
    
30.                                 arr[y][right] = start++;
    
31.                         }
    
32.                         right--;
    
33.                         for(int z=right;z>=left;z--){
    
34.                                 arr[botton][z]=start++;
    
35.                         }
    
36.                         botton--;
    
37.                         for(int k=botton;k>=top;k--){
    
38.                                 arr[k][left]=start++;
    
39.                         }
    
40.                         left++;
    
41.                 }
    
42.                
    
43.                 for(int i=0;i<w;i++){
    
44.                         for(int j=0;j<h;j++){
    
45.                                 System.out.print(arr[i][j]+"\t");
    
46.                         }
    
47.                         System.out.println();
    
48.                 }
    
49.         }
    
50. }
    

复制代码

三维立体算法：

1. /*
   
2. * 3DCaptcha for .net
   
3. *
   
4. * http://www-personal.umich.edu/~mressl/3dcaptcha/     (php)
   
5. * http://code.google.com/p/3dcaptcha/                  (php)
   
6. *
   
7. * Translate :  Aimeast
   
8. * Blog      :  http://www.cnblogs.com/Aimeast/
   
9. */
   
10. 
    
11. using System;
    
12. using System.Drawing;
    
13. 
    
14. namespace Captcha
    
15. {
    
16.     public static class Captcha
    
17.     {
    
18.         private static double[] addVector(double[] a, double[] b)
    
19.         {
    
20.             return new double[] { a[0] + b[0], a[1] + b[1], a[2] + b[2] };
    
21.         }
    
22. 
    
23.         private static double[] scalarProduct(double[] vector, double scalar)
    
24.         {
    
25.             return new double[] { vector[0] * scalar, vector[1] * scalar, vector[2] * scalar };
    
26.         }
    
27. 
    
28.         private static double dotProduct(double[] a, double[] b)
    
29.         {
    
30.             return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
    
31.         }
    
32. 
    
33.         private static double norm(double[] vector)
    
34.         {
    
35.             return Math.Sqrt(dotProduct(vector, vector));
    
36.         }
    
37. 
    
38.         private static double[] normalize(double[] vector)
    
39.         {
    
40.             return scalarProduct(vector, 1.0 / norm(vector));
    
41.         }
    
42. 
    
43.         // http://en.wikipedia.org/wiki/Cross_product
    
44.         private static double[] crossProduct(double[] a, double[] b)
    
45.         {
    
46.             return new double[] {
    
47.                 (a[1] * b[2] - a[2] * b[1]),
    
48.                 (a[2] * b[0] - a[0] * b[2]),
    
49.                 (a[0] * b[1] - a[1] * b[0])
    
50.             };
    
51.         }
    
52. 
    
53.         private static double[] vectorProductIndexed(double[] v, double[] m, int i)
    
54.         {
    
55.             return new double[]{
    
56.                 v[i + 0] * m[0] + v[i + 1] * m[4] + v[i + 2] * m[8] + v[i + 3] * m[12],
    
57.                 v[i + 0] * m[1] + v[i + 1] * m[5] + v[i + 2] * m[9] + v[i + 3] * m[13],
    
58.                 v[i + 0] * m[2] + v[i + 1] * m[6] + v[i + 2] * m[10]+ v[i + 3] * m[14],
    
59.                 v[i + 0] * m[3] + v[i + 1] * m[7] + v[i + 2] * m[11]+ v[i + 3] * m[15]
    
60.             };
    
61.         }
    
62. 
    
63.         private static double[] vectorProduct(double[] v, double[] m)
    
64.         {
    
65.             return vectorProductIndexed(v, m, 0);
    
66.         }
    
67. 
    
68.         private static double[] matrixProduct(double[] a, double[] b)
    
69.         {
    
70.             double[] o1 = vectorProductIndexed(a, b, 0);
    
71.             double[] o2 = vectorProductIndexed(a, b, 4);
    
72.             double[] o3 = vectorProductIndexed(a, b, 8);
    
73.             double[] o4 = vectorProductIndexed(a, b, 12);
    
74. 
    
75.             return new double[]{
    
76.                 o1[0], o1[1], o1[2], o1[3],
    
77.                 o2[0], o2[1], o2[2], o2[3],
    
78.                 o3[0], o3[1], o3[2], o3[3],
    
79.                 o4[0], o4[1], o4[2], o4[3]
    
80.             };
    
81.         }
    
82. 
    
83.         // http://graphics.idav.ucdavis.edu/education/GraphicsNotes/Camera-Transform/Camera-Transform.html
    
84.         private static double[] cameraTransform(double[] C, double[] A)
    
85.         {
    
86.             double[] w = normalize(addVector(C, scalarProduct(A, -1)));
    
87.             double[] y = new double[] { 0, 1, 0 };
    
88.             double[] u = normalize(crossProduct(y, w));
    
89.             double[] v = crossProduct(w, u);
    
90.             double[] t = scalarProduct(C, -1);
    
91. 
    
92.             return new double[]{
    
93.                 u[0], v[0], w[0], 0,
    
94.                 u[1], v[1], w[1], 0,
    
95.                 u[2], v[2], w[2], 0,
    
96.                 dotProduct(u, t), dotProduct(v, t), dotProduct(w, t), 1
    
97.             };
    
98.         }
    
99. 
    
100.         // http://graphics.idav.ucdavis.edu/education/GraphicsNotes/Viewing-Transformation/Viewing-Transformation.html
     
101.         private static double[] viewingTransform(double fov, double n, double f)
     
102.         {
     
103.             fov *= (Math.PI / 180);
     
104.             double cot = 1.0 / Math.Tan(fov / 2);
     
105. 
     
106.             return new double[]{
     
107.                 cot,    0,      0,      0,
     
108.                 0,      cot,    0,      0,
     
109.                 0,      0,      (f + n) / (f - n),      -1,
     
110.                 0,      0,      2 * f * n / (f - n),    0
     
111.             };
     
112.         }
     
113. 
     
114.         public static Image Generate(string captchaText)
     
115.         {
     
116.             Random rnd = new Random();
     
117. 
     
118.             // 3dcha parameters
     
119.             int fontsize = 24;
     
120.             Font font = new Font("Arial", fontsize);
     
121. 
     
122.             SizeF sizeF;
     
123.             using (Graphics g = Graphics.FromImage(new Bitmap(1, 1)))
     
124.             {
     
125.                 sizeF = g.MeasureString(captchaText, font, 0, StringFormat.GenericDefault);
     
126.             }
     
127. 
     
128.             int image2d_x = (int)sizeF.Width;
     
129.             int image2d_y = (int)(fontsize * 1.3);
     
130. 
     
131.             double bevel = 4;
     
132. 
     
133.             // Create 2d image
     
134.             Bitmap image2d = new Bitmap(image2d_x, image2d_y);
     
135.             Color black = Color.Black;
     
136.             Color white = Color.White;
     
137. 
     
138.             // Paint 2d image
     
139.             using (Graphics g = Graphics.FromImage(image2d))
     
140.             {
     
141.                 g.Clear(black);
     
142.                 g.DrawString(captchaText, font, Brushes.White, 0, 0);
     
143.             }
     
144.             // Calculate projection matrix
     
145.             double[] T = cameraTransform(
     
146.                    new double[] { rnd.Next(-90, 90), -200, rnd.Next(150, 250) },
     
147.                    new double[] { 0, 0, 0 }
     
148.                 );
     
149.             T = matrixProduct(
     
150.                     T,
     
151.                     viewingTransform(60, 300, 3000)
     
152.                 );
     
153. 
     
154.             // Calculate coordinates
     
155.             double[][] coord = new double[image2d_x * image2d_y][];
     
156. 
     
157.             int count = 0;
     
158.             for (int y = 0; y < image2d_y; y += 2)
     
159.             {
     
160.                 for (int x = 0; x < image2d_x; x++)
     
161.                 {
     
162.                     // calculate x1, y1, x2, y2
     
163.                     int xc = x - image2d_x / 2;
     
164.                     int zc = y - image2d_y / 2;
     
165.                     double yc = -(double)(image2d.GetPixel(x, y).ToArgb() & 0xff) / 256 * bevel;
     
166.                     double[] xyz = new double[] { xc, yc, zc, 1 };
     
167.                     xyz = vectorProduct(xyz, T);
     
168. 
     
169.                     coord[count] = xyz;
     
170.                     count++;
     
171.                 }
     
172.             }
     
173. 
     
174.             // Create 3d image
     
175.             int image3d_x = 256;
     
176.             //$image3d_y = $image3d_x / 1.618;
     
177.             int image3d_y = image3d_x * 9 / 16;
     
178.             Bitmap image3d = new Bitmap(image3d_x, image3d_y);
     
179.             Color fgcolor = Color.White;
     
180.             Color bgcolor = Color.Black;
     
181.             using (Graphics g = Graphics.FromImage(image3d))
     
182.             {
     
183.                 g.Clear(bgcolor);
     
184.                 count = 0;
     
185.                 double scale = 1.75 - (double)image2d_x / 400;
     
186.                 for (int y = 0; y < image2d_y; y += 2)
     
187.                 {
     
188.                     for (int x = 0; x < image2d_x; x++)
     
189.                     {
     
190.                         if (x > 0)
     
191.                         {
     
192.                             double x0 = coord[count - 1][0] * scale + image3d_x / 2;
     
193.                             double y0 = coord[count - 1][1] * scale + image3d_y / 2;
     
194.                             double x1 = coord[count][0] * scale + image3d_x / 2;
     
195.                             double y1 = coord[count][1] * scale + image3d_y / 2;
     
196.                             g.DrawLine(new Pen(fgcolor), (float)x0, (float)y0, (float)x1, (float)y1);
     
197.                         }
     
198.                         count++;
     
199.                     }
     
200.                 }
     
201.             }
     
202.             return image3d;
     
203.         }
     
204.     }
     
205. }

复制代码

使用方法：

1. this.BackgroundImage = Captcha.Generate("Code");

复制代码

效果图：

宋超 发表于 2014-9-4 14:14
三维立体算法：
使用方法：

都是大牛  

1. /*
   
2. 快速排序：
   
3. 步骤：
   
4. 1、选择一个标准元素
   
5. 2、使用该标准元素分割数组，使得比该元素小的元素在它的左边，比它大的在右边。并
   
6.         把标准元素放在合适的位置。  
   
7. 3、根据标准元素最后确定的位置，把数组分成三部分，左边的，右边的，枢纽元素自己，
   
8.         然后再对左边的和右边的分别递归调用快速排序算法即可。  
   
9. */
   
10. 
    
11. 
    
12. class QuickSort{
    
13.         public static void main(String[] args) {
    
14.                 int [] x = new int[]{16,54,5,61,12,31,25,11,76,22,10};
    
15.                
    
16.                 sopArray(x);
    
17.                
    
18.                quickSort(x,0,x.length-1);
    
19.                
    
20.                sopArray(x);
    
21.         }
    
22.         private static void quickSort(int[] arr, int left, int right) {
    
23.                 int l,r; //左右哨兵 ，l为左哨兵位置，r为右哨兵位置
    
24.                 int baseNum; //存储基准数
    
25.                
    
26.                 if(left > right)
    
27.                         return;
    
28.                
    
29.                 baseNum = arr[left]; //第一次基准数默认为数组首位
    
30.                 l = left;  //左哨兵从左边出发扫描
    
31.                 r = right; //右哨兵从右边出发扫描
    
32.                 while(l != r) {
    
33.                         //先从右边开始往左扫描,找到第一个比基准数小的
    
34.                         while(arr[r] >= baseNum && l < r)
    
35.                                 r--;
    
36.                         //再从左边开始往右扫描,找到第一个比基准数大的
    
37.                         while(arr[l] <= baseNum && l < r)
    
38.                                 l++;
    
39.                         //交换两个数位置
    
40.                         if(l < r) {
    
41.                                 int temp = arr[l];
    
42.                                 arr[l] = arr[r];
    
43.                                 arr[r] = temp;
    
44.                         }
    
45.                 }
    
46.                
    
47.                 //基准数归位
    
48.                 arr[left] = arr[l];
    
49.                 arr[l] = baseNum;
    
50.                
    
51.                 //递归处理左边
    
52.                 quickSort(arr, left, l - 1);
    
53.                 //递归处理右边
    
54.                 quickSort(arr, l + 1, right);
    
55.         }

复制代码

楼主 说好的亲友卷呢 。460791814 谢谢

宋超 发表于 2014-9-4 15:09
楼主 说好的亲友卷呢 。460791814 谢谢

最后随机给，时间还没到，你那写的来点注释！

hejinzhong 发表于 2014-9-4 15:21
最后随机给，时间还没到，你那写的来点注释！

加好友哇 ，你好多黑马币

我讨厌不加注释的代码...

不加注释的代码就和吃没吃过的东西 但是没说明怎么吃  的感觉是一样一样的

1. 
   
2. 
   
3. 约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围,从1开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到最后一个人。
   
4. //下面是报数14
   
5. 
   
6. import java.util.Scanner;
   
7. public class Ex14 {
   
8.         public static void main(String[] args) {
   
9.                 Scanner s = new Scanner(System.in);
   
10.                 int n = s.nextInt();
    
11.                 boolean[] arr = new boolean[n];
    
12.                 for (int i = 0; i < arr.length; i++) {
    
13.                         arr[i] = true;// 下标为TRUE时说明还在圈里
    
14.                 }
    
15.                 int leftCount = n;
    
16.                 int countNum = 0;
    
17.                 int index = 0;
    
18.                 while (leftCount > 1) {
    
19.                         if (arr[index] == true) {// 当在圈里时
    
20.                                 countNum++; // 报数递加
    
21.                                 if (countNum == 14) {// 报道14时
    
22.                                         countNum = 0;// 从零开始继续报数
    
23.                                         arr[index] = false;// 此人退出圈子
    
24.                                         leftCount--;// 剩余人数减一
    
25.                                 }
    
26.                         }
    
27.                         index++;// 每报一次数，下标加一
    
28.                         if (index == n) {// 是循环数数，当下标大于n时，说明已经数了一圈，
    
29.                                 index = 0;// 将下标设为零重新开始。
    
30.                         }
    
31.                 }
    
32.                 for (int i = 0; i < n; i++) {
    
33.                         if (arr[i] == true) {
    
34.                                 System.out.println(i + 1);
    
35.                         }
    
36.                 }
    
37.         }
    
38. }
    
39. 
    

复制代码

入学测试我做了这个题了，做的要疯了。。。

约瑟夫环问题:500个人站成一圈,从一开始数,数到三或三的倍数则被杀掉,下一个人接着数,幸运的是第几个人

1. 
   
2. import java.util.LinkedList;
   
3. 
   
4. public class Test7 {
   
5. 
   
6.         public static void main(String[] args) {
   
7.                 LinkedList<Integer> num=new LinkedList<>();                                                //定义list集合接收1~500的数据
   
8.                 for(int i=1;i<=500;i++){                                                                                                                        //将这500个数据存入集合
   
9.                         num.add(i);
   
10.                 }
    
11.                 int count=0;                                                                                                                                                        //定义计数器用来数数
    
12. 
    
13.                 for(int i=0;i<num.size();){                                                                                                                //遍历集合
    
14.                         count++;                                                                                                                                                        //计数器增加
    
15.                         if(count%3==0){               
    
16.                         num.remove(i--);                                                                                                                                //当计数器为3的倍数的时候,从集合中去掉当前的数,去掉当前的数后,另索引回拨一个
    
17.                         }
    
18.                         i++;                                                                                                                                                                        //下一个数
    
19.                         if((i==num.size())&&num.size()!=1){                                                                        //当索引等于集合个数时,并且集合元素大于1,则从头开始遍历集合
    
20.                                 i=0;
    
21.                         }
    
22.                 }
    
23.                 System.out.println("幸存的是第"+num.get(0)+"人");                                //最后留下的一个数就是那个幸运的人
    
24.         }
    
25. 
    
26. }
    

复制代码

学习了～

只是看看o.o

1. import java.util.Scanner;
   
2. class  MatrixArray
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 Scanner input = new Scanner(System.in);
   
7.                 System.out.println("请输入矩阵的宽度：");
   
8.                 int length=input.nextInt();
   
9.                 //矩阵用二维数组位置可以一一对应
   
10.                 int[][] arr = new int[length][length];
    
11.                 //定义一个变量控制循环所在位置，当count 每自增一次循环内圈进入一次
    
12.                 int count =0;
    
13.                 //字义数值，每次赋值都自增一次让值一直是+1
    
14.                 int number=1;
    
15.                 //利用循环控制count自增，以达到控制循环所在位置，不断向内赋值
    
16.                 /*
    
17.                 while(count<length/2+1)
    
18.                 {//每行数据赋值个数相同都是length-1个
    
19.                         //for循环输入第一行数据，其中不包括最后一个数
    
20.                         for(int x =count;x<length-1-count;x++,number++)
    
21.                         {
    
22.                                 arr[count][x]=number;
    
23.                         }
    
24.                         //for循环输入纵向还没赋值的最后一排的数据，其中不包括最下面一个数
    
25.                         for(int x =count;x<length-1-count;x++,number++)
    
26.                         {
    
27.                                 arr[x][length-1-count]=number;
    
28.                         }
    
29.                         //for循环输入还没赋值的最下边一行数据，其中不包括行第一个数
    
30.                         for(int x = length-1-count;x>count;x--,number++)
    
31.                         {
    
32.                                 arr[length-1-count][x]=number;
    
33.                         }
    
34.                         //for循环输入还没赋值的纵向第一排数据，其中不包括最上面的数
    
35.                         for(int x = length-1-count;x>count;x--,number++)
    
36.                         {
    
37.                                 arr[x][count]=number;
    
38.                         }
    
39.                
    
40.                         count++;
    
41.                 }
    
42.                 */
    
43.                
    
44.                 //这种方式会把中间位置重复赋值，运算完成后需要对中间位置进行判定
    
45.                 //此时 中间公位置的元素赋值不正确
    
46.                 while(count<length/2+1)
    
47.                 {//第次赋值数据不相同，上和下赋值时数据个数为length，左右赋值为length-2
    
48.                         //for循环输入第一行数据，其中不包括最后一个数
    
49.                         for(int x =count;x<length-count;x++,number++)
    
50.                         {
    
51.                                 arr[count][x]=number;
    
52.                         }
    
53.                         //for循环输入纵向还没赋值的最后一排的数据，其中不包括最下面一个数
    
54.                         for(int x =count+1;x<length-1-count;x++,number++)
    
55.                         {
    
56.                                 arr[x][length-1-count]=number;
    
57.                         }
    
58.                         //for循环输入还没赋值的最下边一行数据，其中不包括行第一个数
    
59.                         for(int x = length-count-1;x>=count;x--,number++)
    
60.                         {       
    
61.                                 if((length%2==1)&&(length - 1 - count) == (length/2))
    
62.                                 {
    
63.                                         break;
    
64.                                 }
    
65.                                 arr[length-1-count][x]=number;
    
66.                         }
    
67.                         //for循环输入还没赋值的纵向第一排数据，其中不包括最上面的数
    
68.                         for(int x = length-2-count;x>count;x--,number++)
    
69.                         {
    
70.                                 arr[x][count]=number;
    
71.                         }
    
72.                
    
73.                         count++;
    
74.                 }
    
75. 
    
76. 
    
77. 
    
78.                
    
79.                 for(int x=0;x<length;x++)
    
80.                 {
    
81.                         for(int y=0;y<length;y++)
    
82.                         {
    
83.                                 System.out.print(arr[x][y]+"\t");
    
84.                         }
    
85.                         System.out.println();
    
86.                 }
    
87.         }
    
88. }
    

复制代码

我的螺旋矩阵的作法可能没有你的简单应该说更好理解吧

学 习 了

学习一下

我纯属来凑热闹的:lol