杂乱

冒泡排序：（从小到大）

/**
     * 冒泡排序
     * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。  
     * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。  
     * 针对所有的元素重复以上的步骤，除了最后一个。
     * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 
     * @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 (int i =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 + " ");
         }
    }