Java 数据结构和经典算法经验总结

前言：在计算机软件专业中，算法分析与设计是一门非常重要的课程，很多人为它如痴如醉。很多问题的解决，程序的编写都要依赖它，在软件还是面向过程的阶段，就有‘程序=算法+数据结构’这个公式。算法的学习对于培养一个人的逻辑思维能力是有极大帮助的，它可以培养 我们养成思考分析问题，解决问题的能力。    如果一个算法有缺陷，或不适合某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂性和时间复杂度来衡量。算法可以使用自然语言、伪代码、流程图等多种不同的方法来描述。计算机系统中的操作系统、语言编译系统、数据库管理系统以及各种各样的计算机应用系统中的软件，都必须使用具体的算法来实现。算法设计与分析是计算机科学与技术的一个核心问题。因此，学习算法无疑会增强自己的竞争力，提高自己的修为，为自己增彩。

概念：算法简单来说就是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，也就是说算法告诉计算机怎么做，以此来解决问题。同一个问题存在多种算法来解决它，但是这些算法存在着优劣之分，好的算法速度快，效率高，占用空间小，差的算法不仅复杂难懂，而且效率低，对机器要求还高，当然，有时候算法之间存在一种互补关系，有些算法效率高，节省时间，但浪费空间，另外一些算法可能速度上慢些，但是空间比较节约，这时候 我们就应该根据实际要求，和具体情况来采取相应的算法来解决问题。

一： 

约瑟夫算法

约瑟夫环：已知n个人(以编号1，2，3...n分别表示)围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列;他的下一个人又从1开始报数，数到m的那个人又出列;依此规律重复下去，直到圆桌周围的人全部出列。

[java] view plain co

1. public class YuesefuTest {  
2.       
3.     public static void main(String[] args) {  
4.         int totalNum = 10;  
5.         int countNum = 3;  
6.           
7.         yuesefuByMyself(totalNum, countNum);  
8.         yuesefu(totalNum, countNum);  
9.     }  
10.       
11.     /** 
12.      * 此方法 k 为 list 的下标 
13.      * @param totalNum 
14.      * @param countNum 
15.      */  
16.     public static void yuesefuByMyself( int totalNum,int countNum){  
17. //      初始化人数  
18.         List<Integer> start = new ArrayList<Integer>();  
19.           
20.         for(int i=1; i<=totalNum; i++){  
21.             start.add(i);  
22.         }  
23.           
24. //      此处的k为list的下标，开始报数人的下标，第一个人为0，第n个人为n-1  
25.         int k = 0;  
26.         while(start.size()>0){  
27. //          下一个出列人的下标，因为是从当前报数人开始数，所以减1为下一个出列人的下标  
28.             k = k + countNum -1;  
29.               
30. //          当 下标+1 超过了 list 的size  
31.             if(k + 1>start.size()){  
32. //              当size 为 10 ，下标要取 10 ，最大下标为9，应该取 list 的 第一个，即下标为0，  
33. //              同理，直接取余即可为正确下标  
34.                 k = k % start.size();  
35.             }  
36.               
37.             System.out.print(start.get(k)+",");  
38.               
39. //          出列，下一个开始报数人的下标即为出列人的下标  
40.             start.remove(k);  
41.         }  
42.           
43.         System.out.println();  
44.     }  
45.       
46.     public static void yuesefu(int totalNum,int countNum){  
47. //      初始化人数  
48.         List<Integer> start = new ArrayList<Integer>();  
49.           
50.         for(int i=1; i<=totalNum; i++){  
51.             start.add(i);  
52.         }  
53.           
54. //      从第K个开始计数  
55.         int k = 0;  
56.         while(start.size()>0){  
57.             k = k + countNum;  
58. //          第m人的索引位置  
59.             k = k % (start.size()) -1;  
60. //          判断是否到队尾  
61.             if(k<0){  
62.                 System.out.print(start.get(start.size()-1)+",");  
63.                 start.remove(start.size()-1);  
64.                 k = 0;  
65.             } else {  
66.                 System.out.print(start.get(k)+",");  
67.                 start.remove(k);  
68.             }  
69.         }  
70.           
71.         System.out.println();  
72.     }  
73.       
74.   
75. }  

二： 

二叉树的构建及遍历 

有一些博客构建出来的二叉树是完全二叉树，这篇博客什么样的二叉树都能构建，图为代码所示的一棵二叉树

public class BinaryTree {            private static String [] array = {"A","B","D","H","","","I","","","E","","J","","",              "C","F","","K","","","G","",""};      private static int arrayIndex = 0;        //  创建一棵二叉树，约定用户遵照前序遍历的方式输入数据  //  不使用迭代是因为迭代必须要知道这棵树有多深，  //  递归只需要输入就可以自行决定深度  //  type:结点类型 0 根节点 1左孩子 2右孩子      public static TreeNode createBinaryTree(int type,String parentData) {          switch (type) {          case 0:              System.out.print("根节点:");              break;          case 1:              System.out.print(parentData+"的左孩子:");              break;          case 2:              System.out.print(parentData+"的右孩子:");              break;          }            //      可以使用手动输入也可以放到数组里  //      Scanner sc = new Scanner(System.in);  //      String data = sc.nextLine();                    String data = "";          if(arrayIndex<array.length){              data = array[arrayIndex];              System.out.println(data);                            arrayIndex++;          }else{              System.out.println();          }                    TreeNode node = null;            //      data为空表示没有这个孩子          if(data==null||data.equals("")){              return node;          }else{              node = new TreeNode(data);              node.setLchild(createBinaryTree(1,node.getData()));              node.setRchild(createBinaryTree(2,node.getData()));                            return node;          }                }              //  前序遍历      public static void preOrderTraverse(TreeNode node){          if(node != null){  //          根，左，右              System.out.print(node.getData());              preOrderTraverse(node.getLchild());              preOrderTraverse(node.getRchild());          }      }        //  中序遍历      public static void inOrderTraverse(TreeNode node){          if(node != null){  //          左，根，右              inOrderTraverse(node.getLchild());              System.out.print(node.getData());              inOrderTraverse(node.getRchild());          }      }        //  后序遍历      public static void postOrderTraverse(TreeNode node){          if(node != null){  //          左，右，根              postOrderTraverse(node.getLchild());              postOrderTraverse(node.getRchild());              System.out.print(node.getData());          }      }        //                public static void main(String[] args) {          TreeNode rootNode = createBinaryTree(0,"");                    System.out.println();          System.out.print("前序遍历：");          preOrderTraverse(rootNode);                    System.out.println();          System.out.print("中序遍历：");          inOrderTraverse(rootNode);                    System.out.println();          System.out.print("后序遍历：");          postOrderTraverse(rootNode);      }    }    /**  * 二叉树结点  * @author cmdsm  *  */  class TreeNode{      private String data;            private TreeNode lchild;      private TreeNode rchild;                        public TreeNode() {          super();      }        public TreeNode(String data) {          this.data = data;      }        public String getData() {          return data;      }            public void setData(String data) {          this.data = data;      }        public TreeNode getLchild() {          return lchild;      }        public void setLchild(TreeNode lchild) {          this.lchild = lchild;      }        public TreeNode getRchild() {          return rchild;      }        public void setRchild(TreeNode rchild) {          this.rchild = rchild;      }        @Override      public String toString() {          return "TreeNode [data=" + data + ", lchild=" + lchild + ", rchild=" + rchild + "]";      }                    }  

结果：

三： 

线索二叉树（中序）