萝卜-青菜

java-算法

1.大O表示法：

粗略的量度方法即算法的速度是如何与数据项的个数相关的

算法大O表示法表示的运行时间

线性查找 O(N)

二分查找 O(logN)

无序数组的插入 O(1)

有序数组的插入 O(N)

无序数组的删除 O(N)

有序数组的删除 O(N)

O(1)是最优秀的,O(logN)良好,O(N)还可以,O(N2)稍差(在冒泡法中见到)

2. 排序

 public class JWzw { 
  
    //插入排序  
    public void insertArray(Integer[] in ) {  
        int tem = 0;  
        int num = 0;  
        int upnum = 0;  
        for (int i = 0; i < in .length; i++) {  
            for (int j = i - 1; j >= 0; j--) {  
                num++;  
                if ( in [j + 1] < in [j]) {  
                    tem = in [j + 1]; in [j + 1] = in [j]; in [j] = tem;  
                    upnum++;  
                } else {  
                    break;  
                }  
            }  
        }  
        for (int i = 0; i < in .length; i++) {  
            System.out.print( in [i]);  
            if (i < in .length - 1) {  
                System.out.print(",");  
            }  
        }  
        System.out.println();  
        System.out.println("插入排序循环次数:" + num);  
        System.out.println("移动次数：" + upnum);  
        System.out.print("\n\n\n");  
    }  
    //选择排序  
    public void chooseArray(Integer[] in ) {  
        int tem = 0;  
        int num = 0;  
        int upnum = 0;  
        for (int i = 0; i < in .length; i++) {  
            for (int j = i; j < in .length - 1; j++) {  
                num++;  
                if ( in [j + 1] < in [j]) {  
                    tem = in [j + 1]; in [j + 1] = in [j]; in [j] = tem;  
                    upnum++;  
                }  
            }  
        }  
        for (int i = 0; i < in .length; i++) {  
            System.out.print( in [i]);  
            if (i < in .length - 1) {  
                System.out.print(",");  
            }  
        }  
        System.out.println();  
        System.out.println("选择排序循环次数:" + num);  
        System.out.println("移动次数：" + upnum);  
        System.out.print("\n\n\n");  
    }  
    //冒泡排序  
    public void efferArray(Integer[] in ) {  
        int tem = 0;  
        int num = 0;  
        int upnum = 0;  
        for (int i = 0; i < in .length; i++) {  
            for (int j = i; j < in .length - 1; j++) {  
                num++;  
                if ( in [j + 1] < in [i]) {  
                    tem = in [j + 1]; in [j + 1] = in [i]; in [i] = tem;  
                    upnum++;  
                }  
            }  
        }  
        for (int i = 0; i < in .length; i++) {  
            System.out.print( in [i]);  
            if (i < in .length - 1) {  
                System.out.print(",");  
            }  
        }  
        System.out.println();  
        System.out.println("冒泡排序循环次数:" + num);  
        System.out.println("移动次数：" + upnum);  
        System.out.print("\n\n\n");  
    } 
    
    //打印乘法口诀  
    public void printMulti() {  
        for (int j = 1; j < 10; j++) {  
            for (int i = 1; i <= j; i++) {  
                System.out.print(i + " * " + j + " = " + j * i + "\t");  
            }  
            System.out.print("\t\n");  
        }  
        System.out.print("\n\n\n");  
    }  
    //打印N * 1 + N * 2 + N * 3 =num的所有组合  
    public void printNumAssemble(int num) {  
        for (int i = 0; i < num + 1; i++) {  
            for (int j = 0; j < num / 2 + 1; j++) {  
                for (int in = 0; in < num / 3 + 1; in ++) {  
                    if (i * 1 + j * 2 + in * 3 == num) {  
                        System.out.println("小马" + i + ",\t中马" + j + ",\t大马" + in );  
                    }  
                }  
            }  
        }  
    }  
    /** 
 
 * @param args 
 
 */  
    public static void main(String[] args) {  
        JWzw jwzw = new JWzw();  
        int num = 3;  
        jwzw.printMulti(); //打印乘法口诀  
        jwzw.printNumAssemble(100); //打印N * 1 + N * 2 + N * 3 =num的所有组合  
        Integer in [] = {  
            8, 89, 5, 84, 3, 45, 12, 33, 77, 98, 456, 878, 654, 213, 897  
        };  
        jwzw.efferArray( in ); //冒泡排序  
        Integer in1[] = {  
            8, 89, 5, 84, 3, 45, 12, 33, 77, 98, 456, 878, 654, 213, 897  
        };  
        jwzw.insertArray(in1); //插入排序  
        Integer in2[] = {  
            8, 89, 5, 84, 3, 45, 12, 33, 77, 98, 456, 878, 654, 213, 897  
        };  
        jwzw.chooseArray(in2); //选择排序  
        //int i = num++;  
        //System.out.println(i);  
        System.out.println(1000 >> 2);  
    }  
}

3. 优先级队列

class PriorityQueue {  
    private long[] a = null;  
    private int nItems = 0;  
    private int maxSize = 0;  
    public PriorityQueue(int maxSize) {  
        a = new long[maxSize];  
        this.maxSize = maxSize;  
        nItems = 0;  
    }  
    public void insert(long l) {  
        //优先级队列的插入不是队尾,而是选择一个合适的按照某种顺序插入的  
        //当队列长度为0时，如下  
        //不为0时,将所有比要插入的数小的数据后移,这样大的数就在队列的头部了  
        int i = 0;  
        if (nItems == 0) {  
            a[0] = l;  
        } else {  
            for (i = nItems - 1; i >= 0; i--) {  
                if (l < a[i]) a[i + 1] = a[i];  
                else break;  
            }  
            a[i + 1] = l;  
        }  
        nItems++;  
    }  
    public long remove() {  
        //移出的是数组最上端的数，这样减少数组元素的移动  
        return a[--nItems];  
    }  
    public boolean isEmpty() {  
        return (nItems == 0);  
    }  
    public boolean isFull() {  
        return (nItems == maxSize);  
    }  
    public int size() {  
        return nItems;  
    }  
}  
public class duilie { // 队列体类  
    private duilie s;  
    private String data;  
    duilie(String data) {  
        this.data = data;  
    }  
    public String getData() {  
        return data;  
    }  
    public void setData(String data) {  
        this.data = data;  
    }  
    public duilie getS() {  
        return s;  
    }  
    public void setS(duilie s) {  
        this.s = s;  
    }  
}  
public class duiliecz { // 队列操作类  
    /** 
 
  * @param args 
 
  */  
    private int i = 0; // 队列长  
    private duilie top = new duilie(""); // 队列头  
    private duilie end = new duilie(""); // 队列尾  
    public void add(String s) { // 添加队列  
        duilie m = new duilie(s);  
        if (i != 0) {  
            m.setS(top.getS());  
            top.setS(m);  
        } else {  
            top.setS(m);  
            end.setS(m);  
        }  
        i++;  
    }

4. 队列

public void del() { // 删除队尾  
    if (i == 0) {  
        return;  
    } else if (i == 1) {  
        top.setS(null);  
        end.setS(null);  
    } else {  
        duilie top1 = new duilie(""); // 队列底查找用缓存  
        top1.setS(top.getS());  
        while (!top1.getS().getS().equals(end.getS())) {  
            top1.setS(top1.getS().getS());  
        }  
        end.setS(top1.getS());  
    }  
    i--;  
}  
public static void main(String[] args) {  
    // TODO Auto-generated method stub  
    duiliecz m = new duiliecz();  
    m.add("1");  
    m.add("2");  
    m.add("3");  
    m.add("4");  
    for (int n = 0; n < 4; n++) {  
        m.del();  
    }  
}  
public int getI() {  
    return i;  
}  
public duilie getEnd() {  
    return end;  
}  
public duilie getTop() {  
    return top;  
}  
}

5. 栈

public class Stack {  
    int[] arr;  
    int len = 0;  
    public Stack() {  
        arr = new int[100];  
    }  
    public Stack(int n) {  
        arr = new int[n];  
    }  
    public int size() {  
        return len + 1;  
    }  
    // 扩大数组  
    public void resize() {  
        int[] b = new int[arr.length * 2];  
        System.arraycopy(arr, 0, b, 0, arr.length);  
        arr = b;  
    }  
    public void show() {  
        for (int i = 0; i < len; i++) {  
            System.out.print(arr[i] + "  ");  
        }  
        System.out.println();  
    }  
    // 进栈  
    public void push(int a) {  
        if (len >= arr.length) resize();  
        arr[len] = a;  
        len++;  
    }  
    // 出栈  
    public int pop() {  
        if (len == 0) {  
            System.out.println();  
            System.out.println("stack is empty!");  
            return -1;  
        }  
        int a = arr[len - 1];  
        arr[len - 1] = 0;  
        len--;  
        return a;  
    }  
}

6. 链表

class Node {  
    Object data;  
    Node next;  
    public Node(Object data) {  
        setData(data);  
    }  
    public void setData(Object data) {  
        this.data = data;  
    }  
    public Object getData() {  
        return data;  
    }  
}  
class Link {  
    Node head;  
    int size = 0;  
    public void add(Object data) {  
        Node n = new Node(data);  
        if (head == null) {  
            head = n;  
        } else {  
            Node current = head;  
            while (true) {  
                if (current.next == null) {  
                    break;  
                }  
                current = current.next;  
            }  
            current.next = n;  
        }  
        size++;  
    }  
    public void show() {  
        Node current = head;  
        if (current != null) {  
            while (true) {  
                System.out.println(current);  
                if (current == null) {  
                    break;  
                }  
                current = current.next;  
            }  
        } else {  
            System.out.println("link is empty");  
        }  
    }  
    public Object get(int index) {  
        // ....  
    }  
    public int size() {  
        return size;  
    }  
}

7. 单链表

class Node // 节点类，单链表上的节点  
{  
    String data; // 数据域，存放String类的数据  
    Node next; // 指向下一个节点  
    Node(String data) {  
        this.data = data; // 构造函数  
    }  
    String get() {  
        return data; // 返回数据  
    }  
}  
class MyLinkList // 链表类  
{  
    Node first; // 头节点  
    int size; // 链表长度  
    MyLinkList(String arg[]) {  
        // Node first = new Node("head");//生成头节点  
        first = new Node("head"); // J.F. 这里不需要定义局部变量 first  
        // 如果定义了局部变量，那成员变量 first 就一直没有用上  
        // 所以，它一直为空  
        size = 0;  
        Node p = first;  
        for (int i = 0; i < arg.length; i++) // 将arg数组中的元素分别放入链表中  
        {  
            Node q = new Node(arg[i]);  
            q.next = p.next; // 每一个节点存放一个arg数组中的元素  
            p.next = q;  
            p = p.next;  
            size++;  
        }  
    }  
    MyLinkList() // 无参数构造函数  
    {  
        // Node first = new Node("head");  
        first = new Node("head"); // J.F. 这里犯了和上一个构造方法同样的错误  
        size = 0;  
    }  
    int size() // 返回链表长度  
    {  
        return size;  
    }  
    void insert(Node a, int index) // 将节点a 插入链表中的第index个位置  
    {  
        Node temp = first;  
        for (int i = 0; i < index; i++) {  
            temp = temp.next; // 找到插入节点的前一节点  
        }  
        a.next = temp.next; // 插入节点  
        temp.next = a;  
        size++;  
    }  
    Node del(int index) // 删除第index个节点，并返回该值  
    {  
        Node temp = first;  
        for (int i = 0; i < index; i++) {  
            temp = temp.next; // 找到被删除节点的前一节点  
        }  
        Node node = temp.next;  
        temp.next = node.next;  
        size--; // 删除该节点，链表长度减一  
        return node;  
    }  
    void print() // 在屏幕上输出该链表（这段程序总是出错，不知道错在哪里）  
    {  
        Node temp = first;  
        for (int i = 1; i < size; i++) // 将各个节点分别在屏幕上输出  
        {  
            temp = temp.next;  
            System.out.print(temp.get() + "->");  
        }  
    }  
    void reverse() // 倒置该链表  
    {  
        for (int i = 0; i < size; i++) {  
            insert(del(size - 1), 0); // 将最后一个节点插入到最前  
            // J.F. 最后一个节点的 index 应该是 size - 1  
            // 因为第一个节点的 index 是 0  
        }  
    }  
    String get(int index) // 查找第index个节点，返回其值  
    {  
        if (index >= size) {  
            return null;  
        }  
        Node temp = first;  
        for (int i = 0; i < index; i++) {  
            temp = temp.next; // 找到被查找节点的前一节点  
        }  
        return temp.next.get();  
    }  
}  
class MyStack // 堆栈类，用单链表实现  
{  
    MyLinkList tmp;  
    Node temp;  
    MyStack() {  
        // MyLinkList tmp = new MyLinkList();  
        tmp = new MyLinkList(); // J.F. 和 MyLinkList 构造方法同样的错误  
    }  
    void push(String a) // 压栈，即往链表首部插入一个节点  
    {  
        Node temp = new Node(a);  
        tmp.insert(temp, 0);  
    }  
    String pop() // 出栈，将链表第一个节点删除  
    {  
        Node a = tmp.del(0);  
        return a.get();  
    }  
    int size() {  
        return tmp.size();  
    }  
    boolean empty() // 判断堆栈是否为空  
    {  
        if (tmp.size() == 0) return false;  
        else return true;  
    }  
}  
public class MyLinkListTest // 测试程序部分  
{  
    public static void main(String arg[]) // 程序入口  
    {  
        if ((arg.length == 0) || (arg.length > 10)) System.out.println("长度超过限制或者缺少参数");  
        else {  
            MyLinkList ll = new MyLinkList(arg); // 创建一个链表  
            ll.print(); // 先输出该链表（运行到这一步抛出异常）  
            ll.reverse(); // 倒置该链表  
            ll.print(); // 再输出倒置后的链表  
            String data[] = new String[10];  
            int i;  
            for (i = 0; i < ll.size(); i++) {  
                data[i] = ll.get(i); // 将链表中的数据放入数组  
            }  
            // sort(data);// 按升序排列data中的数据（有没有现成的排序函数？）  
            for (i = 0; i < ll.size(); i++) {  
                System.out.print(data[i] + ";"); // 输出数组中元素  
            }  
            System.out.println();  
            MyStack s = new MyStack(); // 创建堆栈实例s  
            for (i = 0; i < ll.size(); i++) {  
                s.push(data[i]); // 将数组元素压栈  
            }  
            while (!s.empty()) {  
                System.out.print(s.pop() + ";"); // 再将堆栈里的元素弹出  
            }  
        }  
    }  
}

