精通java算法
大家加油噢！
让你学会各种精通java的各种精妙算法!!!
1import java.util.*;
2public class BubbleSort{
3public void sort(int[] a){
4for(int i=0;i
5for(int j=a.length-1;j>=i+1;j--){
6if(a[j]>a[j-1]){
7int tmp =a[j];
8a[j]=a[j-1];
9a[j-1]=tmp;
10}
11}
12}
13}
14public static void main(String[] args){ 15int[] a = {1,6,3,8,1,56,};
16BubbleSort bs = new BubbleSort();
17bs.sort(a);
18System.out.println(Arrays.toString(a)); 19}
20}
21
22 2 InsertSort
23import java.util.*;
24public class InsertSort{
25private int i=0;
26public void sort(int[] a){
27for(int j=1;j
28int keys = a[j];
29i =j-1;
30while(i>=0&&a[i]>keys){
31a[i+1]=a[i];
32i--;
33}
34a[i+1]=keys;
35}
36}
37public static void main(String[] args){ 38InsertSort i = new InsertSort();
39int[] f={5,2,4,6,1,3,0};
40i.sort(f);
41System.out.println(Arrays.toString(f)); 42}
44 3 MergeSort
45import java.util.*;
46public class MergeSortTest{
47private int[] l,r1;
48public void merge(int[] a,int p,int q,int r){ 49int n1 =q-p+1;
50int n2 = r-q;
51l=new int[n1];
52r1 = new int[n2+1];
53for(int i=0;i
54l[i]=a[p+i];
55}
56l[n1-1]=Integer.MAX_VALUE;
57for(int i=0;i
58r1[i]=a[q+i];
59}
60r1[n2] =Integer.MAX_VALUE;
61int i=0;
62int j=0;
63for(int k=p;k
64if(l[i]<=r1[j]){
65a[k]=l[i];
66i=i+1;
67}else{
68a[k]=r1[j];
69j=j+1;
70}
71}
72}
73public void mergeSort(int[] a,int p,int r){ 74if(p+1
75int q=(p+r)/2;
76mergeSort(a,p,q);
77mergeSort(a,q,r);
78merge(a,p,q,r);
79}
80}
81public static void main(String[] args){
82int[] a1 = {3,41,52,26,38,57,9,49};
83MergeSortTest mst =new MergeSortTest();
84mst.mergeSort(a1,0,a1.length);
85System.out.println(Arrays.toString(a1));
86}
88 4 SelectionSort
89import java.util.*;
90public class MergeSortTest{
91private int[] l,r1;
92public void merge(int[] a,int p,int q,int r){ 93int n1 =q-p+1;
94int n2 = r-q;
95l=new int[n1];
96r1 = new int[n2+1];
97for(int i=0;i
98l[i]=a[p+i];
99}
100l[n1-1]=Integer.MAX_VALUE;
101for(int i=0;i
102r1[i]=a[q+i];
103}
104r1[n2] =Integer.MAX_VALUE;
105int i=0;
106int j=0;
107for(int k=p;k
108if(l[i]<=r1[j]){
109a[k]=l[i];
110i=i+1;
111}else{
112a[k]=r1[j];
113j=j+1;
114}
115}
116}
117public void mergeSort(int[] a,int p,int r){ 118if(p+1
119int q=(p+r)/2;
120mergeSort(a,p,q);
121mergeSort(a,q,r);
122merge(a,p,q,r);
123}
124}
125public static void main(String[] args){
126int[] a1 = {3,41,52,26,38,57,9,49};
127MergeSortTest mst =new MergeSortTest();
128mst.mergeSort(a1,0,a1.length);
129System.out.println(Arrays.toString(a1)); 130}
1325 HeapSort
133import java.util.*;
134public class HeapSort{
135private int largest;
136public int left(int i){
137return 2*i+1;
138}
139public int right(int j){
140return 2*j+2;
141}
142public void maxHeapify(int[] a,int i){ 143int l=left(i);
144int r=right(i);
145if((la[i])){
146largest=l;
147}else{
148largest=i;
149}
150if((ra[largest])){
151largest=r;
152}
153if(largest!=i){
154int temp = a[i];
155a[i]=a[largest];
156a[largest]=temp;
157maxHeapify(a,largest);
158}
159}
160public void buildMaxHeap(int[] a){
161for(int i=a.length/2;i>=0;--i){
162maxHeapify(a,i);
163}
164}
165public void sort(int[] a){
166buildMaxHeap(a);
167//System.out.println(Arrays.toString(a)); 168for(int i=a.length-1;i>=1;--i){
169int temp=a[0];
170a[0]=a[i];
171a[i]=temp;
172int[] b= new int[i];
173System.arraycopy(a,0,b,0,i-1);
174maxHeapify(b,0);
175System.arraycopy(b,0,a,0,i-1);
176}
177}
178public static void main(String[] args){
179HeapSort hs = new HeapSort();
180int[] a={23,17,14,6,13,10,1,5,7};
181hs.sort(a);
182System.out.println(Arrays.toString(a));
183}
184}
1856 BucketSort
186import java.util.*;
187public class BucketSort {
188/**
189* @param args
190*/
191private LinkedList[] b;
192public void sort(double[] a){
193int n=a.length;
194b=new LinkedList[a.length];
195for(int i=0;i
196b[(int)(n*a[i])] = new LinkedList();
197}
198for(int i=0;i
199b[(int)(n*a[i])].add(Double.valueOf(a[i]));
200//System.out.println(b[(int)(n*a[i])]);
201}
202//System.out.println(Arrays.toString(b));
203for(int i=0;i
204if(b[i]==null){
205continue;
206}else{
207Collections.sort(b[i]);
208}
209}
210}
211public static void main(String[] args) {
212// TODO Auto-generated method stub
213double[] a ={0.79,0.13,0.16,0.64,0.39,0.20,0.89,0.53,0.71,0.42}; 214BucketSort bs = new BucketSort();
215bs.sort(a);
216for(int i=0;i
217if(bs.b[i]==null){
218continue;
219}else{
220Iterator it =bs.b[i].iterator();
221while(it.hasNext()){
222System.out.print(it.next()+" ");
223}
224}
225}
226//System.out.println(Arrays.toString(bs.b));
227}
228}
2297 CountingSort
230import java.util.*;
231public class CountingSort {
232/**
233* @param args
234*/
235public void Sort(int[] a,int[] b,int k){
236int[] c= new int[k+1];
237for(int j=0;j
238c[a[j]]=c[a[j]]+1;
239}
240for(int i=1;i
241c[i]=c[i]+c[i-1];
242}
243for(int j=a.length-1;j>=0;j--){
244b[c[a[j]]-1]=a[j];
245c[a[j]]=c[a[j]]-1;
246}
247}
248public static void main(String[] args) {
249// TODO Auto-generated method stub
250int[] a=new int[]{3,1,12,11,4,13};
251CountingSort cs = new CountingSort();
252int[] b = new int[a.length];
253cs.Sort(a,b,13);
254System.out.println(Arrays.toString(b));
255}
256}
1 Fibonacci
Fibonacci为1200年代的欧洲数学家，在他的著作中曾经提到：若有一只兔子每个月生一只
小兔子，一个月后小兔子也开始生产。起初只有一只兔子，一个月后就有两只兔子，两个月后有三只兔子，三个月后有五只兔子（小兔子投入生产）……
这就是Fibonacci数列，一般习惯称之为费式数列，例如：1，1，2，3，5，8，13，21，34，55，89，……
Java代码
257public class Fibonacci {
258public static void main(String[] args) {
259int[] fib = new int[20];
260
261 fib[0] = 0;
262 fib[1] = 1;
263
264for(int i = 2; i < fib.length; i++)
265 fib[i] = fib[i-1] + fib[i-2];
266
267for(int i = 0; i < fib.length; i++)
268 System.out.print(fib[i] + " ");
269 System.out.println();
270 }
271}
2 巴斯卡（Pascal）
三角形基本上就是在解nCr ，因为三角形上的每一个数字各对应一个nCr ，其中n为row，而r为colnmu
Java代码
272import java.awt.*;
273import javax.swing.*;
274
275public class Pascal extends JFrame {
276public Pascal() {
277 setBackground(Color.white);
278 setTitle("巴斯卡三角形");
279 setSize(520, 350);
280 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
281 show();
282 }
283
284private long combi(int n, int r){
285int i;
286long p = 1;
287
288for(i = 1; i <= r; i++)
289 p = p * (n-i+1) / i;
290
291return p;
292 }
293
294public void paint(Graphics g) {
295final int N = 12;
296int n, r, t;
297
298for(n = 0; n <= N; n++) {
299for(r = 0; r <= n; r++)
300 g.drawString(" " + combi(n, r),
301 (N-n)*20 + r * 40, n * 20 + 50);
302 }
303 }
304
305public static void main(String args[]) {
306 Pascal frm = new Pascal();
307 }
308}
3 ThreeColorFlags
ThreeColorFlags问题最早由E.W.Dijkstra所提出，塔所使用的用语为Dutch Nation Flag （Dijkstra为荷兰人），而多数的作者则使用Three-Color Flag来说明。
假设有一条绳子，上面有红，白，蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列蓝，白，红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。
Java代码
309import java.io.*;
310
311public class ThreeColorsFlags {
312private void swap(char[] flags, int x, int y) {
313char temp;
314 temp = flags[x];
315 flags[x] = flags[y];
316 flags[y] = temp;
317 }
318
319public String move(char[] flags) {
320int wFlag = 0;
321int bFlag = 0;
322int rFlag = flags.length - 1;
323
324while(wFlag <= rFlag) {
325if(flags[wFlag] == 'W') {
326 wFlag++;
327 }
328else if(flags[wFlag] == 'B') {
329 swap(flags, bFlag, wFlag);
330 bFlag++;
331 wFlag++;
332 }
333else {
334while(wFlag < rFlag && flags[rFlag] == 'R')
335 rFlag--;
336 swap(flags, rFlag, wFlag);
337 rFlag--;
338 }
339 }
340
341return new String(flags);
342 }
343
344public static void main(String[] args)
345throws IOException {
346 BufferedReader buf;
347 buf = new BufferedReader(
348new InputStreamReader(System.in));
349
350 System.out.print("输入三色旗顺序（ex. RWBBWRWR）：");
351 String flags = buf.readLine();
352
353 ThreeColorsFlags threeColorsFlag = new ThreeColorsFlags(); 354 flags = threeColorsFlag.move(
355 flags.toUpperCase().toCharArray());
356
357 System.out.println("移动顺序后：" + flags);
358 }
359}
4 Mouse
Mouse走迷宫是循环求解的基本类型，我们在二维数组中用2来表示迷宫的墙壁，使用1来表示老鼠的行走路径，并用程序求出从入口到出口的距离。
Java代码
360public class Mouse {
361private int startI, startJ; // 入口
362private int endI, endJ; // 出口
363private boolean success = false;
364
365public static void main(String[] args) {
366int[][] maze = {{2, 2, 2, 2, 2, 2, 2},
367 {2, 0, 0, 0, 0, 0, 2},
368 {2, 0, 2, 0, 2, 0, 2},
369 {2, 0, 0, 2, 0, 2, 2},
370 {2, 2, 0, 2, 0, 2, 2},
371 {2, 0, 0, 0, 0, 0, 2},
372 {2, 2, 2, 2, 2, 2, 2}};
373
374 System.out.println("显示迷宫：");
375for(int i = 0; i < maze.length; i++) {
376for(int j = 0; j < maze[0].length; j++)
377if(maze[j] == 2)
378 System.out.print("█");
379else
380 System.out.print(" ");
381 System.out.println();
382 }
383
384 Mouse mouse = new Mouse();
385 mouse.setStart(1, 1);
386 mouse.setEnd(5, 5);
387
388if(!mouse.go(maze)) {
389 System.out.println("\n没有找到出口！");
390 }
391else {
392 System.out.println("\n找到出口！");
393for(int i = 0; i < maze.length; i++) {
394for(int j = 0; j < maze[0].length; j++) { 395if(maze[j] == 2)
396 System.out.print("█");
397else if(maze[j] == 1)
398 System.out.print("◇");
399else
400 System.out.print(" ");
401 }
402 System.out.println();
403 }
404 }
405 }
406
407public void setStart(int i, int j) {
408this.startI = i;
409this.startJ = j;
410 }
411
412public void setEnd(int i, int j) {
413this.endI = i;
414this.endJ = j;
415 }
416
417public boolean go(int[][] maze) {
418return visit(maze, startI, startJ);
419 }
420
421private boolean visit(int[][] maze, int i, int j) { 422 maze[j] = 1;
423
424if(i == endI && j == endJ)
425 success = true;
426
427if(!success && maze[j+1] == 0)
428 visit(maze, i, j+1);
429if(!success && maze[i+1][j] == 0)
430 visit(maze, i+1, j);
431if(!success && maze[j-1] == 0)
432 visit(maze, i, j-1);
433if(!success && maze[i-1][j] == 0)
434 visit(maze, i-1, j);
435
436if(!success)
437 maze[j] = 0;
438
439return success;
440 }
441}
5 Knight tour
骑士游戏，在十八世纪倍受数学家与拼图迷的注意，骑士的走法为西洋棋的走发，骑士可以由任何一个位置出发，它要如何走完所有的位置。
Java代码
442public class Knight {
443public boolean travel(int startX,
444int startY, int[][] board) {
445 // 对应骑士可以走的八个方向
446int[] ktmove1 = {-2, -1, 1, 2, 2, 1, -1, -2};
447int[] ktmove2 = {1, 2, 2, 1, -1, -2, -2, -1};
448
449 // 下一个出路的位置 int[] nexti = new int[board.length];
450int[] nextj = new int[board.length];
451
452 // 记录出路的个数
453int[] exists = new int[board.length];
454
455int x = startX;
456int y = startY;
457
458 board[x][y] = 1;
459
460for(int m = 2; m <= Math.pow(board.length, 2); m++) {
461for(int k = 0; k < board.length; k++) {
462 exists[k] = 0;
463 }
464
465int count = 0;
466 // 试探八个方向
467for(int k = 0; k < board.length; k++) {
468int tmpi = x + ktmove1[k];
469int tmpj = y + ktmove2[k];
470
471 // 如果是边界，不可以走
472if(tmpi < 0 || tmpj < 0 ||
473 tmpi > 7 || tmpj > 7) {
474continue;
475 }
476
477 // 如果这个方向可以走，记录下来
478if(board[tmpi][tmpj] == 0) {
479 nexti[count] = tmpi;
480 nextj[count] = tmpj;
481 // 可走的方向加一个
482 count++;
483 }
484 }
485
486int min = -1;
487if(count == 0) {
488return false;
489 }
490else if(count == 1) {
491 min = 0;
492 }
493else {
494 // 找出下个位置的出路数
495for(int l = 0; l < count; l++) {
496for(int k = 0; k < board.length; k++) { 497int tmpi = nexti[l] + ktmove1[k]; 498int tmpj = nextj[l] + ktmove2[k]; 499
500if(tmpi < 0 || tmpj < 0 ||
501 tmpi > 7 || tmpj > 7) {
502continue;
503 }
504
505if(board[tmpi][tmpj] == 0)
506 exists[l]++;
507 }
508 }
509
510int tmp = exists[0];
511 min = 0;
512
513 // 从可走的方向寻找最少出路的方向
514for(int l = 1; l < count; l++) {
515if(exists[l] < tmp) {
516 tmp = exists[l];
517 min = l;
518 }
519 }
520 }
521
522 // 走最少出路的方向
523 x = nexti[min];
524 y = nextj[min];
525 board[x][y] = m;
526 }
527
528return true;
529 }
530
531public static void main(String[] args) {
532int[][] board = new int[8][8];
533 Knight knight = new Knight();
534
535if(knight.travel(
536 Integer.parseInt(args[0]),
537 Integer.parseInt(args[1]), board)) { 538 System.out.println("走棋完成！");
539 }
540else {
541 System.out.println("走棋失败！");
542 }
543
544for(int i = 0; i < board.length; i++) {
545for(int j = 0; j < board[0].length; j++) { 546if(board[i][j] < 10) {
547 System.out.print(" " + board[i][j]); 548 }
549else {
550 System.out.print(board[i][j]);
551 }
552 System.out.print(" ");
553 }
554 System.out.println();
555 }
556 }
557}
6 Queen
西洋棋中的皇后可以直线前进，吃掉遇到的所有棋子，如果棋盘上有八个皇后，则这八个皇后如何相安无事的放置在棋盘上？
Java代码
558public class Queen {
559 // 同位置是否有皇后，1表示有
560private int[] column;
561 // 右上至左下是否有皇后
562private int[] rup;
563 // 左上至右下是否有皇后
564private int[] lup;
565 // 解答
566private int[] queen;
567
568 // 解答编号
569private int num;
570
571public Queen() {
572 column = new int[8+1];
573 rup = new int[2*8+1];
574 lup = new int[2*8+1];
575
576for(int i = 1; i <= 8; i++)
577 column[i] = 1;
578
579for(int i = 1; i <= 2*8; i++)
580 rup[i] = lup[i] = 1;
581
582 queen = new int[8+1];
583 }
584
585public void backtrack(int i) {
586if(i >
{
587 showAnswer();
588 }
589else {
590for(int j = 1; j <= 8; j++) {
591if(column[j] == 1 &&
592 rup[i+j] == 1 &&
593 lup[i-j+8] == 1) {
594 queen[i] = j;
595 // 设定为占用
596 column[j] = rup[i+j] = lup[i-j+8] = 0;
597 backtrack(i+1);
598 column[j] = rup[i+j] = lup[i-j+8] = 1;
599 }
600 }
601 }
602 }
603
604protected void showAnswer() {
605 num++;
606 System.out.println("\n解答 " + num);
607for(int y = 1; y <= 8; y++) {
608for(int x = 1; x <= 8; x++) {
609if(queen[y] == x) {
610 System.out.print(" Q");
611 }
612else {
613 System.out.print(" .");
614 }
615 }
616 System.out.println();
617 }
618 }
619
620public static void main(String[] args) {
621 Queen queen = new Queen();
622 queen.backtrack(1);
623 }
624}
7 Coins
现在有八枚银币abcdefg，已知其中一枚是假币，其重量不同于真币，但不知道是轻还是重，如何用天平以最小的比较次数决定出那个是假币，并得知假币是比真币轻还是重。
Java代码
625public class Coins {
626private int[] coins;
627
628public Coins() {
629 coins = new int[8];
630for(int i = 0; i < 8; i++)
631 coins[i] = 10;
632 }
633
634public void setFake(int weight) {
635 coins[(int) (Math.random() * 7)] = weight;
636 }
637
638public void fake() {
639if(coins[0]+coins[1]+coins[2] ==
640 coins[3]+coins[4]+coins[5]) {
641if(coins[6] > coins[7])
642 compare(6, 7, 0);
643else
644 compare(7, 6, 0);
645 }
646else if(coins[0]+coins[1]+coins[2] >
647 coins[3]+coins[4]+coins[5]) {
648if(coins[0]+coins[3] == coins[1]+coins[4])
649 compare(2, 5, 0);
650else if(coins[0]+coins[3] > coins[1]+coins[4]) 651 compare(0, 4, 1);
652if(coins[0]+coins[3] < coins[1]+coins[4])
653 compare(1, 3, 0);
654 }
655else if(coins[0]+coins[1]+coins[2] <
656 coins[3]+coins[4]+coins[5]) {
657if(coins[0]+coins[3] == coins[1]+coins[4])
658 compare(5, 2, 0);
659else if(coins[0]+coins[3] > coins[1]+coins[4]) 660 compare(3, 1, 0);
661if(coins[0]+coins[3] < coins[1]+coins[4])
662 compare(4, 0, 1);
663 }
664 }
665
666protected void compare(int i, int j, int k) {
667if(coins[i] > coins[k])
668 System.out.print("\n假币 " + (i+1) + " 较重");
669else
670 System.out.print("\n假币 " + (j+1) + " 较轻");
671 }
672
673public static void main(String[] args) {
674if(args.length == 0) {
675 System.out.println("输入假币重量（比10大或小）");
676 System.out.println("ex. java Coins 5");
677return;
678 }
679
680 Coins eightCoins = new Coins();
681 eightCoins.setFake(Integer.parseInt(args[0]));
682 eightCoins.fake();
683 }
684}
8 Life game
生命游戏，为1970年英国数学家J.H.Conway所提出，某一细胞的邻居包括上，下，左，右，左上，左下，右上与右下相邻的细胞，游戏规则如下：
1，孤单死亡：如果细胞的邻居小于一个，则该细胞在下一个状态死亡。
2，拥挤死亡：如果细胞的邻居在四个以上，则该细胞在下一个状态死亡。
3，稳定：如果细胞的邻居为两个或三个，则该细胞在下一个状态稳定。
4，复活：如果某位置原无细胞存活，而该位置的邻居为三个，则该位置将复活一个细胞。
Java代码
685import java.io.BufferedReader;
686import java.io.IOException;
687import java.io.InputStreamReader;
688
689public class LifeGame {
690private boolean[][] map;
691private boolean[][] newmap;
692
693public LifeGame(int maxRow, int maxColumn) {
694 map = new boolean[maxRow][maxColumn];
695 newmap = new boolean[maxRow][maxColumn];
696 }
697
698public void setCell(int x, int y) {
699 map[x][y] = true;
700 }
701
702public void next() {
703for(int row = 0; row < map.length; row++) {
704for(int col = 0; col < map[0].length; col++) { 705switch (neighbors(row, col)) {
706case 0:
707case 1:
708case 4:
709case 5:
710case 6:
711case 7:
712case 8:
713 newmap[row][col] = false;
714break;
715case 2:
716 newmap[row][col] = map[row][col];
717break;
718case 3:
719 newmap[row][col] = true;
720break;
721 }
722 }
723 }
724
725 copyMap();
726 }
727
728public void outputMap() throws IOException {
729 System.out.println("\n\nGame of life cell status"); 730for(int row = 0; row < map.length; row++) {
731 System.out.print("\n ");
732for(int col = 0; col < map[0].length; col++) 733if(map[row][col] == true)
734 System.out.print('#');
735else
736 System.out.print('-');
737 }
738 }
739
740private void copyMap() {
741for(int row = 0; row < map.length; row++)
742for(int col = 0; col < map[0].length; col++) 743 map[row][col] = newmap[row][col];
744 }
745
746private int neighbors(int row, int col) {
747int count = 0;
748
749for(int r = row-1; r <= row+1; r++)
750for(int c = col-1; c <= col+1; c++) {
751if(r < 0 || r >= map.length ||
752 c < 0 || c >= map[0].length)
753continue;
754if(map[r][c] == true)
755 count++;
756 }
757
758if(map[row][col] == true)
759 count--;
760
761return count;
762 }
763
764public static void main(String[] args)
765throws NumberFormatException, IOException { 766 BufferedReader bufReader =
767new BufferedReader(
768new InputStreamReader(System.in));
769
770 LifeGame game = new LifeGame(10, 25);
771
772 System.out.println("Game of life Program");
773 System.out.println(
774 "Enter x, y where x, y is living cell"); 775 System.out.println("0 <= x < 10, 0 <= y < 25"); 776 System.out.println("Terminate with x, y = -1, -1"); 777
JAVA经典算法案例
JA V A经典算法40例 【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21.... public class exp2{ public static void main(String args[]){ int i=0; for(i=1;i<=20;i++) System.out.println(f(i)); } public static int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 或 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=1;i<=20;i++) System.out.println(mymath.f(i)); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 【程序2】题目：判断101-200之间有多少个素数，并输出所有素数。 1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=2;i<=200;i++) if(mymath.iszhishu(i)==true) System.out.println(i); } } class math { public boolean iszhishu(int x) { for(int i=2;i<=x/2;i++) if (x % i==0 ) return false; return true; } } 【程序3】题目：打印出所有的"水仙花数"，所谓"水仙花数 "是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水
Java数据结构和算法
Java数据结构和算法 一、数组于简单排序 (1) 二、栈与队列 (4) 三、链表 (7) 四、递归 (22) 五、哈希表 (25) 六、高级排序 (25) 七、二叉树 (25) 八、红—黑树 (26) 九、堆 (36) 十、带权图 (39) 一、数组于简单排序 数组 数组（array）是相同类型变量的集合，可以使用共同的名字引用它。数组可被定义为任何类型，可以是一维或多维。数组中的一个特别要素是通过下标来访问它。数组提供了一种将有联系的信息分组的便利方法。 一维数组 一维数组（one-dimensional array ）实质上是相同类型变量列表。要创建一个数组，你必须首先定义数组变量所需的类型。通用的一维数组的声明格式是：type var-name[ ]; 获得一个数组需要2步。第一步，你必须定义变量所需的类型。第二步，你必须使用运算符new来为数组所要存储的数据分配内存，并把它们分配给数组变量。这样Java 中的数组被动态地分配。如果动态分配的概念对你陌生，别担心，它将在本书的后面详细讨论。 数组的初始化（array initializer ）就是包括在花括号之内用逗号分开的表达式的列表。逗号分开了数组元素的值。Java 会自动地分配一个足够大的空间来保存你指定的初始化元素的个数，而不必使用运算符new。 Java 严格地检查以保证你不会意外地去存储或引用在数组范围以外的值。Java 的运行系统会检查以确保所有的数组下标都在正确的范围以内（在这方面，
Java 与C/C++ 从根本上不同，C/C++ 不提供运行边界检查）。 多维数组 在Java 中，多维数组（multidimensional arrays ）实际上是数组的数组。你可能期望，这些数组形式上和行动上和一般的多维数组一样。然而，你将看到，有一些微妙的差别。定义多维数组变量要将每个维数放在它们各自的方括号中。例如，下面语句定义了一个名为twoD 的二维数组变量。 int twoD[][] = new int[4][5]; 简单排序 简单排序中包括了：冒泡排序、选择排序、插入排序； 1.冒泡排序的思想： 假设有N个数据需要排序，则从第0个数开始，依次比较第0和第1个数据，如果第0个大于第1个则两者交换，否则什么动作都不做，继续比较第1个第2个…，这样依次类推，直至所有数据都“冒泡”到数据顶上。 冒泡排序的的java代码： Public void bubbleSort() { int in,out; for(out=nElems-1;out>0;out--) for(in=0;in
Java经典算法大全
Java经典问题算法大全 /*【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21.... */ package https://www.wendangku.net/doc/2317119670.html,.flywater.FiftyAlgorthm; public class FirstRabbit { public static final int MONTH = 15; public static vo id main(String[] args) { long f1 = 1L, f2 = 1L; long f; for(int i=3; i JA V A经典算法40题 【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21.... public class exp2{ public static void main(String args[]){ int i=0; for(i=1;i<=20;i++) System.out.println(f(i)); } public static int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 或 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=1;i<=20;i++) System.out.println(mymath.f(i)); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 【程序2】题目：判断101-200之间有多少个素数，并输出所有素数。 1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=2;i<=200;i++) if(mymath.iszhishu(i)==true) System.out.println(i); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } public boolean iszhishu(int x) { for(int i=2;i<=x/2;i++) if (x % 2==0 ) return false; return true; 1.最短路的笛杰斯特拉算法 /** * * @author Administrator */ //这个算法用来解决无向图中任意两点的最短路径，同时输出路径(起点到所有点的) public class MinPath { public static String dijkstra(int[][] W1, int start, int end) { System.out.println("起点:" + start + "终点:" + end); boolean[] isLabel = new boolean[W1[0].length];// 是否标号 int[] indexs = new int[W1[0].length];// 所有标号的点的下标集合，以标号的先后顺序进行存储，实际上是一个以数组表示的栈 int i_count = -1;// 栈的顶点 int[] distance = W1[start].clone();// v0到各点的最短距离的初始值 int index = start;// 从初始点开始 int presentShortest = 0;// 当前临时最短距离 indexs[++i_count] = index;// 把已经标号的下标存入下标集中 isLabel[index] = true; while (i_count < W1[0].length) { // 第一步：得到与原点最近的某个点 int min = Integer.MAX_V ALUE; for (int i = 0; i < distance.length; i++) { if (!isLabel[i] && distance[i] != -1 && i != index) { // 如果到这个点有边,并且没有被标号 if (distance[i] < min) { min = distance[i]; index = i;// 把下标改为当前下标 } } } i_count = i_count + 1; if (i_count == W1[0].length) { break; } isLabel[index] = true;// 对点进行标号 indexs[i_count] = index;// 把已经标号的下标存入下标集中 if (W1[indexs[i_count - 1]][index] == -1 || presentShortest + W1[indexs[i_count - 1]][index] > distance[index]) { // 如果两个点没有直接相连，或者两个点的路径大于最短路径 presentShortest = distance[index]; } else { presentShortest += W1[indexs[i_count - 1]][index]; 河内塔问题（Towers of Hanoi） 问题说明： 河內之塔(Towers of Hanoi)是法国人M.Claus(Lucas)於1883年从泰国带至法国的，河內为越战时北越的首都，即现在的胡志明市；1883年法国数学家 Edouard Lucas曾提及這个故事，据说创世紀时Benares有一座波罗教塔，是由三支钻石棒（Pag）所支撑，开始时神在第一根棒上放置64个由上至下依由小至大排列的金盘（Disc），並命令僧侣将所有的金盘从第一根石棒移至第三根石棒，且搬运过程中遵守大盘子在小盘子之下的原则，若每日仅搬一个盘子，则当盘子全数搬运完毕之时，此塔将损毁，而也就是世界末日來临之时。 算法代码（Java）： 复制内容到剪贴板 import java.io.*; public class Hanoi { public static void main(String args[]) throws IOException { int n; BufferedReader buf; buf = new BufferedReader(new InputStreamReader(System.in)); System.out.print("请输入盘子个数"); n = Integer.parseInt(buf.readLine()); Hanoi hanoi = new Hanoi(); hanoi.move(n, 'A', 'B', 'C'); } public void move(int n, char a, char b, char c) { if(n == 1) System.out.println("盘 " + n + " 由 " + a + " 移至 " + c); else { move(n - 1, a, c, b); System.out.println("盘 " + n + " 由 " + a + " 移至 " + c); move(n - 1, b, a, c); 1．求两个数的最大公约数 解答： 欧几理德原理:辗转相除法 public static int zdgys(int a,int b){ int x = a%b; if(x==0) return b; else return zdgys(b,x); } 2．关于java垃圾回收器的认识 解答： 对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC 一定会执行。 3．请问如何设计一个类，使其只能被初始化为一个实例。 解答： Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。 第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。附件： package parent.career.blest; class Singleton { private Singleton(){}//在外部用new关键字会报错，只供内部使用 //注意这是private 只供内部调用 private static Singleton instance = new Singleton(); //这里提供了一个供外部访问本class的静态方法，可以直接访问 public static Singleton getInstance() { return instance; } public void say(String str){ System.out.println(str); } } class commonClass{ public commonClass(){ System.out.println("这是一个普通类"); } } public class mySingleton{ public static void main(String args[]) 实验四Java语言解决算法问题（4学时） 一、实验目的 （1）熟悉Java图形用户界面GUI类； （2）学习处理ActionEvent事件； （3）掌握事件源、监视器、处理事件的接口这三个概念； （4）使用Java语言解决算法问题。 二、实验学时：2学时 三、实验要求 （1）编写一个训练算术能力的测试软件； （2）Teacher类对象给出题目，判断答案是否正确；ComputerFrame类对象提供题目GUI 视图；MainClass作为主类。 四、实验原理 （1）事件源指的是能够产生事件的对象，如文本框、按钮等； （2）监视器指的是对事件源进行监视的对象，以便对发生的事件进行处理； （3）Java语言使用接口回调技术设计了它的处理事件模式。事件源增加监视的方法addXXXListener(XXXListener listener)中的参数是一个接口，listener可以引 用任何实现了该接口的类所创建的对象，当事件源发生事件时，接口listener立 刻回调被类实现的接口中的某个方法。 五、实验内容 课堂实验任务：请按模板要求，将【代码】替换为Java程序代码。 1．题目一算术测试 模板代码：Teacher.java public class Teacher { int numberOne,numberTwo; String operator=""; boolean right; public int giveNumberOne(int n) { numberOne=(int)(Math.random()*n)+1; return numberOne; } public int giveNumberT wo(int n) { numberTwo=(int)(Math.random()*n)+1; return numberTwo; } public String giveOperator() { double d=Math.random(); if(d>=0.5) operator="+"; else operator="-"; return operator; } public boolean getRight(int answer) { if(operator.equals("+")) { if(answer==numberOne+numberTwo) right=true; else right=false; } else if(operator.equals("-")) java程序员必学的十种程序算法 算法1：快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。 算法步骤： 1 从数列中挑出一个元素，称为“基准”（pivot）， 2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。 3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。 算法2：堆排序算法 堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 堆排序的平均时间复杂度为Ο(nlogn) 。 算法步骤： 创建一个堆H[0..n-1] 把堆首（最大值）和堆尾互换 3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置 4. 重复步骤2，直到堆的尺寸为1 算法3：归并排序 归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 算法步骤： Java与算法(二) 六八皇后问题 在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 如果动手来摆放皇后，可以用这样一种思路：在最左侧一列放下一个皇后，然后在右边一列从上到下找到第一个与左边皇后不冲突的位置，摆放第二个皇后；再向yo —列，从上到下 找到第一个与前两个皇后不冲突的位置摆放第三个皇后，依次类推，直到在最后一列摆下第 八个皇后。 认真思考的话，可以发现这仍然是深度优先搜索的思路，即步步推进，下一步做的事情和当 前是一样的。代码： [java] view plain copy print?在CODE上查看代码片派生到我的代码片public class DfsEightQuee ns { int[] queens = new int[8]; //记录每一列皇后的摆放位置 int count = 0; // 摆法总数 public void dfs(i nt colu mn) { if(colu mn == 8) { 〃8 个皇后都已经摆放 coun t++; System.out.println(” 第” + count + "种方法：”)； prin t(); return; } for(int i = 0; i < 8; i++) { queens[column] = i; //在该列的第i行上放置皇后if(isValid(column))//检查摆放在该位 置是否与前column-1列的皇后有冲突 dfs(column + 1); // 没有冲突则开始下一列8 个位置的尝试 } } private boolean isV alid(int column) { for(int i = 0; i < column; i++) { // 第column 列上的皇后与前面column-1 个皇后比较 if(queens[i] == queens[column]) // 两个皇后在同一行上return false; if(Math.abs(queens[i] - queens[column]) == (column - i)) // 两个皇后在同一对角线上 return false; } return true; } private void print() { for(int i = 0; i < 8; i++) { for(int j = 0; j < 8; j++) { if(queens[i] == j) System.out.print("* "); else System.out.print("_ "); } System.out.println(); } } public static void main(String[] args) { DfsEightQueens q = new DfsEightQueens(); q.dfs(0); System.out.println(" 共" + q.count + " 种摆放方法"); } } 输出： [java] view plain copy print? 在CODE 上查看代码片派生到我的代码片共92 种摆放方法 七完全二叉树 树 下图是一“棵”树的样子。树这个名称起的很形象，整个数据结构由根、枝、叶组成，其中 1 为根节点，2、3 是1 的子节点，4、5、6、8、9、10 这几个没有子节点的节点称为叶节点。 【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21.... public static void main(String[]args) { Scanner sc=new Scanner(System.in); System.out.println("请输入月数："); int month=sc.nextInt(); int a=0,b=1,i,t; for(i=2;i<=month;i++) { t=b; b=a+b; a=t; } System.out.println("第"+month+"个月有"+b+"对兔子！"); } 【程序2】 题目：判断101-200之间有多少个素数，并输出所有素数。 1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。 public static void main(String args[]) { int i,n,flag; for(n=101;n<200;n++) { flag=0; for(i=2;i public static void main(String[]args)throws Exception { int i,j,count=0; for(i=101;i<200;i++) { for(j=2;j<(int)(Math.sqrt(i)+1);j++) { if(i%j==0) break; } if(j>(int)Math.sqrt(i)) { System.out.println(i); count++; } } System.out.println("201到200之间共有"+count+"个素数！"); } 【程序3】 题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。 1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。public static void main(String args[]) { int a,b,c; int n; for(n=100;n<1000;n++) { a=n/100; b=(n-a*100)/10; c=n%10; if(n==a*a*a+b*b*b+c*c*c) { System.out.println(n); } } } 【程序4】 题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。 程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成： (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。 (2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。 1 package work; public class Fib { public static void main(String[] args){ int[] fib = new int[23]; fib[0] = 1; fib[1] = 1; for(int i = 2; i < fib.length; i++){ fib[i] = fib[i - 1] + fib[i - 2]; } for(int i = 0; i < fib.length; i++){ System.out.print(fib[i]+" "); } } } 2 package work; import java.math.*; import java.util.ArrayList; public class Sushu { public static void main(String[] args){ ArrayList list = new ArrayList(); for(int i = 101; i < 200; i++){ if(isPrime(i)){ list.add(i); } } System.out.println(list + "共有" +list.size()); } public static boolean isPrime(int i){ boolean flag = true; for(int j = 2; j < Math.sqrt(i); j++){ if(i % j == 0){ flag = false; } } return flag; } } 3 package work; public class Flower { public static void main(String[] args){ for(int i = 100; i <999; i++){ if(flower(i)){ System.out.print(i +" "); } } } public static boolean flower(int number){ boolean flag = false; int i = number / 100; // int j = (number - i*100) / 10; int k = number % 10; if((i*i*i + j*j*j + k*k*k) == number){ flag = true; } return flag; } } 4 package work; import java.util.Scanner; import java.io.*; public class Decomposition { private static int k = 2; public static void main(String[] args)throws IOException{ Scanner scanner = new Scanner(System.in); System.out.println("请输入一个整数"); int number = scanner.nextInt(); System.out.print(number + "="); fenJie(number); } public static void fenJie(int number){ if(k == number){ System.out.print(k); return; } JAVA经典算法40题 【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21.... public class exp2{ public static void main(String args[]){ int i=0; for(i=1;i<=20;i++) System.out.println(f(i)); } public static int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 或 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=1;i<=20;i++) System.out.println(mymath.f(i)); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 【程序2】题目：判断101-200之间有多少个素数，并输出所有素数。 1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=2;i<=200;i++) if(mymath.iszhishu(i)==true) System.out.println(i); } } class math { public int f(int x) { if(x==1 || x==2) 代码面试最常用的10大算法 发表于2018-04-10 11:34| 16225 次阅读| 来源ProgramCreek| 279 条评论| 作者X Wang Java面试算法排序二叉树归并排序职业生涯 摘要：面试也是一门学问，在面试之前做好充分的准备则是成功的必须条件，而程序员在代码面试时，常会遇到编写算法的相关问题，比如排序、二叉树遍历等等。 在程序员的职业生涯中，算法亦算是一门基础课程，尤其是在面试的时候，很多公司都会让程序员编写一些算法实例，例如快速排序、二叉树查找等等。 本文总结了程序员在代码面试中最常遇到的10大算法类型，想要真正了解这些算法的原 理，还需程序员们花些功夫。 1.Stri ng/Array/Matrix 在Java中，String是一个包含char数组和其它字段、方法的类。如果没有IDE自动完成 代码，下面这个方法大家应该记住： toCharArray(> //get char array of a Stri ng Arrays.sort(> //sort an array Arrays.toStri ng(char[] a> //con vert to stri ng charAt(i nt x> //get a char at the specific in dex len gth(> //stri ng len gth len gth //array size substri ng(i nt beg inIn dex> substri ng(i nt beg inIn dex, int endln dex> In teger.valueOf(>//stri ng to in teger Stri ng.valueOf(>/i nteger to stri ng String/arrays很容易理解，但与它们有关的问题常常需要高级的算法去解决，例如动态编程、递归等。 下面列出一些需要高级算法才能解决的经典问题： Evaluate Reverse Polish Notati on Lon gest Pali ndromic Substri ng 单词分割 字梯 Media n of Two Sorted Arrays 4.1 算法 前面我们已经讲过，程序=数据结构+算法。 什么是算法？对一个现有的问题我们采取的解决过程及方法，即为算法。一个用算法实现的程序会耗费两种资源：处理时间和内存。 算法的效率分析标准： 时间复杂度 空间复杂度 简单性和清晰性 对于时间复杂度，可以通过System.currentTimeMillis()方法来测试。例如：public class Test { public static void main(String args[]) { System.out.println(System.currentTimeMillis()); fun(); System.out.println(System.currentTimeMillis()); } public static void fun() { double a = 0; for(int i = 0; i < 10000; i++) for(int j = 0; j < 10000; j++) for(int k = 0; k < 100; k++) a++; } } 前后两次获得当前系统时间的差值就是运行所消耗的时间（毫秒为单位）。 通过System.currentTimeMillis()方法来测试的缺点： a.不同的平台执行的时间不同 b.有些算法随着输入数据的加大，测试时间会变得不切实际！ 4.2 查找 4.2.1 查找之线性查找（直接查找） 算法思路：从数组的第一个元素开始查找，并将其与查找值比较，如果相等则停止，否则继续下一个元素查找，直到找到匹配值。 注意：被查找的数组中的元素可以是无序的、随机的。 实例： import java.util.*; public class Demo1 { public static void main(String args[]) { java经典算法40题（21-40） 【程序21】题目：求1+2!+3!+...+20!的和1.程序分析：此程序只是把累加变成了累乘。public class Ex21 { static long sum = 0; static long fac = 0; public static void main(String[] args) { long sum = 0; long fac = 1; for(int i=1; i<=10; i++) { fac = fac * i; sum += fac; } System.out.println(sum); } } 【程序22】题目：利用递归方法求5!。 1.程序分析：递归公式：fn=fn_1*4! import java.util.Scanner; public class Ex22 { public static void main(String[] args) { Scanner s = new Scanner(System.in); int n = s.nextInt(); Ex22 tfr = new Ex22(); System.out.println(tfr.recursion(n)); } public long recursion(int n) { long value = 0 ; if(n ==1 || n == 0) { value = 1; } else if(n > 1) { value = n * recursion(n-1); } return value; } } 【程序23】题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？ 1.程序分析：利用递归的方法，递归分为回推和递推两个阶段。要想知道第五个人岁数，需知道第四人的岁数，依次类推，推到第一人（10岁），再往回推。 public class Ex23 { static intgetAge(int n){ if (n==1){ return 10; } return 2 + getAge(n-1); } java实现一元线性回归算法 网上看一个达人用java写的一元线性回归的实现，我觉得挺有用的，一些企业做数据挖掘不是用到了，预测运营收入的功能吗？采用一元线性回归算法，可以计算出类似的功能。直接上代码吧：1、定义一个DataPoint类，对X和Y坐标点进行封装： package com.zyujie.dm; public class DataPoint { /** the x value */ public float x; /** the y value */ public float y; /** * Constructor. * * @param x * the x value * @param y * the y value */ public DataPoint(float x, float y) { this.x = x; this.y = y; } } 2、下面是算法实现回归线： /** * File : DataPoint.java * Author : zhouyujie * Date : 2012-01-11 16:00:00 * Description : Java实现一元线性回归的算法，回归线实现类，(可实现统 计指标的预测) */ package com.zyujie.dm; import java.math.BigDecimal; import java.util.ArrayList; public class RegressionLine // implements Evaluatable { /** sum of x */ private double sumX; /** sum of y */ private double sumY; /** sum of x*x */ private double sumXX; /** sum of x*y */ private double sumXY; /** sum of y*y */ private double sumYY; /** sum of yi-y */ private double sumDeltaY; /** sum of sumDeltaY^2 */ private double sumDeltaY2; /** 误差 */ private double sse; private double sst; private double E; private String[] xy;JAVA算法100例_全源码
java实现图论中的经典算法
JAVA经典算法
Java_J2ee笔试总结(java算法)
实验四Java语言解决算法问题
java程序员必知的十种程序算法
Java与算法汇总
JAVA经典算法50题
java经典算法50题答案
JAVA算法100例,全源码
个最常见的Java算法
Java常用基本算法
java经典算法40(初学必做基础)
java实现一元线性回归算法