#first commit

Author: 657122411

src/com/blankj/easy/_004/No04.java

@@ -0,0 +1,38 @@
+package com.blankj.easy._004;
+
+public class No04 {
+    public static void main(String[] args) {
+        String str = "We are happy";
+        char[] charArray = str.toCharArray();
+        System.out.println(change(charArray));
+    }
+
+    private static String change(char[] charArray) {
+        int n = charArray.length;
+        int count = 0;
+        for (int i = 0; i < charArray.length; i++) {
+            if (charArray[i] == ' ') {
+                count++;
+            }
+        }
+        if (count == 0) {
+            return null;
+        }
+        char[] temp = new char[n + 2 * count];
+        int j = n + 2 * count - 1;
+        int i = n - 1;
+        while (i >= 0) {
+            if (charArray[i] == ' ') {
+                temp[j] = '0';
+                temp[j - 1] = '2';
+                temp[j - 2] = '%';
+                j = j - 3;
+            } else {
+                temp[j] = charArray[i];
+                j--;
+            }
+            i--;
+        }
+        return new String(temp);
+    }
+}

src/com/blankj/easy/_005/No05.java

@@ -0,0 +1,46 @@
+package com.blankj.easy._005;
+
+import com.blankj.study.base.Node;
+
+public class No05 {
+    public static void main(String[] args) {
+        Node node1 = new Node("A");
+        Node node2 = new Node("B");
+        Node node3 = new Node("C");
+        Node node4 = new Node("D");
+        Node node5 = new Node("E");
+        node1.setNext(node2);
+        node2.setNext(node3);
+        node3.setNext(node4);
+        node4.setNext(node5);
+        Node newNode = reverse2(node1);
+        while (newNode != null) {
+            System.out.print(newNode.getData() + " ");
+            newNode = newNode.getNext();
+        }
+    }
+
+    private static Node reverse(Node head) {
+        if (head.getNext() == null) {
+            return head;
+        }
+        Node reverseHead = reverse(head.getNext());
+        head.getNext().setNext(head);
+        head.setNext(null);
+        return reverseHead;
+    }
+
+    private static Node reverse2(Node head) {
+        Node pre = head;
+        Node cur = head.getNext();
+        Node temp;
+        while (cur != null) {
+            temp = cur.getNext();
+            cur.setNext(pre);
+            pre = cur;
+            cur = temp;
+        }
+        head.setNext(null);
+        return pre;
+    }
+}

src/com/blankj/easy/_006/No06.java

@@ -0,0 +1,42 @@
+package com.blankj.easy._006;
+
+
+import com.blankj.study.base.BinaryTreeNode;
+
+public class No06 {
+    private String midOrder;
+
+    public static void main(String[] args) {
+        String preOrder = "12473568";
+        String midOrder = "47215386";
+
+        BiTree tree = new BiTree(preOrder, midOrder, preOrder.length());
+        tree.postRootTraverse(tree.root);
+    }
+}
+
+class BiTree {
+    BinaryTreeNode root;
+
+    public BiTree(String preOrder, String midOrder, int count) {
+        if (count <= 0) {
+            return;
+        }
+        char c = preOrder.charAt(0);
+        int i = 0;
+        for (; i < count; i++) {
+            if (midOrder.charAt(i) == c) break;
+        }
+        root = new BinaryTreeNode(c);
+        root.setLchild(new BiTree(preOrder.substring(1, i + 1), midOrder.substring(0, i), i).root);
+        root.setRchild(new BiTree(preOrder.substring(i + 1), midOrder.substring(i + 1), count - i - 1).root);
+    }
+
+    public void postRootTraverse(BinaryTreeNode root) {
+        if (root != null) {
+            postRootTraverse(root.getLchild());
+            postRootTraverse(root.getRchild());
+            System.out.print(root.getData());
+        }
+    }
+}

src/com/blankj/study/base/BinaryTreeNode.java

@@ -0,0 +1,38 @@
+package com.blankj.study.base;
+
+public class BinaryTreeNode {
+    private int data;
+    private BinaryTreeNode LchildNode;
+    private BinaryTreeNode RchildNode;
+
+    public BinaryTreeNode(int data) {
+        super();
+        this.data = data;
+    }
+
+    public int getData() {
+        return this.data;
+    }
+
+    public void setData(int data) {
+        this.data = data;
+    }
+
+    public BinaryTreeNode getLchild() {
+        return LchildNode;
+    }
+
+    public void setLchild(BinaryTreeNode lchildNode) {
+        this.LchildNode = lchildNode;
+    }
+
+    public BinaryTreeNode getRchild() {
+        return RchildNode;
+    }
+
+    public void setRchild(BinaryTreeNode rchildNode) {
+        this.RchildNode = rchildNode;
+    }
+
+
+}

src/com/blankj/study/base/Node.java

@@ -0,0 +1,33 @@
+package com.blankj.study.base;
+
+public class Node {
+    private String data;
+    private Node next;
+
+    public Node(String data) {
+        super();
+        this.data = data;
+    }
+
+    public Node(String data, Node next) {
+        super();
+        this.data = data;
+        this.next = next;
+    }
+
+    public void setData(String data) {
+        this.data = data;
+    }
+
+    public String getData() {
+        return data;
+    }
+
+    public void setNext(Node next) {
+        this.next = next;
+    }
+
+    public Node getNext() {
+        return next;
+    }
+}

src/com/blankj/study/singleton/HungrySingleton.java

@@ -0,0 +1,15 @@
+package com.blankj.study.singleton;
+
+// 饿汉单例 线程安全
+public class HungrySingleton {
+    private HungrySingleton() {
+    }
+
+    ;
+
+    private static final HungrySingleton instance = new HungrySingleton();
+
+    public static HungrySingleton getInstance() {
+        return instance;
+    }
+}

src/com/blankj/study/singleton/InnerSingleton.java

@@ -0,0 +1,19 @@
+package com.blankj.study.singleton;
+
+
+//静态内部类单例
+public class InnerSingleton {
+    private InnerSingleton() {
+    }
+
+    ;
+
+    public static InnerSingleton getInstance() {
+        return SingletonHolder.instance;
+    }
+
+    private static class SingletonHolder {
+        private static final InnerSingleton instance = new InnerSingleton();
+    }
+
+}

src/com/blankj/study/singleton/LazySingleton.java

@@ -0,0 +1,22 @@
+package com.blankj.study.singleton;
+
+
+// 懒汉单例 线程安全
+public class LazySingleton {
+    private LazySingleton() {
+    }
+
+    ;
+
+    private static volatile LazySingleton instance = null;
+
+    public static LazySingleton getInstance() {
+        if (instance == null) {
+            synchronized (LazySingleton.class) {
+                if (instance == null)
+                    instance = new LazySingleton();
+            }
+        }
+        return instance;
+    }
+}