8. 双端链表

class Link {  
    public int iData = 0;  
    public Link next = null;  
    public Link(int iData) {  
        this.iData = iData;  
    }  
    public void display() {  
        System.out.print(iData + " ");  
    }  
}  
class FirstLastList {  
    private Link first = null;  
    private Link last = null;  
    public FirstLastList() {  
        first = null;  
        last = null;  
    }  
    public void insertFirst(int key) {  
        Link newLink = new Link(key);  
        if (this.isEmpty()) last = newLink;  
        newLink.next = first;  
        first = newLink;  
    }  
    public void insertLast(int key) {  
        Link newLink = new Link(key);  
        if (this.isEmpty()) first = newLink;  
        else last.next = newLink;  
        last = newLink;  
    }  
    public Link deleteFirst() {  
        Link temp = first;  
        if (first.next == null) last = null;  
        first = first.next;  
        return temp;  
    }  
    public boolean isEmpty() {  
        return (first == null);  
    }  
    public void displayList() {  
        System.out.print("List (first-->last): ");  
        Link current = first;  
        while (current != null) {  
            current.display();  
            current = current.next;  
        }  
        System.out.println("");  
    }  
}  
class FirstLastListApp {  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        FirstLastList theList = new FirstLastList();  
        theList.insertFirst(22); // insert at front  
        theList.insertFirst(44);  
        theList.insertFirst(66);  
        theList.insertLast(11); // insert at rear  
        theList.insertLast(33);  
        theList.insertLast(55);  
        theList.displayList(); // display the list  
        theList.deleteFirst(); // delete first two items  
        theList.deleteFirst();  
        theList.displayList(); // display again  
    }  
}

9. 有序链表

package arithmetic;  
class Link {  
    public int iData = 0;  
    public Link next = null;  
    public Link(int iData) {  
        this.iData = iData;  
    }  
    public void display() {  
        System.out.print(iData + " ");  
    }  
}  
class SortedList {  
    private Link first = null;  
    public SortedList() {  
        first = null;  
    }  
    public void insert(int key) {  
        Link newLink = new Link(key);  
        Link previous = null;  
        Link current = first;  
        // while的第一个条件是没有到达链表的尾端,第二个是按顺序找到一个合适的位置  
        while (current != null && key > current.iData) {  
            previous = current;  
            current = current.next;  
        }  
        // 如果是空表或者要插入的元素最小,则在表头插入key  
        if (current == first) first = newLink;  
        else previous.next = newLink;  
        newLink.next = current;  
    }  
    /** 
 
 * 删除表头的节点 
 
 * 
 
 * @return 要删除的节点 
 
 */  
    public Link remove() {  
        Link temp = first;  
        first = first.next;  
        return temp;  
    }  
    public boolean isEmpty() {  
        return (first == null);  
    }  
    public void displayList() {  
        System.out.print("List (first-->last): ");  
        Link current = first; // start at beginning of list  
        while (current != null) // until end of list,  
        {  
            current.display(); // print data  
            current = current.next; // move to next link  
        }  
        System.out.println("");  
    }  
}  
class SortedListApp {  
    public static void main(String[] args) { // create new list  
        SortedList theSortedList = new SortedList();  
        theSortedList.insert(20); // insert 2 items  
        theSortedList.insert(40);  
        theSortedList.displayList(); // display list  
        theSortedList.insert(10); // insert 3 more items  
        theSortedList.insert(30);  
        theSortedList.insert(50);  
        theSortedList.displayList(); // display list  
        theSortedList.remove(); // remove an item  
        theSortedList.displayList(); // display list  
    }  
}

10. 双向链表

class Link {  
    // 双向链表,有两个指针,一个向前,一个向后  
    public int iData = 0;  
    public Link previous = null;  
    public Link next = null;  
    public Link(int iData) {  
        this.iData = iData;  
    }  
    public void display() {  
        System.out.print(iData + " ");  
    }  
}  
class DoublyLinked {  
    // 分别指向链表的表头和表尾  
    private Link first = null;  
    private Link last = null;  
    public boolean isEmpty() {  
        return first == null;  
    }  
    /** 
 
 * 在表头插入数据 
 
 * 
 
 * @param 要插入的节点的数据 
 
 */  
    public void insertFirst(int key) {  
        Link newLink = new Link(key);  
        // 如果开始链表为空,则插入第一个数据后,last也指向第一个数据  
        if (this.isEmpty()) last = newLink;  
        else { // 表不为空的情况  
            first.previous = newLink;  
            newLink.next = first;  
        }  
        // 无论怎样,插入后都的让first重新指向第一个节点  
        first = newLink;  
    }  
    public void insertLast(int key) { // 在尾端插入数据,同上  
        Link newLink = new Link(key);  
        if (this.isEmpty()) first = newLink;  
        else {  
            last.next = newLink;  
            newLink.previous = last;  
        }  
        last = newLink;  
    }  
    /** 
 
 * 在指定的节点后插入数据 
 
 * 
 
 * @param key 
 
 *            指定的节点的值 
 
 * @param iData 
 
 *            要插入的数据 
 
 * @return 是否插入成功 
 
 */  
    public boolean insertAfter(int key, int iData) {  
        Link newLink = new Link(key);  
        Link current = first;  
        // 从first开始遍历,看能否找到以key为关键字的节点  
        while (current.iData != key) {  
            current = current.next;  
            // 若能找到就跳出循环,否则返回false,插入失败  
            if (current == null) return false;  
        }  
        // 如果插入点在last的位置  
        if (current == last) {  
            last = newLink;  
        } else { // 非last位置,交换各个next和previous的指针  
            newLink.next = current.next;  
            current.next.previous = newLink;  
        }  
        current.next = newLink;  
        newLink.previous = current;  
        return true;  
    }  
    /** 
 
 * 删除表头的节点 
 
 * 
 
 * @return 
 
 */  
    public Link deleteFirst() {  
        Link temp = first;  
        // 如果表中只有一个元素,删除后则为空表,所以last=null  
        if (first.next == null) last = null;  
        else  
        // 否则,让第二个元素的previous=null  
            first.next.previous = null;  
        // 删除头指针,则first指向原来的second  
        first = first.next;  
        return temp;  
    }  
    public Link deleteLast() { // 同上  
        Link temp = last;  
        if (last.previous == null) first = null;  
        else last.previous.next = null;  
        last = last.previous;  
        return temp;  
    }  
    public Link deleteKey(int key) {  
        Link current = first;  
        // 遍历整个链表查找对应的key,如果查到跳出循环,否则...  
        while (current.iData != key) {  
            current = current.next;  
            // ...否则遍历到表尾,说明不存在此key,返回null,删除失败  
            if (current == null) return null;  
        }  
        if (current == first) first = first.next;  
        else current.previous.next = current.next;  
        if (current == last) last = last.previous;  
        else current.next.previous = current.previous;  
        return current;  
    }  
    public void displayForward() {  
        Link current = first;  
        while (current != null) {  
            current.display();  
            current = current.next;  
        }  
        System.out.println();  
    }  
    public void displayBackward() {  
        Link current = last;  
        while (current != null) {  
            current.display();  
            current = current.previous;  
        }  
        System.out.println();  
    }  
}  
class DoublyLinkedApp {  
    public static void main(String[] args) { // make a new list  
        DoublyLinked theList = new DoublyLinked();  
        theList.insertFirst(22); // insert at front  
        theList.insertFirst(44);  
        theList.insertFirst(66);  
        theList.insertLast(11); // insert at rear  
        theList.insertLast(33);  
        theList.insertLast(55);  
        theList.displayForward(); // display list forward  
        theList.displayBackward(); // display list backward  
        theList.deleteFirst(); // delete first item  
        theList.deleteLast(); // delete last item  
        theList.deleteKey(11); // delete item with key 11  
        theList.displayForward(); // display list forward  
        theList.insertAfter(22, 77); // insert 77 after 22  
        theList.insertAfter(33, 88); // insert 88 after 33  
        theList.displayForward(); // display list forward  
    }  
}

11. 实现二叉树前序遍历迭代器

class TreeNode这个类用来声明树的结点，其中有左子树、右子树和自身的内容。  
class MyTree这个类用来声明一棵树，传入根结点。这里设计的比较简单  
class TreeEum这个类是树的迭代器，通过 MyTree类的方法获取，这里主要就是设计它了。代码如下：  
//TreeNode类，使用了泛型，由于比较简单，考试.大提示不作解释  
　　 class TreeNode < E > {  
    E node;　　  
    private TreeNode < String > left;　　  
    private TreeNode < String > right;　　  
    public TreeNode(E e) {　　  
        this(e, null, null);  
    }　　  
    public TreeNode(E e, TreeNode < String > left, TreeNode < String > right) {　　  
        this.node = e;　　  
        this.left = left;　　  
        this.right = right;  
    }　　  
    public TreeNode < String > left() {　　  
        return left;  
    }　　  
    public TreeNode < String > right() {　　  
        return right;  
    }  
}  
// MyTree类，没什么功能，传入根结点构造，getEnumerator()方法获取迭代器。  
　　  
class MyTree {  
    TreeNode < String > root;　　  
    public MyTree(TreeNode < String > root) {　　  
        this.root = root;  
    }　　  
    public TreeEnum getEnumerator() {　　  
        return new TreeEnum(root);  
    }  
}  
// 这个类为迭代器，有详细解释，相信各位能看懂。在栈中用了两次泛型。  
　　  
import java.util.Stack;　　  
public class TreeEnum {　　  
    private TreeNode < String > root;　　  
    private Stack < TreeNode < String >> store; /* 保存遍历左子树但未遍历右子树的结点 */ 　　  
    private TreeNode < String > next;　　  
    public TreeEnum(TreeNode < String > root) {　　  
        this.root = root;  
        store = new Stack < TreeNode < String >> ();  
        next = root;  
    }　　  
    public TreeNode < String > next() {  
        TreeNode < String > current = next;　　  
        if (next != null) {  
            /* 如果当前结点的左子树不为空,则遍历左子树,并标记当前结点未遍历右子树 */  
            　　  
            if (next.left() != null) {  
                store.push(next);  
                next = next.left();  
            }  
            // 如果当前结点的左子树为空,则遍历右子树  
            　　  
            else if (next.right() != null) {  
                next = next.right();  
            }  
            /* 如果当前结点为叶子,则找未遍历右子树的结点并且遍历它的右子树 */  
            　　  
            else {　　  
                if (!store.empty()) /* 判断是否还有结点的右子树未遍历 */ {  
                    TreeNode < String > tmp = store.pop();  
                    /* 如果有未遍历右子树的结点,但它的右子树为空,且还有结点的右子树未遍历, */  
                    /* 则一直往上取,直到取到未遍历右子树且右子树不为空的结点,遍历它的右子树. */  
                    　　  
                    while ((tmp.right() == null) && !store.empty()) {  
                        tmp = store.pop();  
                    }  
                    next = tmp.right();  
                }　　  
                else {  
                    /* 如果没有哪个结点右子树未遍历,则表示没有下一个结点了,设置next为null */  
                    next = null;  
                }  
            }  
        }　　  
        return current;  
    }　　  
    public boolean hasMoreElement() {　　  
        return next != null;  
    }  
}　　下面写个测试类，不作解释，相信大家看得懂　　  
public class TreeReader {　　  
    public static void main(String[] args) {  
        TreeNode < String > n1 = new TreeNode < String > ("n1");  
        TreeNode < String > n2 = new TreeNode < String > ("n2");  
        TreeNode < String > n3 = new TreeNode < String > ("n3");  
        TreeNode < String > n4 = new TreeNode < String > ("n4");  
        TreeNode < String > n5 = new TreeNode < String > ("n5");  
        TreeNode < String > n6 = new TreeNode < String > ("n6", null, n1);  
        TreeNode < String > n7 = new TreeNode < String > ("n7", n2, null);  
        TreeNode < String > n8 = new TreeNode < String > ("n8", n7, null);  
        TreeNode < String > n9 = new TreeNode < String > ("n9", null, n5);  
        TreeNode < String > n10 = new TreeNode < String > ("n10", n4, n9);  
        TreeNode < String > n11 = new TreeNode < String > ("n11", n6, n8);  
        TreeNode < String > n12 = new TreeNode < String > ("n12", n3, n10);  
        TreeNode < String > root = new TreeNode < String > ("root", n11, n12);  
        MyTree tree = new MyTree(root);  
        TreeEnum eum = tree.getEnumerator();　　  
        while (eum.hasMoreElement()) {  
            System.out.print(eum.next().node + "--");  
        }  
        System.out.println("end");  
    }  
}

12. 迭代器

package TreeIterator;  
public interface Iterator {  
    public boolean hasNext();  
    public Object next();  
    
}

这个接口我们有 2个方法， hasNext()是否还有下一条数据， next返回具体的 Object这里也就是树。我们先不必要忙着做他的实现类，我们现在要来做的是这个容器（不是 JAVA中容器，与 arraylist什么的无关），正所谓树的容器是什么，是山也！我们想想山应该具有什么呢！？首先它要有种植树的功能，这里可以看作添加树。我们可以想像山的功能是和树相互关联的，那么他们之间是什么关系呢，我们给他们一种聚合的关系，聚合的关系大家可以参考 UML图，我在这里给出它的一种程序表现形式。

