杂乱

冒泡排序：（从小到大）

/**     * 冒泡排序     * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。       * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。       * 针对所有的元素重复以上的步骤，除了最后一个。     * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。      * @param numbers 需要排序的整型数组     */    public static void bubbleSort(int[] numbers)    {        int temp = 0;        int size = numbers.length;        for(int i = 0 ; i < size-1; i ++)        {        for(int j = 0 ;j < size-1-i ; j++)        {            if(numbers[j] > numbers[j+1])  //交换两数位置            {            temp = numbers[j];            numbers[j] = numbers[j+1];            numbers[j+1] = temp;            }        }        }    }

快速排序：

/**     * 查找出中轴（默认是最低位low）的在numbers数组排序后所在位置     *      * @param numbers 带查找数组     * @param low   开始位置     * @param high  结束位置     * @return  中轴所在位置     */    public static int getMiddle(int[] numbers, int low,int high)    {        int temp = numbers[low]; //数组的第一个作为中轴        while(low < high)        {        while(low < high && numbers[high] > temp)        {            high--;        }        numbers[low] = numbers[high];//比中轴小的记录移到低端        while(low < high && numbers[low] < temp)        {            low++;        }        numbers[high] = numbers[low] ; //比中轴大的记录移到高端        }        numbers[low] = temp ; //中轴记录到尾        return low ; // 返回中轴的位置    }

二叉树排序：

public class Node {private int data;private Node leftNode;private Node rightNode;public Node(int data, Node leftNode, Node rightNode){this.data = data;this.leftNode = leftNode;this.rightNode = rightNode;}public int getData() {return data;}public void setData(int data) {this.data = data;}public Node getLeftNode() {return leftNode;}public void setLeftNode(Node leftNode) {this.leftNode = leftNode;}public Node getRightNode() {return rightNode;}public void setRightNode(Node rightNode) {this.rightNode = rightNode;}}

public class BinaryTree {/** * @author 行者摩罗 * 二叉树的先序中序后序排序 */public Node init() {//注意必须逆序建立，先建立子节点，再逆序往上建立，因为非叶子结点会使用到下面的节点，而初始化是按顺序初始化的，不逆序建立会报错Node J = new Node(8, null, null);Node H = new Node(4, null, null);Node G = new Node(2, null, null);Node F = new Node(7, null, J);Node E = new Node(5, H, null);Node D = new Node(1, null, G);Node C = new Node(9, F, null);Node B = new Node(3, D, E);Node A = new Node(6, B, C);return A;   //返回根节点}public void printNode(Node node){System.out.print(node.getData());}public void theFirstTraversal(Node root) {  //先序遍历printNode(root);if (root.getLeftNode() != null) {  //使用递归进行遍历左孩子theFirstTraversal(root.getLeftNode());}if (root.getRightNode() != null) {  //递归遍历右孩子theFirstTraversal(root.getRightNode());}}public void theInOrderTraversal(Node root) {  //中序遍历if (root.getLeftNode() != null) {theInOrderTraversal(root.getLeftNode());}printNode(root);if (root.getRightNode() != null) {theInOrderTraversal(root.getRightNode());}}public void thePostOrderTraversal(Node root) {  //后序遍历if (root.getLeftNode() != null) {thePostOrderTraversal(root.getLeftNode());}if(root.getRightNode() != null) {thePostOrderTraversal(root.getRightNode());}printNode(root);}public static void main(String[] args) {BinaryTree tree = new BinaryTree();Node root = tree.init();System.out.println("先序遍历");tree.theFirstTraversal(root);System.out.println("");System.out.println("中序遍历");tree.theInOrderTraversal(root);System.out.println("");System.out.println("后序遍历");tree.thePostOrderTraversal(root);System.out.println("");}}

二叉树按层遍历：用队列

 public void levelIterator(BiTree root)    {        if(root == null)        {            return ;        }        LinkedList<BiTree> queue = new LinkedList<BiTree>();        BiTree current = null;        queue.offer(root);//将根节点入队        while(!queue.isEmpty())        {            current = queue.poll();//出队队头元素并访问            System.out.print(current.val +"-->");            if(current.left != null)//如果当前节点的左节点不为空入队            {                queue.offer(current.left);            }            if(current.right != null)//如果当前节点的右节点不为空，把右节点入队            {                queue.offer(current.right);            }        }            }  

单链表逆序：

    /**          * 遍历，将当前节点的下一个节点缓存后更改当前节点指针          */          public static Node reverse2(Node head) {              if (head == null)                  return head;              Node pre = head;// 上一结点              Node cur = head.getNext();// 当前结点              Node tmp;// 临时结点，用于保存当前结点的指针域（即下一结点）              while (cur != null) {// 当前结点为null，说明位于尾结点                  tmp = cur.getNext();                  cur.setNext(pre);// 反转指针域的指向                        // 指针往下移动                  pre = cur;                  cur = tmp;              }              // 最后将原链表的头节点的指针域置为null，还回新链表的头结点，即原链表的尾结点              head.setNext(null);                            return pre;          }      }            class Node {          private int Data;// 数据域          private Node Next;// 指针域                public Node(int Data) {              // super();              this.Data = Data;          }                public int getData() {              return Data;          }                public void setData(int Data) {              this.Data = Data;          }                public Node getNext() {              return Next;          }                public void setNext(Node Next) {              this.Next = Next;          }      }  

 /**      * 递归，在反转当前节点之前先反转后续节点      */      public static Node Reverse1(Node head) {          // head看作是前一结点，head.getNext()是当前结点，reHead是反转后新链表的头结点          if (head == null || head.getNext() == null) {              return head;// 若为空链或者当前结点在尾结点，则直接还回          }          Node reHead = Reverse1(head.getNext());// 先反转后续节点head.getNext()          head.getNext().setNext(head);// 将当前结点的指针域指向前一结点          head.setNext(null);// 前一结点的指针域令为null;          return reHead;// 反转后新链表的头结点      }  }  

100以内输出所有质数：

1、外层for循环有必要执行100次吗？

除了2所有的偶数都不是质数，那么能不能只遍历奇数。

代码：for(inti =3; i< 100; i+=2)//i一次循环自增2

考虑到这个问题，for循环就少遍历了50次。效率就提升了一倍

2、内层for循环能不能也做些优化呢？

内层for循环作为 除数（除数从3到 被除数-1），通过规律发现

除数只需要从3到除数的开平方根数 就行了。

public static void test4() {         boolean bool;         for (int i = 3; i < 100; i+=2) {              bool = true;              for (int j = 3; j <= Math.sqrt(i); j++) {                 if (i % j == 0) {                     bool = false; 　　　　　　　　　　　　break;                 }             }            if (bool)                 System.out.print(i + " ");         }    }