练习

src/leo/class02/BiggerThanRightTwice.java

@@ -0,0 +1,212 @@
+package leo.class02;
+
+import java.util.function.IntPredicate;
+
+/**
+ * @author Leo
+ * @ClassName BiggerThanRightTwice
+ * @DATE 2020/11/24 2:10 下午
+ * @Description 对于每个数num，求有多少个后面的数 * 2 依然<左面的数，求总个数
+ */
+class BiggerThanRightTwice {
+
+    public static int biggerTwice(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+        if (l == r) {
+            return 0;
+        }
+        int mid = l + ((r - l) >> 1);
+        return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+        int res = 0;
+        int R = m;
+        for (int i = l; i <= m; i++) {
+            while (R + 1 <= r && arr[i] > (arr[R + 1] << 1)) {
+                R++;
+            }
+            res += R - m;
+        }
+        int[] help = new int[r - l + 1];
+        int i = 0;
+        int p1 = l;
+        int p2 = m + 1;
+        while (p1 <= m && p2 <= r) {
+            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
+        }
+        while (p1 <= m) {
+            help[i++] = arr[p1++];
+        }
+        while (p2 <= r) {
+            help[i++] = arr[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+
+        return res;
+
+
+    }
+
+}
+
+class BiggerThanRightTwice1 {
+
+    public static int biggerTwice(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int  process(int[] arr, int l, int r) {
+        if (l == r) {
+            return 0;
+        }
+        int mid = l + ((r - l) >> 1);
+        return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+        int res = 0;
+        int windowR = m + 1;
+        for (int i = l; i <= m; i++) {
+            while (windowR <= r && arr[i] > (arr[windowR] << 1)) {
+                windowR++;
+            }
+            res += windowR - m - 1;
+        }
+        int[] help = new int[r - l + 1];
+        int p1 = l;
+        int p2 = m + 1;
+        int i = 0;
+        while (p1 <= m && p2 <= r) {
+            help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
+        }
+        while(p1<=m){
+            help[i++] = arr[p1++];
+        }
+        while (p2 <= r) {
+            help[i++] = arr[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return res;
+    }
+}
+
+class BiggerThanRightTwice2 {
+    public static int biggerTwice(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+        if (l==r){
+            return 0;
+        }
+        int m = l + ((r - l) >> 1);
+        return process(arr, l, m) + process(arr, m + 1, r) + merge(arr, l, m, r);
+
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+
+        int windowR = m + 1;
+        int res = 0;
+        for (int i = l; i <= m; i++) {
+            while (windowR <= r && arr[i] > (arr[windowR]) << 1) {
+                windowR++;
+            }
+            res += windowR - m - 1;
+        }
+        int[] help = new int[r - l + 1];
+        int i = 0;
+        int p1 = l;
+        int p2 = m + 1;
+        while (p1 <= m && p2 <= r) {
+            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
+        }
+        while (p1 <= m) {
+            help[i++] = arr[p1++];
+        }
+        while (p2 <= r) {
+            help[i++] = arr[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return res;
+    }
+
+
+
+}
+
+
+class TestBiggerThanRightTwice {
+    public static int biggerTwice(int[] arr) {
+        int res = 0;
+
+        for (int i = 0; i < arr.length; i++) {
+            for (int j = i + 1; j < arr.length; j++) {
+                if (arr[i] > arr[j] << 1) {
+                    res++;
+                }
+            }
+        }
+        return res;
+    }
+}
+
+class Main{
+    public static void main(String[] args){
+        int testTime = 1000;
+        int sizeMax = 10;
+        int range = 60;
+        System.out.println("start");
+        for (int i = 0; i < testTime; i++) {
+            int[] arr = generateRandomArray(sizeMax, range);
+            int[] copyArray = copyArray(arr);
+            int res = BiggerThanRightTwice2.biggerTwice(arr);
+            int res1 = TestBiggerThanRightTwice.biggerTwice(copyArray);
+            if (res != res1) {
+                System.out.println("res : " + res + " " + " res1: " + res1);
+                return;
+            }
+
+        }
+        System.out.println("end");
+
+
+
+
+    }
+
+    public static int[] generateRandomArray(int sizeMax, int range) {
+        int[] arr = new int[(int) (sizeMax * Math.random() + 1)];
+        for (int i = 0; i < arr.length; i++) {
+            arr[i] = (int) ((range * Math.random() - 1) - (range * Math.random() - 1));
+        }
+        return arr;
+    }
+
+    public static int[] copyArray(int[] arr) {
+        int[] copyArr = new int[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            copyArr[i] = arr[i];
+        }
+        return copyArr;
+    }
+}

src/leo/class02/DeleteGivenValue.java

@@ -126,6 +126,27 @@ public class DeleteGivenValue {
         return head;
     }
 
+    public static Node removeNodeOfValue4(Node head, int value) {
+        while (head != null) {
+            if (head.value != value) {
+                break;
+            }
+            head = head.next;
+        }
+        Node pre = head;
+        Node cur = head;
+        while (cur != null) {
+            if (cur.value == value) {
+                pre.next = cur.next;
+            }else{
+                pre = cur;
+            }
+            cur = cur.next;
+        }
+        return head;
+
+    }
+
     /**
      * 功能描述 : 双链表删除某个给定值
      * @author Leo
@@ -293,6 +314,31 @@ public class DeleteGivenValue {
         return head;
     }
 
+    public static DoubleNode removeDoubleNodeOfValue6(DoubleNode head, int value) {
+        while (head != null) {
+            if (head.value != value) {
+                head.pre = null;
+                break;
+            }
+            head = head.next;
+        }
+        DoubleNode pre = head;
+        DoubleNode cur = head;
+        while (cur != null) {
+            if (cur.value == value) {
+                pre.next = cur.next;
+                cur.pre = null;
+                if (cur.next != null) {
+                    pre.next.pre = pre;
+                }
+            }else{
+                pre = cur;
+            }
+            cur = cur.next;
+        }
+        return head;
+    }
+
     /**
      * 功能描述 : 验证单链表删除结果
      * @author Leo
@@ -392,21 +438,21 @@ public class DeleteGivenValue {
 
 
     public static void main(String[] args) {
-        int sizeMax = 40;
+        int sizeMax = 80;
         int range = 80;
         int testTime = 10000;
         System.out.println("测试开始");
         for (int i = 0; i < testTime; i++) {
             int value = randomInt(range);
             Node nodeHead = randomNode(sizeMax, range);
-            Node node = removeNodeOfValue3(nodeHead, value);
+            Node node = removeNodeOfValue4(nodeHead, value);
 
             if (!verifyRemoveNodeOfValue(node,value)) {
                 System.out.println("node fuck!");
                 break;
             }
             DoubleNode doubleNodeHead = randomDoubleNode(sizeMax, range);
-            DoubleNode doubleNode = removeDoubleNodeOfValue5(doubleNodeHead, value);
+            DoubleNode doubleNode = removeDoubleNodeOfValue6(doubleNodeHead, value);
             if (!verifyRemoveDoubleNodeOfValue(doubleNode, value)) {
                 System.out.println("doubleNode fuck");
                 break;

src/leo/class02/GetMax.java

@@ -22,7 +22,7 @@ public class GetMax {
             return arr[L];
         }
         int mid = L + ((R - L) >> 1);
-        int leftMax = process(arr, 0, mid);
+        int leftMax = process(arr, L, mid);
         int rightMax = process(arr, mid + 1, R);
         return Math.max(leftMax, rightMax);
     }

src/leo/class02/ReversePair.java

@@ -0,0 +1,251 @@
+package leo.class02;
+
+import leo.util.ArrayUtil;
+
+/**
+ * @author Leo
+ * @ClassName ReversePair
+ * @DATE 2020/11/23 9:48 下午
+ * @Description 在一段数组中 返回有多少逆序对
+ * 合并的时候 两侧下标--
+ */
+public class ReversePair {
+
+    public static int reversePairNumber(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+
+        if (l == r) {
+            return 0;
+        }
+        int mid = l + ((r - l) >> 1);
+        return process(arr, 0, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+        int[] help = new int[r - l + 1];
+        int i = help.length - 1;
+        int p1 = m;
+        int p2 = r;
+        int res = 0;
+        while (p1 >= l && p2 > m) {
+            res += arr[p1] > arr[p2] ? (p2 - m) : 0;
+            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
+        }
+        while (p1 >= l) {
+            help[i--] = arr[p1--];
+        }
+        while (p2 > m) {
+            help[i--] = arr[p2--];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return res;
+    }
+}
+
+class ReversePair1{
+
+    public static int reversePairNumber(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+
+        if (l == r) {
+            return 0;
+        }
+        int mid = l + ((r - l) >> 1);
+        return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+
+        int[] help = new int[r - l + 1];
+        int i = help.length - 1;
+        int p1 = m;
+        int p2 = r;
+        int res = 0;
+        while (p1 >= l && p2 > m) {
+            res += arr[p1] > arr[p2] ? (p2 - m) : 0;
+            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
+        }
+        while (p1 >= l) {
+            help[i--] = arr[p1--];
+        }
+
+        while(p2>m){
+            help[i--] = arr[p2--];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return res;
+    }
+
+}
+
+class ReversePair2{
+
+    public static int reversePairNumber(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+        if (l == r) {
+            return 0;
+        }
+        int mid = l + ((r - l) >> 1);
+        return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+        int res = 0;
+        int[] help = new int[r - l + 1];
+        int p1 = m;
+        int p2 = r;
+        int i = help.length - 1;
+        while (p1 >= l && p2 > m) {
+            res += arr[p1] > arr[p2] ? (p2 - m) : 0;
+            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
+        }
+        while (p1 >= l) {
+            help[i--] = arr[p1--];
+        }
+        while (p2 > m) {
+            help[i--] = arr[p2--];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return res;
+    }
+
+}
+
+class ReversePair3 {
+
+    public static int reversePairNumber(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+
+
+        if(l==r){
+            return 0;
+        }
+        int m = l + ((r - l) >> 1);
+        return process(arr, l, m) + process(arr, m + 1, r) + merge(arr, l, m, r);
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+
+        int p1 = m;
+        int p2 = r;
+        int[] help = new int[r - l + 1];
+        int i = help.length - 1;
+        int res = 0;
+        while (p1 >= l && p2 > m) {
+            res += arr[p1] > arr[p2] ? p2 - m : 0;
+            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
+        }
+        while (p1 >= l) {
+            help[i--] = arr[p1--];
+        }
+        while(p2>m){
+            help[i--] = arr[p2--];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return res;
+    }
+}
+
+class TestReversePair{
+    public static int reversePairNumber(int[] arr) {
+        int res = 0;
+        for (int i = arr.length-2; i >=0 ; i--) {
+            for (int j = arr.length-1; j >i  ; j--) {
+                if (arr[i] > arr[j]) {
+                    res += 1;
+                }
+            }
+        }
+
+        for (int i = 1; i < arr.length; i++) {
+            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
+                swap(arr, j, j + 1);
+            }
+        }
+        return res;
+    }
+
+    private static void swap(int[] arr, int i, int j) {
+        if (i == j || arr[i] == arr[j]) {
+            return;
+        }
+        arr[i] = arr[i] ^ arr[j];
+        arr[j] = arr[i] ^ arr[j];
+        arr[i] = arr[i] ^ arr[j];
+    }
+
+
+    public static void main(String[] args){
+        int testTime = 1000;
+        int sizeMax = 30;
+        int range = 50;
+        System.out.println("start!");
+
+        for (int i = 0; i < testTime; i++) {
+            int[] arr = randomArray(sizeMax, range);
+            int[] copyArr = copyArray(arr);
+            int num = ReversePair3.reversePairNumber(arr);
+            int copyNum = reversePairNumber(copyArr);
+            if (num != copyNum) {
+                System.out.println("num : "+num);
+                System.out.println("copyNum : "+copyNum);
+                return;
+            }
+            if (!ArrayUtil.isEqual(arr, copyArr)) {
+                System.out.println("arr fuck!!");
+                return;
+            }
+        }
+        System.out.println("end!");
+
+    }
+
+    private static int[] copyArray(int[] arr) {
+        int[] copyArr = new int[arr.length];
+        for (int i = 0; i < copyArr.length; i++) {
+            copyArr[i] = arr[i];
+        }
+        return copyArr;
+    }
+
+    private static int[] randomArray(int sizeMax, int range) {
+        int[] arr = new int[(int) (sizeMax * Math.random() + 1)];
+        for (int i = 0; i < arr.length; i++) {
+            arr[i] = (int) ((range * Math.random() + 1) - (range * Math.random() + 1));
+        }
+        return arr;
+    }
+
+}

src/leo/class02/RingArray.java

@@ -56,7 +56,6 @@ public class RingArray {
 
     }
 
-
     public static class MyQueue1{
         private int[] arr;
         private int size;
@@ -141,13 +140,56 @@ public class RingArray {
         }
     }
 
+    public static class MyQueue3{
+        private int[] arr;
+        private int push;
+        private int pop;
+        private int size;
+        private final int limit;
+
+        public MyQueue3(int limit) {
+            this.arr = new int[limit];
+            this.push = 0;
+            this.pop = 0;
+            this.size = 0;
+            this.limit = limit;
+        }
+
+        public void push(int value) {
+            if (size == limit) {
+                throw new RuntimeException("stack is full");
+            }
+            this.arr[push] = value;
+            this.size++;
+            this.push = nextIndex(push);
+        }
+
+        public int poll() {
+            if (size == 0) {
+                throw new RuntimeException("stack is empty");
+            }
+            int value = this.arr[pop];
+            this.size--;
+            this.pop = nextIndex(pop);
+            return value;
+        }
+
+        private int nextIndex(int i) {
+            return i < limit-1 ? i + 1 : 0;
+        }
+
+        public boolean isEmpty() {
+            return size == 0;
+        }
+    }
+
     public static void main(String[] args) {
         int testTime = 10000;
         int range = 100;
         int sizeMax = 80;
         for (int i = 0; i < testTime; i++) {
             int length = randomInt(sizeMax);
-            MyQueue2 myQueue = new MyQueue2(length);
+            MyQueue3 myQueue = new MyQueue3(length);
             Queue<Integer> queue = new LinkedList<>();
             for (int j = 0; j < length; j++) {
                 int value = randomInt(range);

src/leo/class02/SmallSum.java

@@ -7,6 +7,7 @@ import leo.util.ArrayUtil;
  * @ClassName SmallSum
  * @DATE 2020/11/23 10:46 上午
  * @Description 小和问题
+ * 在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个数组的小和
  */
 class SmallSum {
 
@@ -104,6 +105,132 @@ class SmallSum1{
 
 }
 
+class SmallSum2 {
+
+    public static int smallSum(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+        if (l == r) {
+            return 0;
+        }
+        int mid = l + ((r - l) >> 1);
+        return process(arr, l, mid) +
+                process(arr, mid + 1, r) +
+                merge(arr, l, mid, r);
+
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+        int res = 0;
+        int p1 = l;
+        int p2 = m + 1;
+        int i = 0;
+        int[] help = new int[r - l + 1];
+        while (p1 <= m && p2 <= r) {
+            res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
+            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
+        }
+        while(p1<=m){
+            help[i++] = arr[p1++];
+        }
+        while(p2<=r){
+            help[i++] = arr[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+
+        return res;
+    }
+
+}
+
+class SmallSum3{
+    public static int smallSum(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+        if (l == r) {
+            return 0;
+        }
+        int mid = l + ((r - l) >> 1);
+        return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
+    }
+
+
+    private static int merge(int[] arr, int l, int m, int r) {
+        int i = 0;
+        int[] help = new int[r - l + 1];
+        int p1 = l;
+        int p2 = m + 1;
+        int sum = 0;
+        while (p1 <= m && p2 <= r) {
+            sum += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
+            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
+        }
+        while (p1 <= m) {
+            help[i++] = arr[p1++];
+        }
+        while (p2 <= r) {
+            help[i++] = arr[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return sum;
+    }
+}
+
+class SmallSum4{
+
+    public static int smallSum(int[] arr) {
+        if (arr.length < 2 || arr == null) {
+            return 0;
+        }
+        return process(arr, 0, arr.length - 1);
+    }
+
+    private static int process(int[] arr, int l, int r) {
+
+        if (l == r) {
+            return 0;
+        }
+        int m = l + ((r - l) >> 1);
+        return process(arr, l, m) + process(arr, m + 1, r)+merge(arr,l,m,r);
+    }
+
+    private static int merge(int[] arr, int l, int m, int r) {
+        int sum = 0;
+        int[] help = new int[r - l + 1];
+        int p1 = l;
+        int p2 = m + 1;
+        int i = 0;
+        while (p1 <= m && p2 <= r) {
+            sum += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
+            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
+        }
+        while (p1 <= m) {
+            help[i++] = arr[p1++];
+        }
+        while (p2 <= r) {
+            help[i++] = arr[p2++];
+        }
+        for (i = 0; i < help.length; i++) {
+            arr[l + i] = help[i];
+        }
+        return sum;
+    }
+}
+
 class TestSmallSum{
     public static int smallSum(int[] arr) {
         if (arr.length < 2 || arr == null) {
@@ -147,7 +274,7 @@ class TestMain {
         for (int i = 0; i < testTime; i++) {
             int[] arr = ArrayUtil.randomArray(maxSize, range);
             int[] copyArray = ArrayUtil.copyArray(arr);
-            int sum = SmallSum1.smallSum(arr);
+            int sum = SmallSum4.smallSum(arr);
             int testSum = TestSmallSum.smallSum(copyArray);
             if (testSum != sum) {
                 System.out.println("sum :" + sum + ", testSum : " + testSum);

src/leo/class02/StackAndQueue.java

@@ -12,26 +12,27 @@ import java.util.Stack;
  */
 public class StackAndQueue {
 
-    /**
-     * @ClassName : DoubleNode
-     * @author Leo
-     * @date 2020/11/20 11:09 上午
-     */
-    public static class DoubleNode<T>{
-        T value;
-        DoubleNode pre;
-        DoubleNode next;
-        public DoubleNode(T value) {
-            this.value = value;
-        }
 
 
+    public static class DoubleNodeQueue<T> {
+        /**
+         * @ClassName : DoubleNode
+         * @author Leo
+         * @date 2020/11/20 11:09 上午
+         */
+        public static class DoubleNode<T>{
+            T value;
+            DoubleNode pre;
+            DoubleNode next;
+            public DoubleNode(T value) {
+                this.value = value;
+            }
+
 
 
 
-    }
 
-    public static class DoubleNodeQueue<T> {
+        }
         DoubleNode<T> head;
         DoubleNode<T> tail;
 
@@ -123,6 +124,24 @@ public class StackAndQueue {
     }
 
     public static class DoubleNodeQueue1<T> {
+        /**
+         * @ClassName : DoubleNode
+         * @author Leo
+         * @date 2020/11/20 11:09 上午
+         */
+        public static class DoubleNode<T>{
+            T value;
+            DoubleNode pre;
+            DoubleNode next;
+            public DoubleNode(T value) {
+                this.value = value;
+            }
+
+
+
+
+
+        }
 
         DoubleNode<T> head;
         DoubleNode<T> tail;
@@ -190,6 +209,168 @@ public class StackAndQueue {
         }
     }
 
+    public static class DoubleNodeQueue2<T> {
+        /**
+         * @ClassName : DoubleNode
+         * @author Leo
+         * @date 2020/11/20 11:09 上午
+         */
+        public static class DoubleNode<T>{
+            T value;
+            DoubleNode pre;
+            DoubleNode next;
+            public DoubleNode(T value) {
+                this.value = value;
+            }
+
+
+
+
+
+        }
+        DoubleNode<T> head;
+        DoubleNode<T> tail;
+
+        public void pushHead(T value) {
+            DoubleNode<T> node = new DoubleNode<>(value);
+            if (head == null) {
+                head = node;
+                tail = node;
+            }else{
+                head.pre = node;
+                node.next = head;
+                head = node;
+            }
+        }
+
+        public void pushTail(T value) {
+            DoubleNode<T> node = new DoubleNode<>(value);
+            if (tail == null) {
+                head = node;
+                tail = node;
+            } else {
+                tail.next = node;
+                node.pre = tail;
+                tail = node;
+            }
+        }
+
+        public T popHead() {
+            if (head == null) {
+                return null;
+            }
+            T value = head.value;
+
+            if (head.next == null) {
+                head = null;
+                tail = null;
+            }else{
+                head = head.next;
+                head.pre = null;
+            }
+
+            return value;
+        }
+
+        public T popTail() {
+            if (tail == null) {
+                return null;
+            }
+            T value = tail.value;
+            if (tail.pre == null) {
+                head = null;
+                tail = null;
+            }else{
+                tail = tail.pre;
+                tail.next = null;
+            }
+
+            return value;
+        }
+
+        public boolean isEmpty() {
+            return head == null;
+        }
+
+
+    }
+
+    public static class DoubleNodeStackAndQueue<T>{
+        private static class DoubleNode<T>{
+            T value;
+            DoubleNode pre;
+            DoubleNode next;
+
+            public DoubleNode(T value) {
+                this.value = value;
+            }
+        }
+
+        private DoubleNode<T> head;
+        private DoubleNode<T> tail;
+
+        public void pushHead(T value) {
+            DoubleNode<T> node = new DoubleNode<T>(value);
+            if (this.head == null) {
+                this.head = node;
+                this.tail = node;
+            }else{
+                node.next = this.head;
+                this.head.pre = node;
+                this.head = node ;
+            }
+        }
+
+        public void pushTail(T value) {
+            DoubleNode<T> node = new DoubleNode<T>(value);
+            if (this.tail == null) {
+                tail = node;
+                head = node;
+            }else{
+                tail.next = node;
+                node.pre = tail;
+                tail = node;
+            }
+        }
+
+        public T popHead(){
+            if (this.head == null) {
+                return null;
+            }
+            T value = this.head.value;
+            if (this.head.next != null) {
+                this.head = this.head.next;
+                this.head.pre = null;
+            }else{
+                this.head = null;
+                this.tail = null;
+            }
+            return value;
+        }
+
+        public T popTail() {
+            if (this.tail == null) {
+                return null;
+            }
+            T value = this.tail.value;
+            if (this.tail.pre != null) {
+                this.tail = this.tail.pre;
+                this.tail.next.pre = null;
+                this.tail.next = null;
+            }else{
+                this.tail = null;
+                this.head = null;
+            }
+            return value;
+        }
+
+        public boolean isEmpty() {
+            return this.head == null;
+        }
+
+    }
+
+
 
     /**
      * @author Leo
@@ -259,6 +440,79 @@ public class StackAndQueue {
 
     }
 
+    public static class MyStack2<T> {
+        DoubleNodeQueue2<T> stack;
+        public MyStack2() {
+            this.stack = new DoubleNodeQueue2<>();
+        }
+
+        public void push(T value) {
+            this.stack.pushHead(value);
+        }
+
+        public T pop() {
+            return stack.popHead();
+        }
+
+        public boolean isEmpty() {
+            return this.stack.isEmpty();
+        }
+
+    }
+
+    public static class MyStack3<T>{
+        private DoubleNodeStackAndQueue<T> myStack;
+
+        public MyStack3() {
+            this.myStack = new DoubleNodeStackAndQueue<>();
+        }
+
+        public void push(T value) {
+            this.myStack.popHead();
+        }
+
+        public T pop() {
+            return this.myStack.popHead();
+        }
+
+        public boolean isEmpty() {
+            return this.myStack.isEmpty();
+        }
+    }
+
+
+
+
+
+
+
+    /**
+     * @author Leo
+     * @ClassName MyQueue
+     * @DATE 2020/11/20 11:05 上午
+     * @Description 队列 先进先出
+     */
+    public static class MyQueue<T>{
+
+        DoubleNodeQueue<T> myQueue;
+
+        public MyQueue() {
+            this.myQueue = new DoubleNodeQueue<>();
+        }
+
+        public void push(T value) {
+            myQueue.addHead(value);
+        }
+
+        public T poll() {
+            return myQueue.popTail();
+        }
+
+        public boolean isEmpty() {
+            return myQueue.isEmpty();
+        }
+
+    }
 
     /**
      * 队列 先进先出
@@ -292,36 +546,49 @@ public class StackAndQueue {
 
     }
 
+    public static class MyQueue2<T> {
+        private DoubleNodeQueue2<T> queue;
 
+        public MyQueue2() {
+            this.queue = new DoubleNodeQueue2<T>();
+        }
 
-    /**
-     * @author Leo
-     * @ClassName MyQueue
-     * @DATE 2020/11/20 11:05 上午
-     * @Description 队列 先进先出
-     */
-    public static class MyQueue<T>{
+        public void push(T value) {
+            this.queue.pushHead(value);
+        }
 
-        DoubleNodeQueue<T> myQueue;
+        public T poll() {
+            return this.queue.popTail();
+        }
 
-        public MyQueue() {
-            this.myQueue = new DoubleNodeQueue<>();
+        public boolean isEmpty() {
+            return this.queue.isEmpty();
+        }
+
+    }
+
+    public static class MyQueue3<T> {
+        private DoubleNodeStackAndQueue<T> myQueue;
+
+        public MyQueue3() {
+            this.myQueue = new DoubleNodeStackAndQueue<>();
         }
 
         public void push(T value) {
-            myQueue.addHead(value);
+            this.myQueue.popHead();
         }
 
         public T poll() {
-            return myQueue.popTail();
+            return this.myQueue.popTail();
         }
 
         public boolean isEmpty() {
-            return myQueue.isEmpty();
+            return this.myQueue.isEmpty();
         }
-
     }
 
+
+
     public static boolean isEqual(Integer o1, Integer o2) {
         if (o1 == null && o2 != null) {
             return false;
@@ -336,12 +603,12 @@ public class StackAndQueue {
     }
 
     public static void main(String[] args){
-        int testTime = 10000;
-        int forTime = 100000;
+        int testTime = 1000;
+        int forTime = 1000;
         int range = 8000;
         for (int i = 0; i < forTime; i++) {
-            MyStack1<Integer> myStack = new MyStack1<>();
-            MyQueue1<Integer> myQueue = new MyQueue1<>();
+            MyStack3<Integer> myStack = new MyStack3<>();
+            MyQueue3<Integer> myQueue = new MyQueue3<>();
             Stack<Integer> stack = new Stack<>();
             Queue<Integer> queue = new LinkedList<>();
             for (int j = 0; j < testTime; j++) {

src/leo/class02/TwoQueueImplementStack.java

@@ -61,10 +61,53 @@ public class TwoQueueImplementStack {
         }
     }
 
+    public static class MyStack1<T>{
+        private Queue<T> queue;
+        private Queue<T> help;
+
+        public MyStack1() {
+            queue = new LinkedList<T>();
+            help = new LinkedList<T>();
+        }
+
+        public void push(T value) {
+            this.queue.offer(value);
+        }
+
+        public T pop() {
+            while (queue.size() > 1) {
+                help.offer(queue.poll());
+            }
+            T value = queue.poll();
+            Queue<T> temp = queue;
+            queue = help;
+            help = temp;
+            return value;
+        }
+
+        public T peek(){
+            while (queue.size() > 1) {
+                help.offer(queue.poll());
+            }
+            T value = queue.poll();
+            this.help.offer(value);
+            Queue<T> temp = queue;
+            queue = help;
+            help = temp;
+            return value;
+        }
+
+        public boolean isEmpty() {
+            return this.queue.size() == 0;
+        }
+
+
+    }
+
     public static void main(String[] args){
-        int testTime = 10000;
+        int testTime = 1000;
         int range = 500;
-        MyStack<Integer> myStack = new MyStack<>();
+        MyStack1<Integer> myStack = new MyStack1<>();
         Stack<Integer> stack = new Stack<>();
         System.out.println("Start!");
         for (int i = 0; i < testTime; i++) {

src/leo/class02/TwoStacksImplementQueue.java

@@ -9,6 +9,8 @@ import java.util.Stack;
  * @ClassName TwoStacksImplementQueue
  * @DATE 2020/11/21 12:09 下午
  * @Description 使用栈数据结构实现队列
+ * 队列 先进先出
+ * 栈 先进后出
  */
 public class TwoStacksImplementQueue {