package TreeIterator;  
public class Hall {  
    Tree[] tree; // 这里可以看作是聚合关系  
    private int index; // 指向Tree[]的标签  
    public Hall(int maxNumber) {  
        tree = new Tree[maxNumber];  
        index = 0;  
    }  
    public void add(Tree tree) {  
        this.tree[index] = tree;  
        index++;  
    }  
    public Iterator connectIterator() {  
        return new TreeIterator(this);  
    }  
}

这里我们定义的山可以抽象出
Hall类来， Tree[] tree可以看作是山和树之间的一种聚合关系。 add方法就是添加树。问题来了，山和树有了关系，那么山和迭代器有什么关系呢。它们之间肯定有一种关系。我们有了这个容器（山），就要把这个容器来实现迭代的方法： hasNext()和 Next().恩这里我们可以看出，山和迭代器之间也是一种关联关系。我们就把它看成是一种聚合关系（TIP：聚合关系一种特殊的关联关系）。我们可以通过一个 connectIterator方法来链接山和迭代器，接下来我们要去做一个具体的迭代类，这个具体的类中间有了 hasNext()和 Next()的具体实现方法

package TreeIterator;  
public class TreeIterator implements Iterator {  
    private int last = 0;  
    private Hall hall;  
    public TreeIterator(Hall hall) {  
        this.hall = hall;  
    }  
    public boolean hasNext() {  
        if (last < hall.tree.length) return true;  
        else return false;  
    }  
    public Tree next() {  
        Tree t = hall.tree[last];  
        last++;  
        return t;  
    }  
}

这里Hall hall就可以看作是一种关联关系，我们要把山和迭代器联系起来就通过构造函数来实现， hasNext和 next实现方法就体现出来了有了山，有了迭代器，可是树还没有定义，不过这个树的方法还很好解决！树不关联其他的事务，我们可以简单的这么写：

package TreeIterator;  
public class Tree {  
    private String name;  
    public Tree(String name) {  
        this.name = name;  
    }  
    public String getName() {  
        return this.name;  
    }  
}

好了似乎我们整个工程完工了，我们现在来模拟一下农民老大伯来种树撒肥的过程；

package TreeIterator;  
public class Pren {  
    public Pren() {}  
    public static void main(String[] args) {  
        Hall hall = new Hall(4);  
        hall.add(new Tree("苹果树"));  
        hall.add(new Tree("梨树"));  
        hall.add(new Tree("橘子树"));  
        hall.add(new Tree("凤梨树"));  
        for (Iterator i = hall.connectIterator(); i.hasNext();) {  
            String Type = ((Tree)(i.next())).getName();  
            if (Type == "苹果树") {  
                System.out.println("洒苹果树的农药,");  
            }  
            if (Type == "梨树") {  
                System.out.println("洒梨树的农药");  
            }  
            if (Type == "橘子树") {  
                System.out.println("洒橘子树的农药,洒了也没用,还没到成熟日,现在没结果实");  
            }  
            if (Type == "凤梨树") {  
                System.out.println("南风天，湿气大，让它烂在地里吧");  
            }  
        }  
    }  
}

种4个树，山小而五脏俱全，更像一个土包，再要有树才行啊，所以 4个树的实例出现。好了接下来种树，几毫秒解决！山了有我们就要把山放到迭代器中间去了。遍历这个山（容器）。联想我们看看 arrayList中的迭代器模式是怎么实现的！

ArrayList a = new ArrayList();  
a.add("a1");  
a.add("a2");  
a.add("a3");  
a.add("a4");  
for (Iterator i = a.iterator(); i.hasNext();) {  
    System.out.println(i.next().toString());  
}

合并搜索算法

public class MergeSortArray {  
    private long[] theArray;  
    private int nElems;  
    public MergeSortArray(int max) {  
        theArray = new long[max];  
        nElems = 0;  
    }  
    public void insert(long value) {  
        theArray[nElems] = value; // insert it  
        nElems++; // increment size  
    }  
    public void display() {  
        for (int j = 0; j < nElems; j++) System.out.print(theArray[j] + " ");  
        System.out.println("");  
    }  
    public void mergeSort() {  
        long[] workSpace = new long[nElems];  
        recMergeSort(workSpace, 0, nElems - 1);  
    }  
    private void recMergeSort(long[] workSpace, int lowerBound, int upperBound) {  
        if (lowerBound == upperBound) // if range is 1,  
            return; // no use sorting  
        else { // find midpoint  
            int mid = (lowerBound + upperBound) / 2;  
            // sort low half  
            recMergeSort(workSpace, lowerBound, mid);  
            // sort high half  
            recMergeSort(workSpace, mid + 1, upperBound);  
            // merge them  
            merge(workSpace, lowerBound, mid + 1, upperBound);  
        }  
    }  
    private void merge(long[] workSpace, int lowPtr, int highPtr, int upperBound) {  
        int j = 0; // workspace index  
        int lowerBound = lowPtr;  
        int mid = highPtr - 1;  
        int n = upperBound - lowerBound + 1; // # of items  
        while (lowPtr <= mid && highPtr <= upperBound)  
            if (theArray[lowPtr] < theArray[highPtr]) workSpace[j++] = theArray[lowPtr++];  
            else workSpace[j++] = theArray[highPtr++];  
        while (lowPtr <= mid) workSpace[j++] = theArray[lowPtr++];  
        while (highPtr <= upperBound) workSpace[j++] = theArray[highPtr++];  
        for (j = 0; j < n; j++) theArray[lowerBound + j] = workSpace[j];  
    }  
    public static void main(String[] args) {  
        int maxSize = 100; // array size  
        MergeSortArray arr = new MergeSortArray(maxSize); // create the array  
        arr.insert(14);  
        arr.insert(21);  
        arr.insert(43);  
        arr.insert(50);  
        arr.insert(62);  
        arr.insert(75);  
        arr.insert(14);  
        arr.insert(2);  
        arr.insert(39);  
        arr.insert(5);  
        arr.insert(608);  
        arr.insert(36);  
        arr.display();  
        arr.mergeSort();  
        arr.display();  
    }  
}

14. 递归

public class Recursion {  
     
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        Recursion re = new Recursion();  
        System.out.println(re.RecursionNum(10));  
    }  
    public int RecursionNum(int num) {  
        if (num > 0) {  
            return num + RecursionNum(num - 1);  
        }  
        Else {  
            return 0;  
        }  
    }  
}

15. 归并排序

/** 
 
 * 归并排序，要求待排序的数组必须实现Comparable接口 
 
 */  
public class MergeSort implements SortStrategy {  
    private Comparable[] bridge;  
    /** 
 
 * 利用归并排序算法对数组obj进行排序 
 
 */  
    public void sort(Comparable[] obj) {  
        if (obj == null) {  
            throw new NullPointerException("The param can not be null!");  
        }  
        bridge = new Comparable[obj.length]; // 初始化中间数组  
        mergeSort(obj, 0, obj.length - 1); // 归并排序  
        bridge = null;  
    }  
    /** 
 
 * 将下标从left到right的数组进行归并排序 
 
 * 
 
 * @param obj 
 
 *            要排序的数组的句柄 
 
 * @param left 
 
 *            要排序的数组的第一个元素下标 
 
 * @param right 
 
 *            要排序的数组的最后一个元素的下标 
 
 */  
    private void mergeSort(Comparable[] obj, int left, int right) {  
        if (left < right) {  
            int center = (left + right) / 2;  
            mergeSort(obj, left, center);  
            mergeSort(obj, center + 1, right);  
            merge(obj, left, center, right);  
        }  
    }  
    /** 
 
 * 将两个对象数组进行归并，并使归并后为升序。归并前两个数组分别有序 
 
 * 
 
 * @param obj 
 
 *            对象数组的句柄 
 
 * @param left 
 
 *            左数组的第一个元素的下标 
 
 * @param center 
 
 *            左数组的最后一个元素的下标 
 
 * @param right 
 
 *            右数组的最后一个元素的下标 
 
 */  
    private void merge(Comparable[] obj, int left, int center, int right) {  
        int mid = center + 1;  
        int third = left;  
        int tmp = left;  
        while (left <= center && mid <= right) { // 从两个数组中取出小的放入中间数组  
            if (obj[left].compareTo(obj[mid]) <= 0) {  
                bridge[third++] = obj[left++];  
            } else bridge[third++] = obj[mid++];  
        }  
        // 剩余部分依次置入中间数组  
        while (mid <= right) {  
            bridge[third++] = obj[mid++];  
        }  
        while (left <= center) {  
            bridge[third++] = obj[left++];  
        }  
        // 将中间数组的内容拷贝回原数组  
        copy(obj, tmp, right);  
    }  
    /** 
 
 * 将中间数组bridge中的内容拷贝到原数组中 
 
 * 
 
 * @param obj 
 
 *            原数组的句柄 
 
 * @param left 
 
 *            要拷贝的第一个元素的下标 
 
 * @param right 
 
 *            要拷贝的最后一个元素的下标 
 
 */  
    private void copy(Comparable[] obj, int left, int right) {  
        while (left <= right) {  
            obj[left] = bridge[left];  
            left++;  
        }  
    }  
}

16. 希尔排序

间隔序列：  
h = 3 * h + 1， h = (h - 1) / 3  
public class ShellSort {  
    /** 
 
 * @param args 
 
 */  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        ShellSort ss = new ShellSort();  
        int num[] = {  
            546, 87, 21, 3124, 65, 2, 9, 3, 213, 54, 98, 23, 6, 4, 7,  
            8, 123, 872, 61, 5, 8954  
        };  
        ss.shellArray(num);  
        for (int i = 0; i < num.length; i++) {  
            System.out.println(num[i]);  
        }  
    }  
    public void shellArray(int[] num) {  
        int i = 1;  
        int tem, in ;  
        for (; i < num.length / 3;) {  
            i = 3 * i + 1;  
        }  
        for (; i >= 1;) {  
            for (int j = i; j < num.length; j++) {  
                tem = num[j]; in = j;  
                while ( in > i - 1 && num[ in -i] >= tem) {  
                    num[ in ] = num[ in -i]; in = in -i;  
                }  
                num[ in ] = tem;  
            }  
            i = (i - 1) / 3;  
        }  
    }  
}

17. 快速排序

class QuickSort {  
    private int[] data;  
    QuickSort(int[] data) {  
        this.data = data;  
    }  
    public void quickSort() {  
        recQuickSort(data, 0, data.length - 1);  
    }  
    private void recQuickSort(int[] data, int low, int high) {  
        // 设置两个滑标  
        int lowCursor = low + 1;  
        int highCursor = high;  
        // 交换时的临时变量  
        int temp = 0;  
        // 比较枢值,设为数组的第一个值  
        int medi = data[low];  
        while (true) {  
            // 从低端开始查找，确定大于数 data[low] 所在的位置  
            while (lowCursor < high && data[lowCursor] < medi) {  
                lowCursor++;  
            }  
            // 从高端开始查找，确定小于数 data[low] 所在的位置。这里要使用 >= 判断确定小于值  
            while (highCursor > low && data[highCursor] >= medi) {  
                highCursor--;  
            }  
            // 两游标位置出现越界，退出循环  
            if (lowCursor >= highCursor) {  
                break;  
            }  
            // 交换 data[highCursor] 和 data[lowCursor] 位置数据  
            temp = data[highCursor];  
            data[highCursor] = data[lowCursor];  
            data[lowCursor] = temp;  
        }  
        // 由 while 循环退出条件可知：lowCursor > highCursor  
        // 当前 lowCursor 指向右侧大于 data[low]的第一个位置;  
        // 而 highCursor 指向左侧小于 data[low]的第一个位置，所以需要交换 data[low] 和  
        // data[highCursor]的值  
        data[low] = data[highCursor];  
        data[highCursor] = medi;  
        // 递归运算左半部分  
        if (low < highCursor) {  
            recQuickSort(data, low, highCursor);  
        }  
        // 递归运算右半部分  
        if (lowCursor < high) {  
            recQuickSort(data, lowCursor, high);  
        }  
    }  
    public void display() {  
        for (int i = 0; i < data.length; i++) {  
            System.out.print(data[i] + " ");  
        }  
        System.out.println();  
    }  
    public static void main(String[] args) {  
        int[] data = new int[] {  
            43, 12, 32, 55, 33, 67, 54, 65, 43, 22, 66,  
            98, 74  
        };  
        QuickSort sort = new QuickSort(data);  
        sort.display();  
        sort.quickSort();  
        sort.display();  
    }  
}

18. 二叉树

//******************************************************************************************************//  
//*****本程序包括简单的二叉树类的实现和前序,中序,后序,层次遍历二叉树算法,*******//  
//******以及确定二叉树的高度,制定对象在树中的所处层次以及将树中的左右***********//  
//******孩子节点对换位置,返回叶子节点个数删除叶子节点,并输出所删除的叶子节点**//  
//*******************************CopyRight By phoenix*******************************************//  
//************************************Jan 12,2008*************************************************//  
//****************************************************************************************************//  
public class BinTree {  
    public final static int MAX = 40;  
    BinTree[] elements = new BinTree[MAX]; // 层次遍历时保存各个节点  
    int front; // 层次遍历时队首  
    int rear; // 层次遍历时队尾  
    private Object data; // 数据元数  
    private BinTree left, right; // 指向左,右孩子结点的链  
    public BinTree() {}  
    public BinTree(Object data) { // 构造有值结点  
        this.data = data;  
        left = right = null;  
    }  
    public BinTree(Object data, BinTree left, BinTree right) { // 构造有值结点  
        this.data = data;  
        this.left = left;  
        this.right = right;  
    }  
    public String toString() {  
        return data.toString();  
    }  
    // 前序遍历二叉树  
    public static void preOrder(BinTree parent) {  
        if (parent == null) return;  
        System.out.print(parent.data + " ");  
        preOrder(parent.left);  
        preOrder(parent.right);  
    }  
    // 中序遍历二叉树  
    public void inOrder(BinTree parent) {  
        if (parent == null) return;  
        inOrder(parent.left);  
        System.out.print(parent.data + " ");  
        inOrder(parent.right);  
    }  
    // 后序遍历二叉树  
    public void postOrder(BinTree parent) {  
        if (parent == null) return;  
        postOrder(parent.left);  
        postOrder(parent.right);  
        System.out.print(parent.data + " ");  
    }  
    // 层次遍历二叉树  
    public void LayerOrder(BinTree parent) {  
        elements[0] = parent;  
        front = 0;  
        rear = 1;  
        while (front < rear) {  
            try {  
                if (elements[front].data != null) {  
                    System.out.print(elements[front].data + " ");  
                    if (elements[front].left != null) elements[rear++] = elements[front].left;  
                    if (elements[front].right != null) elements[rear++] = elements[front].right;  
                    front++;  
                }  
            } catch (Exception e) {  
                break;  
            }  
        }  
    }  
    // 返回树的叶节点个数  
    public int leaves() {  
        if (this == null) return 0;  
        if (left == null && right == null) return 1;  
        return (left == null ? 0 : left.leaves()) + (right == null ? 0 : right.leaves());  
    }  
    // 结果返回树的高度  
    public int height() {  
        int heightOfTree;  
        if (this == null) return -1;  
        int leftHeight = (left == null ? 0 : left.height());  
        int rightHeight = (right == null ? 0 : right.height());  
        heightOfTree = leftHeight < rightHeight ? rightHeight : leftHeight;  
        return 1 + heightOfTree;  
    }  
    // 如果对象不在树中,结果返回-1;否则结果返回该对象在树中所处的层次,规定根节点为第一层  
    public int level(Object object) {  
        int levelInTree;  
        if (this == null) return -1;  
        if (object == data) return 1; // 规定根节点为第一层  
        int leftLevel = (left == null ? -1 : left.level(object));  
        int rightLevel = (right == null ? -1 : right.level(object));  
        if (leftLevel < 0 && rightLevel < 0) return -1;  
        levelInTree = leftLevel < rightLevel ? rightLevel : leftLevel;  
        return 1 + levelInTree;  
    }  
    // 将树中的每个节点的孩子对换位置  
    public void reflect() {  
        if (this == null) return;  
        if (left != null) left.reflect();  
        if (right != null) right.reflect();  
        BinTree temp = left;  
        left = right;  
        right = temp;  
    }  
    // 将树中的所有节点移走,并输出移走的节点  
    public void defoliate() {  
        if (this == null) return;  
        // 若本节点是叶节点，则将其移走  
        if (left == null && right == null) {  
            System.out.print(this + " ");  
            data = null;  
            return;  
        }  
        // 移走左子树若其存在  
        if (left != null) {  
            left.defoliate();  
            left = null;  
        }  
        // 移走本节点，放在中间表示中跟移走...  
        // innerNode += this + " ";  
        data = null;  
        // 移走右子树若其存在  
        if (right != null) {  
            right.defoliate();  
            right = null;  
        }  
    }  
    /** 
 
 * @param args 
 
 */  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        BinTree e = new BinTree("E");  
        BinTree g = new BinTree("G");  
        BinTree h = new BinTree("H");  
        BinTree i = new BinTree("I");  
        BinTree d = new BinTree("D", null, g);  
        BinTree f = new BinTree("F", h, i);  
        BinTree b = new BinTree("B", d, e);  
        BinTree c = new BinTree("C", f, null);  
        BinTree tree = new BinTree("A", b, c);  
        System.out.println("前序遍历二叉树结果: ");  
        tree.preOrder(tree);  
        System.out.println();  
        System.out.println("中序遍历二叉树结果: ");  
        tree.inOrder(tree);  
        System.out.println();  
        System.out.println("后序遍历二叉树结果: ");  
        tree.postOrder(tree);  
        System.out.println();  
        System.out.println("层次遍历二叉树结果: ");  
        tree.LayerOrder(tree);  
        System.out.println();  
        System.out.println("F所在的层次: " + tree.level("F"));  
        System.out.println("这棵二叉树的高度: " + tree.height());  
        System.out.println("--------------------------------------");  
        tree.reflect();  
        System.out.println("交换每个节点的孩子节点后......");  
        System.out.println("前序遍历二叉树结果: ");  
        tree.preOrder(tree);  
        System.out.println();  
        System.out.println("中序遍历二叉树结果: ");  
        tree.inOrder(tree);  
        System.out.println();  
        System.out.println("后序遍历二叉树结果: ");  
        tree.postOrder(tree);  
        System.out.println();  
        System.out.println("层次遍历二叉树结果: ");  
        tree.LayerOrder(tree);  
        System.out.println();  
        System.out.println("F所在的层次: " + tree.level("F"));  
        System.out.println("这棵二叉树的高度: " + tree.height());  
    }  
}

经典算法的Java实现

（1）河内塔问题：

说明：

河内之塔(Towers of Hanoi)是法国人M.Claus(Lucas)于1883年从泰国带至法国的，河内为越战时北越的首都，即现在的胡志明市；1883年法国数学家 Edouard Lucas曾提及这个故事，据说创世纪时Benares有一座波罗教塔，是由三支钻石棒（Pag）所支撑，开始时神在第一根棒上放置64个由上至下依由小至大排列的金盘（Disc），并命令僧侣将所有的金盘从第一根石棒移至第三根石棒，且搬运过程中遵守大盘子在小盘子之下的原则，若每日仅搬一个盘子，则当盘子全数搬运完毕之时，此塔将毁损，而也就是世界末日来临之时。

解法：

如果柱子标为ABC，要由A搬至C，在只有一个盘子时，就将它直接搬至C，当有两个盘子，就将B当作辅助柱。

如图所示：

事实上，若有n个盘子，则移动完毕所需之次数为2^n - 1，所以当盘数为64时，则所需次数为：264- 1 = 18446744073709551615 为5.05390248594782e+16年，也就是约5000世纪，如果对这数字没什么概念，就假设每秒钟搬一个盘子好了，也要约5850亿年左右。

实现：

//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);  
        }  
    }  
}

（2）费式数列

说明：

Fibonacci为1200年代的欧洲数学家，在他的著作中曾经提到：“若有一只免子每个月生一只小免子，一个月后小免子也开始生产。起初只有一只免子，一个月后就有两只免子，二个月后有三只免子，三个月后有五只免子（小免子投入生产）…”。

如果不太理解这个例子的话，举个图就知道了，注意新生的小免子需一个月成长期才会投入生产，类似的道理也可以用于植物的生长，这就是Fibonacci数列，一般习惯称之为费氏数列，例如以下：

1、1 、2、3、5、8、13、21、34、55、89…

解法：

依说明，我们可以将费氏数列定义为以下：

fn = fn-1 + fn-2　　 if n > 2

fn = 1　　　　　　 if n = 0, 1

实现：

//Java程序的实现：  
public class Fibonacci {  
    public static void main(String[] args) {  
        int[] fib = new int[20];  
        fib[0] = 0;  
        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] + " ");  
        System.out.println();  
    }  
}

（3）巴斯卡（Pascal）三角形

说明：

巴斯卡（Pascal）三角形基本上就是在解 nCr ，因为三角形上的每一个数字各对应一个nCr，其中 n 为 row，而 r 为 column，如下：

0C0

1C0 1C1

2C0 2C1 2C2

3C0 3C1 3C2 3C3

4C0 4C1 4C2 4C3 4C4

对应的数据如下图所示：

解法：

巴斯卡三角形中的 nCr 可以使用以下这个公式来计算，以避免阶乘运算时的数值溢位：

nCr = [(n-r+1)*nCr-1]/r

nC0 = 1

实现：

//java实现  
import java.awt.*;  
import javax.swing.*;  
public class Pascal extends JFrame {  
    public Pascal() {  
        setBackground(Color.white);  
        setTitle("巴斯卡三角形");  
        setSize(520, 350);  
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        setSize(700, 700);  
        setVisible(true);  
    }  
    private long combi(int n, int r) {  
        int i;  
        long p = 1;  
        for (i = 1; i <= r; i++) p = p * (n - i + 1) / i;  
        return p;  
    }  
    public void paint(Graphics g) {  
        g.setColor(Color.white);  
        g.clearRect(0, 0, getSize().width, getSize().height);  
        g.setColor(Color.red);  
        final int N = 12;  
        int n, r, t;  
        for (n = 0; n <= N; n++) {  
            for (r = 0; r <= n; r++) g.drawString(" " + combi(n, r), (N - n) * 20 + r * 40, n * 20 + 50);  
        }  
    }  
    public static void main(String args[]) {  
        Pascal frm = new Pascal();  
    }  
}

（4）蒙地卡罗法求 PI

说明：

蒙地卡罗为摩洛哥王国之首都，该国位于法国与义大利国境，以赌博闻名。蒙地卡罗的基本原理为以乱数配合面积公式来进行解题，这种以机率来解题的方式带有赌博的意味，虽然在精确度上有所疑虑，但其解题的思考方向却是个值得学习的方式。

解法：

蒙地卡罗的解法适用于与面积有关的题目，例如求PI值或椭圆面积，这边介绍如何求PI值；假设有一个圆半径为1，所以四分之一圆面积就为PI，而包括此四分之一圆的正方形面积就为1，如下图所示：

如果随意的在正方形中投射飞标（点）好了，则这些飞标（点）有些会落于四分之一圆内，假设所投射的飞标（点）有n点，在圆内的飞标（点）有c点，则依比例来算，就会得到上图中最后的公式。

至于如何判断所产生的点落于圆内，很简单，令乱数产生X与Y两个数值，如果X^2+Y2等于1就是落在圆内。

实现：

//java程序实现  
public class PI {  
    public static void main(String[] args) {  
        final int N = 50000;  
        int sum = 0;  
        for (int i = 1; i < N; i++) {  
            double x = Math.random();  
            double y = Math.random();  
            if ((x * x + y * y) < 1) sum++;  
        }  
        System.out.println("PI = " + (double) 4 * sum / N);  
    }  
}

（5）最大公因数、最小公倍数

说明：

解法：

最大公因数使用辗转相除法来求，最小公倍数则由这个公式来求：

GCD * LCM = 两数乘积

实现：

//java程序实现  
import java.io.*;  
public class GcdLcm {  
    public static int gcdOf(int m, int n) {  
        int r;  
        while (n != 0) {  
            r = m % n;  
            m = n;  
            n = r;  
        }  
        return m;  
    }  
    public static int lcmOf(int m, int n) {  
        return m * n / gcdOf(m, n);  
    }  
    public static void main(String[] args) throws IOException {  
        BufferedReader ln = new BufferedReader(new InputStreamReader(System. in ));  
        System.out.print("请输入第一个数：");  
        int x = Integer.parseInt(ln.readLine());  
        System.out.print("请输入第二个数：");  
        int y = Integer.parseInt(ln.readLine());  
        System.out.println("GCD of (" + x + "," + y + ")=" + GcdLcm.gcdOf(x, y));  
        System.out.println("LCM of (" + x + "," + y + ")=" + GcdLcm.lcmOf(x, y));  
    }  
}

（6）阿姆斯壮数

说明：

在三位的整数中，例如153可以满足13 + 53 + 33 = 153，这样的数称之为Armstrong数，试写出一程式找出所有的三位数Armstrong数。

解法：

Armstrong数的寻找，其实就是在问如何将一个数字分解为个位数、十位数、百位数…，这只要使用除法与余数运算就可以了，例如输入 input为abc，则：

a = input / 100

b = (input%100) / 10

c = input % 10

实现：

//java程序实现  
public class Armstrong {  
    public static void main(String[] args) {  
        System.out.println("寻找Armstrong数：");  
        for (int i = 100; i <= 999; i++) {  
            int a = i / 100;  
            int b = (i % 100) / 10;  
            int c = i % 10;  
            if (a * a * a + b * b * b + c * c * c == i) System.out.print(i + " ");  
        }  
        System.out.println();  
    }  
}

（7）最大访客数

说明：

现将举行一个餐会，让访客事先填写到达时间与离开时间，为了掌握座位的数目，必须先估计不同时间的最大访客数。

解法：

这个题目看似有些复杂，其实相当简单，单就计算访客数这个目的，同时考虑同一访客的来访时间与离开时间，反而会使程式变得复杂；只要将来访时间与离开时间分开处理就可以了，假设访客 i 的来访时间为x[i]，而离开时间为y[i]。

在资料输入完毕之后，将x[i]与y[i]分别进行排序（由小到大），道理很简单，只要先计算某时之前总共来访了多少访客，然后再减去某时之前的离开访客，就可以轻易的解出这个问题

实现：

//java实现  
import java.io.*;  
import java.util.*;  
public class MaxVisit {  
    public static int maxGuest(int[] x, int[] y, int time) {  
        int num = 0;  
        for (int i = 0; i < x.length; i++) {  
            if (time > x[i]) num++;  
            if (time > y[i]) num--;  
        }  
        return num;  
    }  
    public static void main(String[] args) throws IOException {  
        BufferedReader buf = new BufferedReader(new InputStreamReader(System. in ));  
        System.out.println("输入来访时间与离开时间(0~24)：");  
        System.out.println("范例：10 15");  
        System.out.println("输入-1结束");  
        java.util.ArrayList list = new ArrayList();  
        while (true) {  
            System.out.print(">>");  
            String input = buf.readLine();  
            if (input.equals("-1")) break;  
            list.add(input);  
        }  
        int[] x = new int[list.size()];  
        int[] y = new int[list.size()];  
        for (int i = 0; i < x.length; i++) {  
            String input = (String) list.get(i);  
            String[] strs = input.split(" ");  
            x[i] = Integer.parseInt(strs[0]);  
            y[i] = Integer.parseInt(strs[1]);  
        }  
        Arrays.sort(x);  
        Arrays.sort(y);  
        for (int time = 0; time < 25; time++) {  
            System.out.println(time + " 时的最大访客数：" + MaxVisit.maxGuest(x, y, time));  
        }  
    }  
}

（8）洗扑克牌（乱数排列）

说明：

洗扑克牌的原理其实与乱数排列是相同的，都是将一组数字（例如1～N）打乱重新排列，只不过洗扑克牌多了一个花色判断的动作而已。

解法：

初学者通常会直接想到，随机产生1～N的乱数并将之存入阵列中，后来产生的乱数存入阵列前必须先检查阵列中是否已有重复的数字，如果有这个数就不存入，再重新产生下一个数，运气不好的话，重复的次数就会很多，程式的执行速度就很慢了，这不是一个好方法。

以1～52的乱数排列为例好了，可以将阵列先依序由1到52填入，然后使用一个回圈走访阵列，并随机产生1～52的乱数，将产生的乱数当作索引取出阵列值，并与目前阵列走访到的值相交换，如此就不用担心乱数重复的问题了，阵列走访完毕后，所有的数字也就重新排列了。

至于如何判断花色？这只是除法的问题而已，取商数判断花色，取余数判断数字，您可以直接看程式比较清楚。

实现：

//java实现  
public class ShuffleCard {  
    public static void main(String args[]) {  
        final int N = 52;  
        int[] poker = new int[N + 1];  
        // 初始化阵列  
        for (int i = 1; i <= N; i++) poker[i] = i;  
        // 洗牌  
        for (int i = 1; i <= N; i++) {  
            int j = (int)(Math.random() * N);  
            if (j == 0) j = 1;  
            int tmp = poker[i];  
            poker[i] = poker[j];  
            poker[j] = tmp;  
        }  
        for (int i = 1; i <= N; i++) {  
            // 判断花色  
            switch ((poker[i] - 1) / 13) {  
                case 0:  
                    System.out.print("桃");  
                    break;  
                case 1:  
                    System.out.print("心");  
                    break;  
                case 2:  
                    System.out.print("砖");  
                    break;  
                case 3:  
                    System.out.print("梅");  
                    break;  
            }  
            // 扑克牌数字  
            int remain = poker[i] % 13;  
            switch (remain) {  
                case 0:  
                    System.out.print("K ");  
                    break;  
                case 12:  
                    System.out.print("Q ");  
                    break;  
                case 11:  
                    System.out.print("J ");  
                    break;  
                default:  
                    System.out.print(remain + " ");  
                    break;  
            }  
            if (i % 13 == 0) System.out.println("");  
        }  
    }  
}

（9）约瑟夫问题（Josephus Problem）

说明：

据说着名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。

然而Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。

解法：

约瑟夫问题可用代数分析来求解，将这个问题扩大好了，假设现在您与m个朋友不幸参与了这个游戏，您要如何保护您与您的朋友？只要画两个圆圈就可以让自己与朋友免于死亡游戏，这两个圆圈内圈是排列顺序，而外圈是自杀顺序，如下图所示：

使用程式来求解的话，只要将阵列当作环状来处理就可以了，在阵列中由计数1开始，每找到三个无资料区就填入一个计数，直而计数达41为止，然后将阵列由索引1开始列出，就可以得知每个位置的自杀顺序，这就是约瑟夫排列，41个人而报数3的约琴夫排列如下所示：

14 36 1 38 15 2 24 30 3 16 34 4 25 17 5 40 31 6 18 26 7 37 19 8 35 27 9 20 32 10 41 21 11 28 39 12 22 33 13 29 23

由上可知，最后一个自杀的是在第31个位置，而倒数第二个自杀的要排在第16个位置，之前的人都死光了，所以他们也就不知道约琴夫与他的朋友并没有遵守游戏规则了。

实现：

//java实现  
public class Josephus {  
    public static int[] arrayOfJosephus(int number, int per) {  
        int[] man = new int[number];  
        for (int count = 1, i = 0, pos = -1; count <= number; count++) {  
            do {  
                pos = (pos + 1) % number; // 环状处理  
                if (man[pos] == 0) i++;  
                if (i == per) { // 报数为3了  
                    i = 0;  
                    break;  
                }  
            } while (true);  
            man[pos] = count;  
        }  
        return man;  
    }  
    public static void main(String[] args) {  
        int[] man = Josephus.arrayOfJosephus(41, 3);  
        int alive = 3;  
        System.out.println("约琴夫排列：");  
        for (int i = 0; i < 41; i++) System.out.print(man[i] + " ");  
        System.out.println("\nL表示3个存活的人要放的位置：");  
        for (int i = 0; i < 41; i++) {  
            if (man[i] > (41 - alive)) System.out.print("L");  
            else System.out.print("D");  
            if ((i + 1) % 5 == 0) System.out.print("  ");  
        }  
        System.out.println();  
    }  
}

（10）排列组合

说明：

将一组数字、字母或符号进行排列，以得到不同的组合顺序，例如1 2 3这三个数的排列组合有：1 2 3、1 3 2、2 1 3、2 3 1、3 1 2、3 2 1。

解法：

可以使用递回将问题切割为较小的单元进行排列组合，例如1 2 3 4的排列可以分为1 [2 3 4]、2 [1 3 4]、3 [1 2 4]、4 [1 2 3]进行排列，这边利用旋转法，先将旋转间隔设为0，将最右边的数字旋转至最左边，并逐步增加旋转的间隔，例如：

1 2 3 4 -> 旋转1 -> 继续将右边2 3 4进行递回处理

2 1 3 4 -> 旋转1 2 变为 2 1-> 继续将右边1 3 4进行递回处理

3 1 2 4 -> 旋转1 2 3变为 3 1 2 -> 继续将右边1 2 4进行递回处理

4 1 2 3 -> 旋转1 2 3 4变为4 1 2 3 -> 继续将右边1 2 3进行递回处理

实现：

//java实现  
public class Permutation {  
    public static void perm(int[] num, int i) {  
        if (i < num.length - 1) {  
            for (int j = i; j <= num.length - 1; j++) {  
                int tmp = num[j];  
                // 旋转该区段最右边数字至最左边  
                for (int k = j; k > i; k--) num[k] = num[k - 1];  
                num[i] = tmp;  
                perm(num, i + 1);  
                // 还原  
                for (int k = i; k < j; k++) num[k] = num[k + 1];  
                num[j] = tmp;  
            }  
        } else {  
            // 显示此次排列  
            for (int j = 1; j <= num.length - 1; j++) System.out.print(num[j] + " ");  
            System.out.println();  
        }  
    }  
    public static void main(String[] args) {  
        int[] num = new int[4 + 1];  
        for (int i = 1; i <= num.length - 1; i++) num[i] = i;  
        perm(num, 1);  
    }  
}

（11）得分排行

说明：

假设有一教师依学生座号输入考试分数，现希望在输入完毕后自动显示学生分数的排行，当然学生的分数可能相同。

解法：

这个问题基本上要解不难，只要使用额外的一个排行阵列走访分数阵列就可以了，直接使用下面的程式片段作说明：

for(i = 0; i < count; i++) {

    juni[i] = 1;

    for(j = 0; j < count; j++) {

        if(score[j] > score[i])

            juni[i]++;

   }

}

printf("得分\t排行\n");

for(i = 0; i < count; i++)

    printf("%d\t%d\n", score[i], juni[i]);

上面这个方法虽然简单，但是反覆计算的次数是n^2，如果n值变大，那么运算的时间就会拖长；改变juni阵列的长度为n+2，并将初始值设定为0，如下所示：

接下来走访分数阵列，并在分数所对应的排行阵列索引元素上加1，如下所示：

将排行阵列最右边的元素设定为1，然后依序将右边的元素值加至左边一个元素，最后排行阵列中的「分数+1」」就是得该分数的排行，如下所示：

这样的方式看起来复杂，其实不过在计算某分数之前排行的人数，假设89分之前的排行人数为x人，则89分自然就是x+1了，这也是为什么排行阵列最右边要设定为1的原因；如果89分有y人，则88分自然就是x+y+1，整个阵列右边元素向左加的原因正是如此。

如果分数有负分的情况，由于C/C++或Java等程式语言无法处理负的索引，所以必须加上一个偏移值，将所有的分数先往右偏移一个范围即可，最后显示的时候记得减回偏移值就可以了。

实现：

//  
import java.io.*;  
public class ScoreRank {  
    public static void main(String[] args)  
    throws NumberFormatException, IOException {  
        final int MAX = 100;  
        final int MIN = 0;  
        int[] score = new int[MAX + 1];  
        int[] juni = new int[MAX + 2];  
        BufferedReader reader = new BufferedReader(new InputStreamReader(System. in ));  
        int count = 0;  
        do {  
            System.out.print("输入分数，-1结束：");  
            score[count++] = Integer.parseInt(reader.readLine());  
        } while ((score[count - 1] != -1));  
        count--;  
        for (int i = 0; i < count; i++) juni[score[i]]++;  
        juni[MAX + 1] = 1;  
        for (int i = MAX; i >= MIN; i--) juni[i] = juni[i] + juni[i + 1];  
        System.out.println("得分\t排行");  
        for (int i = 0; i < count; i++) {  
            System.out.println(score[i] + "\t" + juni[score[i] + 1]);  
        }  
    }  
}

（12）选择、插入、气泡排序

说明：

选择排序（Selection sort）、插入排序（Insertion sort）与气泡排序（Bubble sort）这三个排序方式是初学排序所必须知道的三个基本排序方式，它们由于速度不快而不实用（平均与最快的时间复杂度都是O(n2)），然而它们排序的方式确是值得观察与探讨的。

解法：

① 选择排序

将要排序的对象分作两部份，一个是已排序的，一个是未排序的，从后端未排序部份选择一个最小值，并放入前端已排序部份的最后一个，例如：

排序前：70 80 31 37 10 1 48 60 33 80

[1] 80 31 37 10 70 48 60 33 80 选出最小值1

[1 10] 31 37 80 70 48 60 33 80 选出最小值10

[1 10 31] 37 80 70 48 60 33 80 选出最小值31

[1 10 31 33] 80 70 48 60 37 80 …

[1 10 31 33 37] 70 48 60 80 80 …

[1 10 31 33 37 48] 70 60 80 80 …

[1 10 31 33 37 48 60] 70 80 80 …

[1 10 31 33 37 48 60 70] 80 80 …

[1 10 31 33 37 48 60 70 80] 80 …

② 插入排序

像是玩朴克一样，我们将牌分作两堆，每次从后面一堆的牌抽出最前端的牌，然后插入前面一堆牌的适当位置，例如：

排序前：92 77 67 8 6 84 55 85 43 67

[77 92] 67 8 6 84 55 85 43 67 将77插入92前

[67 77 92] 8 6 84 55 85 43 67 将67插入77前

[8 67 77 92] 6 84 55 85 43 67 将8插入67前

[6 8 67 77 92] 84 55 85 43 67 将6插入8前

[6 8 67 77 84 92] 55 85 43 67 将84插入92前

[6 8 55 67 77 84 92] 85 43 67 将55插入67前

[6 8 55 67 77 84 85 92] 43 67 …

[6 8 43 55 67 77 84 85 92] 67 …

[6 8 43 55 67 67 77 84 85 92] …

③ 气泡排序法

顾名思义，就是排序时，最大的元素会如同气泡一样移至右端，其利用比较相邻元素的方法，将大的元素交换至右端，所以大的元素会不断的往右移动，直到适当的位置为止。

基本的气泡排序法可以利用旗标的方式稍微减少一些比较的时间，当寻访完阵列后都没有发生任何的交换动作，表示排序已经完成，而无需再进行之后的回圈比较与交换动作，例如：

排序前：95 27 90 49 80 58 6 9 18 50

27 90 49 80 58 6 9 18 50 [95] 95浮出

27 49 80 58 6 9 18 50 [90 95] 90浮出

27 49 58 6 9 18 50 [80 90 95] 80浮出

27 49 6 9 18 50 [58 80 90 95] …

27 6 9 18 49 [50 58 80 90 95] …

6 9 18 27 [49 50 58 80 90 95] …

6 9 18 [27 49 50 58 80 90 95] 由于接下来不会再发生交换动作，排序提早结束

在上面的例子当中，还加入了一个观念，就是当进行至i与i+1时没有交换的动作，表示接下来的i+2至n已经排序完毕，这也增进了气泡排序的效率。

实现：

//Java程序实现  
public class BasicSort {  
    public static void selectionSort(int[] number) {  
        for (int i = 0; i < number.length - 1; i++) {》》  
            int m = i;  
            for (int j = i + 1; j < number.length; j++)  
                if (number[j] < number[m]) m = j; === = if (i != m) swap(number, i, m);  
        }  
    }  
    public static void injectionSort(int[] number) {  
        for (int j = 1; j < number.length; j++) {  
            int tmp = number[j];  
            int i = j - 1;  
            while (tmp < number[i]) {  
                number[i + 1] = number[i];  
                i--;  
                if (i == -1) break;  
            }  
            number[i + 1] = tmp;  
        }  
    }  
    public static void bubbleSort(int[] number) {  
        boolean flag = true;  
        for (int i = 0; i < number.length - 1 && flag; i++) {  
            flag = false;  
            for (int j = 0; j < number.length - i - 1; j++) {  
                if (number[j + 1] < number[j]) {  
                    swap(number, j + 1, j);  
                    flag = true;  
                }  
            }  
        }  
    }  
    private static void swap(int[] number, int i, int j) {  
        int t;  
        t = number[i];  
        number[i] = number[j];  
        number[j] = t;  
    }  
    public static void main(String[] args) {  
        //测试：  
        int[] a = {  
            10, 9, 1, 100, 20, 200, 39, 45, 23, 18, 2, 2, 15  
        };  
        //测试选择排序：  
        System.out.println("选择排序前：");  
        for (int x: a) System.out.print(x + " ");  
        System.out.println();  
        int[] b = new int[a.length];  
        b = a;  
        selectionSort(b);  
        System.out.println("选择排序后：");  
        for (int x: b) System.out.print(x + " ");  
        System.out.println();  
        //测试插入排序：  
        System.out.println("插入排序前：");  
        for (int x: a) System.out.print(x + " ");  
        System.out.println();  
        int[] c = new int[a.length];  
        c = a;  
        injectionSort(c);  
        System.out.println("插入排序后：");  
        for (int x: c) System.out.print(x + " ");  
        System.out.println();  
        //测试气泡排序：  
        System.out.println("气泡排序前：");  
        for (int x: a) System.out.print(x + " ");  
        System.out.println();  
        int[] d = new int[a.length];  
        d = a;  
        bubbleSort(d);  
        System.out.println("气泡排序后：");  
        for (int x: d) System.out.print(x + " ");  
    }  
}

（13）快速排序（一）

说明：

快速排序法（quick sort）是目前所公认最快的排序方法之一（视解题的对象而定），虽然快速排序法在最差状况下可以达O(n2)，但是在多数的情况下，快速排序法的效率表现是相当不错的。

快速排序法的基本精神是在数列中找出适当的轴心，然后将数列一分为二，分别对左边与右边数列进行排序，而影响快速排序法效率的正是轴心的选择。

这边所介绍的第一个快速排序法版本，是在多数的教科书上所提及的版本，因为它最容易理解，也最符合轴心分割与左右进行排序的概念，适合对初学者进行讲解。

解法：

这边所介绍的快速演算如下：将最左边的数设定为轴，并记录其值为 s

廻圈处理：

令索引 i 从数列左方往右方找，直到找到大于 s 的数

令索引 j 从数列左右方往左方找，直到找到小于 s 的数

如果 i >= j，则离开回圈

如果 i < j，则交换索引i与j两处的值

将左侧的轴与 j 进行交换

对轴左边进行递回

对轴右边进行递回

透过以下演算法，则轴左边的值都会小于s，轴右边的值都会大于s，如此再对轴左右两边进行递回，就可以对完成排序的目的，例如下面的实例，*表示要交换的数，[]表示轴：

[41]　24　76*　11　45　64　21　69　19　36*

[41]　24　36　11　45*　64　21　69　19*　76

[41]　24　36　11　19　64*　21*　69　45　76

[41]　24　36　11　19　21　64　69　45　76

21　24　36　11　19　[41]　64　69　45　76

在上面的例子中，41左边的值都比它小，而右边的值都比它大，如此左右再进行递回至排序完成。

实现：

//java实现  
public class QuickSort {  
    public static void sort(int[] number) {  
        sort(number, 0, number.length - 1);  
    }  
    private static void sort(int[] number, int left, int right) {  
        if (left < right) {  
            int s = number[left];  
            int i = left;  
            int j = right + 1;  
            while (true) {  
                // 向右找  
                while (i + 1 < number.length && number[++i] < s);  
                // 向左找  
                while (j - 1 > -1 && number[--j] > s);  
                if (i >= j) break;  
                swap(number, i, j);  
            }  
            number[left] = number[j];  
            number[j] = s;  
            sort(number, left, j - 1);  
            // 对左边进行递回  
            sort(number, j + 1, right);  
            // 对右边进行递回  
        }  
    }  
    private static void swap(int[] number, int i, int j) {  
        int t;  
        t = number[i];  
        number[i] = number[j];  
        number[j] = t;  
    }  
}

（14）快速排序（二）

说明：

在快速排序法（一）中，每次将最左边的元素设为轴，而之前曾经说过，快速排序法的加速在于轴的选择，在这个例子中，只将轴设定为中间的元素，依这个元素作基准进行比较，这可以增加快速排序法的效率。

解法：

在这个例子中，取中间的元素s作比较，同样的先得右找比s大的索引 i，然后找比s小的索引 j，只要两边的索引还没有交会，就交换 i 与 j 的元素值，这次不用再进行轴的交换了，因为在寻找交换的过程中，轴位置的元素也会参与交换的动作，例如：

41　24　76　11　45　64　21　69　19　36

首先left为0，right为9，(left+right)/2 = 4（取整数的商），所以轴为索引4的位置，比较的元素是45，您往右找比45大的，往左找比45小的进行交换：

41　24　76*　11　[45]　64　21　69　19　*36

41　24　36　11　45*　64　21　69　19*　76

41　24　36　11　19　64*　21*　69　45　76

[41　24　36　11　19　21]　[64　69　45　76]

完成以上之后，再初别对左边括号与右边括号的部份进行递回，如此就可以完成排序的目的。

实现：

public class QuickSort {  
    public static void sort(int[] number) {  
        sort(number, 0, number.length - 1);  
    }  
    private static void sort(int[] number, int left, int right) {  
        if (left < right) {  
            int s = number[(left + right) / 2];  
            int i = left - 1;  
            int j = right + 1;  
            while (true) {  
                // 向右找  
                while (number[++i] < s);  
                // 向左找  
                while (number[--j] > s);  
                if (i >= j) break;  
                swap(number, i, j);  
            }  
            sort(number, left, i - 1);  
            // 对左边进行递回  
            sort(number, j + 1, right);  
            // 对右边进行递回  
        }  
    }  
    private static void swap(int[] number, int i, int j) {  
        int t;  
        t = number[i];  
        number[i] = number[j];  
        number[j] = t;  
    }  
}

（15）快速排序（三）

说明：

之前说过轴的选择是快速排序法的效率关键之一，在这边的快速排序法的轴选择方式更加快了快速排序法的效率，它是来自演算法名书 Introduction to Algorithms 之中。

解法：

先说明这个快速排序法的概念，它以最右边的值s作比较的标准，将整个数列分为三个部份，一个是小于s的部份，一个是大于s的部份，一个是未处理的部份，如下所示：

在排序的过程中，i 与 j 都会不断的往右进行比较与交换，最后数列会变为以下的状态：

然后将s的值置于中间，接下来就以相同的步骤会左右两边的数列进行排序的动作，如下所示：

整个演算的过程，直接摘录书中的虚拟码来作说明：

实现：

public class QuickSort3 {  
    public static void sort(int[] number) {  
        sort(number, 0, number.length - 1);  
    }  
    private static void sort(int[] number, int left, int right) {  
        if (left < right) {  
            int q = partition(number, left, right);  
            sort(number, left, q - 1);  
            sort(number, q + 1, right);  
        }  
    }  
    private static int partition(int number[], int left, int right) {  
        int s = number[right];  
        int i = left - 1;  
        for (int j = left; j < right; j++) {  
            if (number[j] <= s) {  
                i++;  
                swap(number, i, j);  
            }  
        }  
        swap(number, i + 1, right);  
        return i + 1;  
    }  
    private static void swap(int[] number, int i, int j) {  
        int t;  
        t = number[i];  
        number[i] = number[j];  
        number[j] = t;  
    }  
}

（16）合并排序

说明：

之前所介绍的排序法都是在同一个阵列中的排序，考虑今日有两笔或两笔以上的资料，它可能是不同阵列中的资料，或是不同档案中的资料，如何为它们进行排序？

解法：

可以使用合并排序法，合并排序法基本是将两笔已排序的资料合并并进行排序，如果所读入的资料尚未排序，可以先利用其它的排序方式来处理这两笔资料，然后再将排序好的这两笔资料合并。

有人问道，如果两笔资料本身就无排序顺序，何不将所有的资料读入，再一次进行排序？排序的精神是尽量利用资料已排序的部份，来加快排序的效率，小笔资料的排序较为快速，如果小笔资料排序完成之后，再合并处理时，因为两笔资料都有排序了，所有在合并排序时会比单纯读入所有的资料再一次排序来的有效率。

那么可不可以直接使用合并排序法本身来处理整个排序的动作？而不动用到其它的排序方式？答案是肯定的，只要将所有的数字不断的分为两个等分，直到最后剩一个数字为止，然后再反过来不断的合并，就如下图所示：

不过基本上分割又会花去额外的时间，不如使用其它较好的排序法来排序小笔资料，再使用合并排序来的有效率。

实现：

public class MergeSort {  
    public static int[] sort(int[] number1, int[] number2) {  
        int[] number3 = new int[number1.length + number2.length];  
        int i = 0, j = 0, k = 0;  
        while (i < number1.length && j < number2.length) {  
            if (number1[i] <= number2[j]) number3[k++] = number1[i++];  
            else number3[k++] = number2[j++];  
        }  
        while (i < number1.length) number3[k++] = number1[i++];  
        while (j < number2.length) number3[k++] = number2[j++];  
        return number3;  
    }  
}

（17）基数排序

说明：

在之前所介绍过的排序方法，都是属于「比较性」的排序法，也就是每次排序时，都是比较整个键值的大小以进行排序。

这边所要介绍的「基数排序法」（radix sort）则是属于「分配式排序」（distribution sort），基数排序法又称「桶子法」（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些「桶」中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog®m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的比较性排序法。

解法：

基数排序的方式可以采用LSD（Least sgnificant digital）或MSD（Most sgnificant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。

以LSD为例，假设原来有一串数值如下所示：

73, 22, 93, 43, 55, 14, 28, 65, 39, 81

首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

81, 22, 73, 93, 43, 14, 55, 65, 28, 39

接着再进行一次分配，这次是根据十位数来分配：

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

14, 22, 28, 39, 43, 55, 65, 73, 81, 93

这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。

LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好，MSD的方式恰与LSD相反，是由高位数为基底开始进行分配，其他的演算方式则都相同。

实现：

public class RadixSort {  
    public static void sort(int[] number, int d) {  
        int k = 0;  
        int n = 1;  
        int[][] temp = new int[number.length][number.length];  
        int[] order = new int[number.length];  
        while (n <= d) {  
            for (int i = 0; i < number.length; i++) {  
                int lsd = ((number[i] / n) % 10);  
                temp[lsd][order[lsd]] = number[i];  
                order[lsd]++;  
            }  
            for (int i = 0; i < number.length; i++) {  
                if (order[i] != 0)  
                    for (int j = 0; j < order[i]; j++) {  
                        number[k] = temp[i][j];  
                        k++;  
                    }  
                order[i] = 0;  
            }  
            n *= 10;  
            k = 0;  
        }  
    }  
    public static void main(String[] args) {  
        int[] data = {  
            73, 22, 93, 43, 55, 14, 28, 65, 39, 81, 33, 100  
        };  
        RadixSort.sort(data, 100);  
        for (int i = 0; i < data.length; i++) {  
            System.out.print(data[i] + " ");  
        }  
    }  
}

（18）循序查找法（使用卫兵）

说明：

搜寻的目的，是在「已排序的资料」中寻找指定的资料，而当中循序搜寻是最基本的搜寻法，只要从资料开头寻找到最后，看看是否找到资料即可。

解法：

初学者看到循序搜寻，多数都会使用以下的方式来进行搜寻：

while(i < MAX) {

    if(number[i] == k) {

        printf("找到指定值");

        break;

    }

    i++;

}

这个方法基本上没有错，但是可以加以改善，可以利用设定卫兵的方式，省去if判断式，卫兵通常设定在数列最后或是最前方，假设设定在列前方好了（索引0的位置），我们从数列后方向前找，如果找到指定的资料时，其索引值不是0，表示在数列走访完之前就找到了，在程式的撰写上，只要使用一个while回圈就可以了。

实现：

public class LinearSearch {  
    public static int search(int[] number, int des) {  
        int[] tmp = new int[number.length + 1];  
        for (int i = 1; i < tmp.length; i++) {  
            tmp[i] = number[i - 1];  
        }  
        tmp[0] = des;  
        int k = tmp[0];  
        int i = number.length;  
        while (tmp[i] != k) i--;  
        return i - 1;  
    }  
    public static void main(String[] args) {  
        int[] number = {  
            1, 4, 2, 6, 7, 3, 9, 8  
        };  
        QuickSort.sort(number);  
        int find = LinearSearch.search(number, 3);  
        if (find != 0) System.out.println("找到数值于索引" + find);  
        else System.out.println("找不到数值");  
    }  
}

（19）二分查找法

说明：

如果搜寻的数列已经有排序，应该尽量利用它们已排序的特性，以减少搜寻比对的次数，这是搜寻的基本原则，二分搜寻法是这个基本原则的代表。

解法：

在二分搜寻法中，从数列的中间开始搜寻，如果这个数小于我们所搜寻的数，由于数列已排序，则该数左边的数一定都小于要搜寻的对象，所以无需浪费时间在左边的数；如果搜寻的数大于所搜寻的对象，则右边的数无需再搜寻，直接搜寻左边的数。

所以在二分搜寻法中，将数列不断的分为两个部份，每次从分割的部份中取中间数比对，例如要搜寻92于以下的数列，首先中间数索引为(0+9)/2 = 4（索引由0开始）：

[3 24 57 57 67 68 83 90 92 95]

由于67小于92，所以转搜寻右边的数列：

3 24 57 57 67 [68 83 90 92 95]

由于90小于92，再搜寻右边的数列，这次就找到所要的数了：

3 24 57 57 67 68 83 90 [92 95]

实现：

public class BinarySearch {  
    public static int search(int[] number, int des) {  
        int low = 0;  
        int upper = number.length - 1;  
        while (low <= upper) {  
            int mid = (low + upper) / 2;  
            if (number[mid] < des) low = mid + 1;  
            else if (number[mid] > des) upper = mid - 1;  
            else return mid;  
        }  
        return -1;  
    }  
    public static void main(String[] args) {  
        int[] number = {  
            1, 4, 2, 6, 7, 3, 9, 8  
        };  
        QuickSort.sort(number);  
        int find = BinarySearch.search(number, 3);  
        if (find != -1) System.out.println("找到数值于索引" + find);  
        else System.out.println("找不到数值");  
    }  
}

（20）插补查找法

说明：

如果却搜寻的资料分布平均的话，可以使用插补（Interpolation）搜寻法来进行搜寻，在搜寻的对象大于500时，插补搜寻法会比二分搜寻法来的快速。

解法：

插补搜寻法是以资料分布的近似直线来作比例运算，以求出中间的索引并进行资料比对，如果取出的值小于要寻找的值，则提高下界，如果取出的值大于要寻找的值，则降低下界，如此不断的减少搜寻的范围，所以其本原则与二分搜寻法是相同的，至于中间值的寻找是透过比例运算，如下所示，其中K是指定要寻找的对象，而m则是可能的索引值：

实现：

public class InterpolationSearch {  
    public static int search(int[] number, int des) {  
        int low = 0;  
        int upper = number.length - 1;  
        while (low <= upper) {  
            int mid = (upper - low) * (des - number[low]) / (number[upper] - number[low]) + low;  
            if (mid < low || mid > upper) return -1;  
            if (des < number[mid]) upper = mid - 1;  
            else if (des > number[mid]) low = mid + 1;  
            else return mid;  
        }  
        return -1;  
    }  
    public static void main(String[] args) {  
        int[] number = {  
            1, 4, 2, 6, 7, 3, 9, 8  
        };  
        QuickSort.sort(number);  
        int find = InterpolationSearch.search(number, 3);  
        if (find != -1) System.out.println("找到数值于索引" + find);  
        else System.out.println("找不到数值");  
    }  
}

（21）费式查找法

说明：

二分搜寻法每次搜寻时，都会将搜寻区间分为一半，所以其搜寻时间为O(log(2)n)，log(2)表示以2为底的log值，这边要介绍的费氏搜寻，其利用费氏数列作为间隔来搜寻下一个数，所以区间收敛的速度更快，搜寻时间为O(logn)。

解法：

费氏搜寻使用费氏数列来决定下一个数的搜寻位置，所以必须先制作费氏数列，这在之前有提过；费氏搜寻会先透过公式计算求出第一个要搜寻数的位置，以及其代表的费氏数，以搜寻对象10个数字来说，第一个费氏数经计算后一定是F5，而第一个要搜寻的位置有两个可能，例如若在下面的数列搜寻的话（为了计算方便， 通常会将索引0订作无限小的数，而数列由索引1开始）：

-infin; 1 3 5 7 9 13 15 17 19 20

如果要搜寻5的话，则由索引F5 = 5开始搜寻，接下来如果数列中的数小于指定搜寻值时，就往左找，大于时就向右，每次找的间隔是F4、F3、F2来寻找，当费氏数为0时还没找到，就表示寻找失败，如下所示：

由于第一个搜寻值索引F5 = 5处的值小于19，所以此时必须对齐数列右方，也就是将第一个搜寻值的索引改为F5+2 = 7，然后如同上述的方式进行搜寻，如下所示：

至于第一个搜寻值是如何找到的？我们可以由以下这个公式来求得，其中n为搜寻对象的个数：

Fx + m = n

Fx <= n

也就是说Fx必须找到不大于n的费氏数，以10个搜寻对象来说：

Fx + m = 10

取Fx = 8, m = 2，所以我们可以对照费氏数列得x = 6，然而第一个数的可能位置之一并不是F6，而是第x-1的费氏数，也就是F5 = 5。

如果数列number在索引5处的值小于指定的搜寻值，则第一个搜寻位置就是索引5的位置，如果大于指定的搜寻值，则第一个搜寻位置必须加上m，也就是F5 + m = 5 + 2 = 7，也就是索引7的位置，其实加上m的原因，是为了要让下一个搜寻值刚好是数列的最后一个位置。

费氏搜寻看来难懂，但只要掌握Fx + m = n这个公式，自己找几个实例算一次，很容易就可以理解；费氏搜寻除了收敛快速之外，由于其本身只会使用到加法与减法，在运算上也可以加快。

实现：

public class FibonacciSearch {  
    public static int search(int[] number, int des) {  
        int[] fib = createFibonacci(number.length);  
        int x = findX(fib, number.length + 1, des);  
        int m = number.length - fib[x];  
        x--;  
        int i = x;  
        if (number[i] < des) i += m;  
        while (fib[x] > 0) {  
            if (number[i] < des) i += fib[--x];  
            else if (number[i] > des) i -= fib[--x];  
            else return i;  
        }  
        return -1;  
    }  
    private static int[] createFibonacci(int max) {  
        int[] fib = new int[max];  
        for (int i = 0; i < fib.length; i++) {  
            fib[i] = Integer.MIN_VALUE;  
        }  
        fib[0] = 0;  
        fib[1] = 1;  
        for (int i = 2; i < max; i++) fib[i] = fib[i - 1] + fib[i - 2];  
        return fib;  
    }  
    private static int findX(int[] fib, int n, int des) {  
        int i = 0;  
        while (fib[i] <= n) i++;  
        i--;  
        return i;  
    }  
    public static void main(String[] args) {  
        int[] number = {  
            1, 4, 2, 6, 7, 3, 9, 8  
        };  
        QuickSort.sort(number);  
        int find = FibonacciSearch.search(number, 3);  
        if (find != -1) System.out.println("找到数值于索引" + find);  
        else System.out.println("找不到数值");  
    }  
}

（22）稀疏矩阵

说明：

如果在矩阵中，多数的元素并没有资料，称此矩阵为稀疏矩阵（sparse matrix），由于矩阵在程式中常使用二维阵列表示，二维阵列的大小与使用的记忆体空间成正比，如果多数的元素没有资料，则会造成记忆体空间的浪费，为 此，必须设计稀疏矩阵的阵列储存方式，利用较少的记忆体空间储存完整的矩阵资讯。

解法：

在这边所介绍的方法较为简单，阵列只储存矩阵的行数、列数与有资料的索引位置及其值，在需要使用矩阵资料时，再透过程式运算加以还原，例如若矩阵资料如下，其中0表示矩阵中该位置没有资料：

0 0 0 0 0 0

0 3 0 0 0 0

0 0 0 6 0 0

0 0 9 0 0 0

0 0 0 0 12 0

这个矩阵是5X6矩阵，非零元素有4个，您要使用的阵列第一列记录其列数、行数与非零元素个数：

5 6 4

阵列的第二列起，记录其位置的列索引、行索引与储存值：

1 1 3

2 3 6

3 2 9

4 4 12

所以原本要用30个元素储存的矩阵资讯，现在只使用了15个元素来储存，节省了不少记忆体的使用。

实现：

public class SparseMatrix {  
    public static int[][] restore(int[][] sparse) {  
        int row = sparse[0][0];  
        int column = sparse[0][1];  
        int[][] array = new int[row][column];  
        int k = 1;  
        for (int i = 0; i < row; i++) {  
            for (int j = 0; j < column; j++) {  
                if (k <= sparse[0][2] && i == sparse[k][0] && j == sparse[k][1]) {  
                    array[i][j] = sparse[k][2];  
                    k++;  
                } else array[i][j] = 0;  
            }  
        }  
        return array;  
    }  
    public static void main(String[] args) {  
        int[][] sparse = {  
            {  
                5, 6, 4  
            }, {  
                1, 1, 3  
            }, {  
                2, 3, 6  
            }, {  
                3, 2, 9  
            }, {  
                4, 4, 12  
            }  
        };  
        int[][] array = SparseMatrix.restore(sparse);  
        for (int i = 0; i < array.length; i++) {  
            for (int j = 0; j < array[i].length; j++) {  
                System.out.print(array[i][j] + " ");  
            }  
            System.out.println();  
        }  
    }  
}

（23）多维矩阵转一维矩阵

说明：

有的时候，为了运算方便或资料储存的空间问题，使用一维阵列会比二维或多维阵列来得方便，例如上三角矩阵、下三角矩阵或对角矩阵，使用一维阵列会比使用二维阵列来得节省空间。

解法：

以二维阵列转一维阵列为例，索引值由0开始，在由二维阵列转一维阵列时，我们有两种方式：「以列（Row）为主」或「以行（Column）为主」。由于 C/C++、Java等的记忆体配置方式都是以列为主，所以您可能会比较熟悉前者（Fortran的记忆体配置方式是以行为主）。

以列为主的二维阵列要转为一维阵列时，是将二维阵列由上往下一列一列读入一维阵列，此时索引的对应公式如下所示，其中row与column是二维阵列索引，loc表示对应的一维阵列索引：

loc = column + row*行数

以行为主的二维阵列要转为一维阵列时，是将二维阵列由左往右一行一行读入一维阵列，此时索引的对应公式如下所示：

loc = row + column*列数

公式的推导您画图看看就知道了，如果是三维阵列，则公式如下所示，其中i（个数u1）、j（个数u2）、k（个数u3）分别表示三维阵列的三个索引：

以列为主：loc = iu2u3 + j*u3 + k

以行为主：loc = ku1u2 + j*u1 + i

更高维度的可以自行依此类推，但通常更高维度的建议使用其它资料结构（例如物件包装）会比较具体，也不易搞错。

实现：

public class TwoDimArray {  
    public static int[] toOneDimByRow(int[][] array) {  
        int[] arr = new int[array.length * array[0].length];  
        for (int row = 0; row < array.length; row++) {  
            for (int column = 0; column < array[0].length; column++) {  
                int i = column + row * array[0].length;  
                arr[i] = array[row][column];  
            }  
        }  
        return arr;  
    }  
    public static int[] toOneDimByColumn(int[][] array) {  
        int[] arr = new int[array.length * array[0].length];  
        for (int row = 0; row < array.length; row++) {  
            for (int column = 0; column < array[0].length; column++) {  
                int i = i = row + column * array.length;  
                arr[i] = array[row][column];  
            }  
        }  
        return arr;  
    }  
}

（24）上三角、下三角、对称矩阵

说明：

上三角矩阵是矩阵在对角线以下的元素均为0，即Aij = 0，i > j，例如：

1 2 3 4 5

0 6 7 8 9

0 0 10 11 12

0 0 0 13 14

0 0 0 0 15

下三角矩阵是矩阵在对角线以上的元素均为0，即Aij = 0，i < j，例如：

1 0 0 0 0

2 6 0 0 0

3 7 10 0 0

4 8 11 13 0

5 9 12 14 15

对称矩阵是矩阵元素对称于对角线，例如：

1 2 3 4 5

2 6 7 8 9

3 7 10 11 12

4 8 11 13 14

5 9 12 14 15

上三角或下三角矩阵也有大部份的元素不储存值（为0），我们可以将它们使用一维阵列来储存以节省储存空间，而对称矩阵因为对称于对角线，所以可以视为上三角或下三角矩阵来储存。

解法：

假设矩阵为nxn，为了计算方便，我们让阵列索引由1开始，上三角矩阵化为一维阵列，若以列为主，其公式为：loc = n*(i-1) - i*(i-1)/2 + j

化为以行为主，其公式为：loc = j*(j-1)/2 + i

下三角矩阵化为一维阵列，若以列为主，其公式为：loc = i*(i-1)/2 + j

若以行为主，其公式为：loc = n*(j-1) - j*(j-1)/2 + i

实现：

public class TriangleArray {  
    private int[] arr;  
    private int length;  
    public TriangleArray(int[][] array) {  
        length = array.length;  
        arr = new int[length * (1 + length) / 2];  
        int loc = 0;  
        for (int i = 0; i < length; i++) {  
            for (int j = 0; j < length; j++) {  
                if (array[i][j] != 0) arr[loc++] = array[i][j];  
            }  
        }  
    }  
    public int getValue(int i, int j) {  
        int loc = length * i - i * (i + 1) / 2 + j;  
        return arr[loc];  
    }  
    public static void main(String[] args) {  
        int[][] array = {  
            {  
                1, 2, 3, 4, 5  
            }, {  
                0, 6, 7, 8, 9  
            }, {  
                0, 0, 10, 11, 12  
            }, {  
                0, 0, 0, 13, 14  
            }, {  
                0, 0, 0, 0, 15  
            }  
        };  
        TriangleArray triangleArray = new TriangleArray(array);  
        System.out.print(triangleArray.getValue(2, 2));  
    }  
}

（25）奇数魔方阵

说明：

将1到n(为奇数)的数字排列在nxn的方阵上，且各行、各列与各对角线的和必须相同，如下所示：

解法：

填魔术方阵的方法以奇数最为简单，第一个数字放在第一行第一列的正中央，然后向右(左)上填，如果右(左)上已有数字，则向下填，如下图所示：

一般程式语言的阵列索引多由0开始，为了计算方便，我们利用索引1到n的部份，而在计算是向右(左)上或向下时，我们可以将索引值除以n值，如果得到余数为1就向下，否则就往右(左)上，原理很简单，看看是不是已经在同一列上绕一圈就对了。

实现：

public class Matrix {  
    public static int[][] magicOdd(int n) {  
        int[][] square = new int[n + 1][n + 1];  
        int i = 0;  
        int j = (n + 1) / 2;  
        for (int key = 1; key <= n * n; key++) {  
            if ((key % n) == 1) i++;  
            else {  
                i--;  
                j++;  
            }  
            if (i == 0) i = n;  
            if (j > n) j = 1;  
            square[i][j] = key;  
        }  
        int[][] matrix = new int[n][n];  
        for (int k = 0; k < matrix.length; k++) {  
            for (int l = 0; l < matrix[0].length; l++) {  
                matrix[k][l] = square[k + 1][l + 1];  
            }  
        }  
        return matrix;  
    }  
    public static void main(String[] args) {  
        int[][] magic = Matrix.magicOdd(5);  
        for (int k = 0; k < magic.length; k++) {  
            for (int l = 0; l < magic[0].length; l++) {  
                System.out.print(magic[k][l] + " ");  
            }  
            System.out.println();  
        }  
    }  
}

（26）4N魔方阵

说明：

与 奇数魔术方阵 相同，在于求各行、各列与各对角线的和相等，而这次方阵的维度是4的倍数。

解法：

先来看看4X4方阵的解法：

简单的说，就是一个从左上由1依序开始填，但遇对角线不填，另一个由左上由16开始填，但只填在对角线，再将两个合起来就是解答了；如果N大于2，则以 4X4为单位画对角线：

至于对角线的位置该如何判断，有两个公式，有兴趣的可以画图印证看看，如下所示：

左上至右下：j % 4 == i % 4

右上至左下：(j % 4 + i % 4) == 1

实现：

public class Matrix2 {  
    public static int[][] magicFourN(int n) {  
        int[][] square = new int[n + 1][n + 1];  
        for (int j = 1; j <= n; j++) {  
            for (int i = 1; i <= n; i++) {  
                if (j % 4 == i % 4 || (j % 4 + i % 4) == 1) square[i][j] = (n + 1 - i) * n - j + 1;  
                else square[i][j] = (i - 1) * n + j;  
            }  
        }  
        int[][] matrix = new int[n][n];  
        for (int k = 0; k < matrix.length; k++) {  
            for (int l = 0; l < matrix[0].length; l++) {  
                matrix[k][l] = square[k + 1][l + 1];  
            }  
        }  
        return matrix;  
    }  
    public static void main(String[] args) {  
        int[][] magic = Matrix2.magicFourN(8);  
        for (int k = 0; k < magic.length; k++) {  
            for (int l = 0; l < magic[0].length; l++) {  
                System.out.print(magic[k][l] + " ");  
            }  
            System.out.println();  
        }  
    }  
}

（27）2(2n+1)魔方阵

说明：

方阵的维度整体来看是偶数，但是其实是一个奇数乘以一个偶数，例如6X6，其中6=2X3，我们也称这种方阵与单偶数方阵。

解法：

如果您会解奇数魔术方阵，要解这种方阵也就不难理解，首先我们令n=2(2m+1)，并将整个方阵看作是数个奇数方阵的组合，如下所示：

首先依序将A、B、C、D四个位置，依奇数方阵的规则填入数字，填完之后，方阵中各行的和就相同了，但列与对角线则否，此时必须在A-D与C- B之间，作一些对应的调换，规则如下：

将A中每一列(中间列除外)的头m个元素，与D中对应位置的元素调换。

将A的中央列、中央那一格向左取m格，并与D中对应位置对调

将C中每一列的倒数m-1个元素，与B中对应的元素对调

举个实例来说，如何填6X6方阵，我们首先将之分解为奇数方阵，并填入数字，如下所示：

接下来进行互换的动作，互换的元素以不同颜色标示，如下：

实现：

public class Matrix3 {  
    public static int[][] magic22mp1(int n) {  
        int[][] square = new int[n][n];  
        magic_o(square, n / 2);  
        exchange(square, n);  
        return square;  
    }  
    private static void magic_o(int[][] square, int n) {  
        int row = 0;  
        int column = n / 2;  
        for (int count = 1; count <= n * n; count++) {  
            square[row][column] = count;  
            // 填A  
            square[row + n][column + n] = count + n * n;  
            // 填B  
            square[row][column + n] = count + 2 * n * n;  
            // 填C  
            square[row + n][column] = count + 3 * n * n;  
            // 填D  
            if (count % n == 0) row++;  
            else {  
                row = (row == 0) ? n - 1 : row - 1;  
                column = (column == n - 1) ? 0 : column + 1;  
            }  
        }  
    }  
    private static void exchange(int[][] x, int n) {  
        int i, j;  
        int m = n / 4;  
        int m1 = m - 1;  
        for (i = 0; i < n / 2; i++) {  
            if (i != m) {  
                for (j = 0; j < m; j++)  
                // 处理规则 1  
                    swap(x, i, j, n / 2 + i, j);  
                for (j = 0; j < m1; j++)  
                // 处理规则 2  
                    swap(x, i, n - 1 - j, n / 2 + i, n - 1 - j);  
            } else {  
                // 处理规则 3  
                for (j = 1; j <= m; j++) swap(x, m, j, n / 2 + m, j);  
                for (j = 0; j < m1; j++) swap(x, m, n - 1 - j, n / 2 + m, n - 1 - j);  
            }  
        }  
    }  
    private static void swap(int[][] number, int i, int j, int k, int l) {  
        int t;  
        t = number[i][j];  
        number[i][j] = number[k][l];  
        number[k][l] = t;  
    }  
    public static void main(String[] args) {  
        int[][] magic = Matrix3.magic22mp1(6);  
        for (int k = 0; k < magic.length; k++) {  
            for (int l = 0; l < magic[0].length; l++) {  
                System.out.print(magic[k][l] + " ");  
            }  
            System.out.println();  
        }  
    }  
}

你可能感兴趣的:(java)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式 java
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
Nginx负载均衡 510888780 nginx 应用服务器
Nginx负载均衡一些基础知识: nginx 的 upstream目前支持 4 种方式的分配 1)、轮询（默认）每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。 2)、weight 指定轮询几率，weight和访问比率成正比
RedHat 6.4 安装 rabbitmq bylijinnan erlang rabbitmq redhat
在 linux 下安装软件就是折腾，首先是测试机不能上外网要找运维开通，开通后发现测试机的 yum 不能使用于是又要配置 yum 源，最后安装 rabbitmq 时也尝试了两种方法最后才安装成功机器版本： [root@redhat1 rabbitmq]# lsb_release LSB Version: :base-4.0-amd64:base-4.0-noarch:core
FilenameUtils工具类 eksliang FilenameUtils common-io
转载请出自出处：http://eksliang.iteye.com/blog/2217081 一、概述这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。非常的好用。
xml文件解析SAX 不懂事的小屁孩 xml
xml文件解析:xml文件解析有四种方式， 1.DOM生成和解析XML文档(SAX是基于事件流的解析) 2.SAX生成和解析XML文档(基于XML文档树结构的解析) 3.DOM4J生成和解析XML文档 4.JDOM生成和解析XML 本文章用第一种方法进行解析，使用android常用的DefaultHandler import org.xml.sax.Attributes;
通过定时任务执行mysql的定期删除和新建分区，此处是按日分区酷的飞上天空 mysql
使用python脚本作为命令脚本，linux的定时任务来每天定时执行 #!/usr/bin/python # -*- coding: utf8 -*- import pymysql import datetime import calendar #要分区的表 table_name = 'my_table' #连接数据库的信息 host,user,passwd,db =
如何搭建数据湖架构？听听专家的意见蓝儿唯美架构
Edo Interactive在几年前遇到一个大问题：公司使用交易数据来帮助零售商和餐馆进行个性化促销，但其数据仓库没有足够时间去处理所有的信用卡和借记卡交易数据 “我们要花费27小时来处理每日的数据量，”Edo主管基础设施和信息系统的高级副总裁Tim Garnto说道：“所以在2013年，我们放弃了现有的基于PostgreSQL的关系型数据库系统，使用了Hadoop集群作为公司的数
spring学习——控制反转与依赖注入 a-john spring
控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。
用spool+unixshell生成文本文件的方法 aijuans xshell
例如我们把scott.dept表生成文本文件的语句写成dept.sql,内容如下: 　　set pages 50000; 　　set lines 200; 　　set trims on; 　　set heading off; 　　spool /oracle_backup/log/test/dept.lst; 　　select deptno||','||dname||','||loc
1、基础--名词解析(OOA/OOD/OOP) asia007 学习基础知识
OOA:Object-Oriented Analysis（面向对象分析方法）是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。　　OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）
浅谈java转成json编码格式技术百合不是茶 json编码 java转成json编码
json编码;是一个轻量级的数据存储和传输的语言在java中需要引入json相关的包,引包方式在工程的lib下就可以了 JSON与JAVA数据的转换（JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式，非常适合于服务器与 JavaScript 之间的数据的交
web.xml之Spring配置(基于Spring+Struts+Ibatis) bijian1013 java web.xml SSI spring配置
指定Spring配置文件位置 <context-param> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/spring-dao-bean.xml,/WEB-INF/spring-resources.xml, /WEB-INF/
Installing SonarQube（Fail to download libraries from server） sunjing Install Sonar
1. Download and unzip the SonarQube distribution 2. Starting the Web Server The default port is "9000" and the context path is "/". These values can be changed in &l
【MongoDB学习笔记十一】Mongo副本集基本的增删查 bit1129 mongodb
一、创建复本集假设mongod,mongo已经配置在系统路径变量上，启动三个命令行窗口，分别执行如下命令： mongod --port 27017 --dbpath data1 --replSet rs0 mongod --port 27018 --dbpath data2 --replSet rs0 mongod --port 27019 -
Anychart图表系列二之执行Flash和HTML5渲染白糖_ Flash
今天介绍Anychart的Flash和HTML5渲染功能 HTML5 Anychart从6.0第一个版本起，已经逐渐开始支持各种图的HTML5渲染效果了，也就是说即使你没有安装Flash插件，只要浏览器支持HTML5，也能看到Anychart的图形（不过这些是需要做一些配置的）。这里要提醒下大家，Anychart6.0版本对HTML5的支持还不算很成熟，目前还处于
Laravel版本更新异常4.2.8-> 4.2.9 Declaration of ... CompilerEngine ... should be compa bozch laravel
昨天在为了把laravel升级到最新的版本，突然之间就出现了如下错误： ErrorException thrown with message "Declaration of Illuminate\View\Engines\CompilerEngine::handleViewException() should be compatible with Illuminate\View\Eng
编程之美-NIM游戏分析-石头总数为奇数时如何保证先动手者必胜 bylijinnan 编程之美
import java.util.Arrays; import java.util.Random; public class Nim { /**编程之美 NIM游戏分析问题：有N块石头和两个玩家A和B，玩家A先将石头随机分成若干堆，然后按照BABA...的顺序不断轮流取石头，能将剩下的石头一次取光的玩家获胜，每次取石头时，每个玩家只能从若干堆石头中任选一堆，
lunce创建索引及简单查询 chengxuyuancsdn 查询创建索引 lunce
import java.io.File; import java.io.IOException; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.document.Docume
[IT与投资]坚持独立自主的研究核心技术 comsci it
和别人合作开发某项产品....如果互相之间的技术水平不同,那么这种合作很难进行,一般都会成为强者控制弱者的方法和手段..... 所以弱者,在遇到技术难题的时候,最好不要一开始就去寻求强者的帮助,因为在我们这颗星球上,生物都有一种控制其
flashback transaction闪回事务查询 daizj oracle sql 闪回事务
闪回事务查询有别于闪回查询的特点有以下3个：（1）其正常工作不但需要利用撤销数据，还需要事先启用最小补充日志。（2）返回的结果不是以前的“旧”数据，而是能够将当前数据修改为以前的样子的撤销SQL（Undo SQL）语句。（3）集中地在名为flashback_transaction_query表上查询，而不是在各个表上通过“as of”或“vers
Java I/O之FilenameFilter类列举出指定路径下某个扩展名的文件游其是你 FilenameFilter
这是一个FilenameFilter类用法的例子，实现的列举出“c:\\folder“路径下所有以“.jpg”扩展名的文件。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
C语言学习五函数，函数的前置声明以及如何在软件开发中合理的设计函数来解决实际问题 dcj3sjt126com c
# include <stdio.h> int f(void) //括号中的void表示该函数不能接受数据，int表示返回的类型为int类型 { return 10; //向主调函数返回10 } void g(void) //函数名前面的void表示该函数没有返回值 { //return 10; //error 与第8行行首的void相矛盾 } in
今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Pl dcj3sjt126com centos
今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Please verify its path and try again 处理很简单，修改文件“/etc/yum.repos.d/epel.repo”，将baseurl的注释取消， mirrorlist注释掉。即可。 &n
单例模式 shuizhaosi888 单例模式
单例模式懒汉式 public class RunMain { /** * 私有构造 */ private RunMain() { } /** * 内部类，用于占位，只有 */ private static class SingletonRunMain { priv
Spring Security（09）——Filter 234390216 Spring Security
Filter 目录 1.1 Filter顺序 1.2 添加Filter到FilterChain 1.3 DelegatingFilterProxy 1.4 FilterChainProxy 1.5
公司项目NODEJS实践0.1 逐行分析JS源代码 mongodb nginx ubuntu nodejs
一、前言前端如何独立用nodeJs实现一个简单的注册、登录功能，是不是只用nodejs+sql就可以了？其实是可以实现，但离实际应用还有距离，那要怎么做才是实际可用的。网上有很多nod
java.lang.Math liuhaibo_ljf java Math lang
System.out.println(Math.PI); System.out.println(Math.abs(1.2)); System.out.println(Math.abs(1.2)); System.out.println(Math.abs(1)); System.out.println(Math.abs(111111111)); System.out.println(Mat
linux下时间同步 nonobaba ntp
今天在linux下做hbase集群的时候，发现hmaster启动成功了，但是用hbase命令进入shell的时候报了一个错误 PleaseHoldException: Master is initializing，查看了日志，大致意思是说master和slave时间不同步，没办法，只好找一种手动同步一下，后来发现一共部署了10来台机器，手动同步偏差又比较大，所以还是从网上找现成的解决方
ZooKeeper3.4.6的集群部署 roadrunners zookeeper 集群部署
ZooKeeper是Apache的一个开源项目，在分布式服务中应用比较广泛。它主要用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步、集群管理、配置文件管理、同步锁、队列等。这里主要讲集群中ZooKeeper的部署。 1、准备工作我们准备3台机器做ZooKeeper集群，分别在3台机器上创建ZooKeeper需要的目录。数据存储目录
Java高效读取大文件 tomcat_oracle java
　　读取文件行的标准方式是在内存中读取，Guava 和Apache Commons IO都提供了如下所示快速读取文件行的方法：　　Files.readLines(new File(path), Charsets.UTF_8); 　　FileUtils.readLines(new File(path)); 　　这种方法带来的问题是文件的所有行都被存放在内存中，当文件足够大时很快就会导致
微信支付api返回的xml转换为Map的方法 xu3508620 xml map 微信api
举例如下： <xml> <return_code><![CDATA[SUCCESS]]></return_code> <return_msg><![CDATA[OK]]></return_msg> <appid><