数据结构和算法-栈

chenweijie · chenweijie · commit 9c69823c301c · 2019-03-06T01:21:27.000+08:00
diff --git a/src/main/java/com/chen/algorithm/sort/InsertSort.java b/src/main/java/com/chen/algorithm/sort/InsertSort.java
@@ -0,0 +1,50 @@
+package com.chen.algorithm.sort;
+
+/**
+ * @author :  chen weijie
+ * @Date: 2019-03-01 12:35 AM
+ */
+public class InsertSort {
+
+
+    public static int[] sort(int[] array) {
+
+        int j;
+        //从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
+        for (int i = 1; i < array.length; i++) {
+            //记录要插入的数据
+            int temp = array[i];
+            j = i;
+            //从已经排序的序列最右边的开始比较，找到比其小的数
+            while (j > 0 && temp < array[j - 1]) {
+                //向后挪动
+                array[j] = array[j - 1];
+                j--;
+            }
+            //存在比其小的数，插入
+            array[j] = temp;
+        }
+        return array;
+    }
+
+    //遍历显示数组
+    public static void display(int[] array) {
+        for (int i = 0; i < array.length; i++) {
+            System.out.print(array[i] + " ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        int[] array = {4, 2, 8, 9, 5, 7, 6, 1, 3};
+        //未排序数组顺序为
+        System.out.println("未排序数组顺序为：");
+        display(array);
+        System.out.println("-----------------------");
+        array = sort(array);
+        System.out.println("-----------------------");
+        System.out.println("经过插入排序后的数组顺序为：");
+        display(array);
+    }
+
+}
diff --git a/src/main/java/com/chen/dataStructure/stack/ArrayStack.java b/src/main/java/com/chen/dataStructure/stack/ArrayStack.java
@@ -0,0 +1,121 @@
+package com.chen.dataStructure.stack;
+
+import java.util.Arrays;
+
+/**
+ * @author :  chen weijie
+ * @Date: 2019-03-06 12:31 AM
+ */
+public class ArrayStack {
+
+
+    /**
+     * object类型的数组可以存储任意类型
+     */
+    private Object[] elementData;
+
+    /**
+     * 指向栈顶的指针
+     */
+    private int top;
+
+    /**
+     * 栈的容量
+     */
+    private int size;
+
+
+    public ArrayStack() {
+
+        this.elementData = new Object[10];
+        this.top = -1;
+        this.size = 10;
+    }
+
+    public ArrayStack(int initialCapacity) {
+
+        if (initialCapacity < 0) {
+            throw new IllegalArgumentException("栈的初始容量不得小于0：" + initialCapacity);
+        }
+        this.elementData = new Object[initialCapacity];
+        this.top = -1;
+        this.size = initialCapacity;
+    }
+
+
+    public Object push(Object value) {
+        isGrow(top + 1);
+        elementData[++top] = value;
+        return value;
+    }
+
+
+    public void remove(int top) {
+
+        //栈顶元素置为null
+        elementData[top] = null;
+        this.top--;
+    }
+
+
+    public boolean isEmpty() {
+        return top == -1;
+    }
+
+
+    public Object peek() {
+
+        if (top == -1) {
+            return null;
+        }
+        return elementData[top];
+
+    }
+
+
+    public Object pop() {
+        Object object = peek();
+        remove(top);
+        return object;
+    }
+
+
+    public boolean isGrow(int minCapacity) {
+
+        int oldCapacity = size;
+        //如果当前元素压入栈之后总容量大于前面定义的容量，则需要扩容
+        if (oldCapacity <= minCapacity) {
+            //定义扩大之后栈的总容量
+            int newCapacity = 0;
+            if ((oldCapacity << 1) - Integer.MAX_VALUE > 0) {
+                newCapacity = Integer.MAX_VALUE;
+            } else {
+                newCapacity = (oldCapacity << 1);//左移一位，相当于*2
+            }
+            this.size = newCapacity;
+            int[] newArray = new int[size];
+            elementData = Arrays.copyOf(elementData, size);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public static void main(String[] args) {
+
+        ArrayStack stack = new ArrayStack(3);
+        stack.push(1);
+        //System.out.println(stack.peek());
+        stack.push(2);
+        stack.push(3);
+        stack.push("abc");
+        System.out.println(stack.peek());
+        stack.pop();
+        stack.pop();
+        stack.pop();
+        System.out.println(stack.peek());
+
+    }
+
+
+}
diff --git a/src/main/java/com/chen/dataStructure/stack/MyStack.java b/src/main/java/com/chen/dataStructure/stack/MyStack.java
@@ -0,0 +1,102 @@
+package com.chen.dataStructure.stack;
+
+/**
+ * @author :  chen weijie
+ * @Date: 2019-03-05 11:47 PM
+ */
+public class MyStack {
+
+
+    /**
+     * 栈的实际元素
+     */
+    private int[] array;
+
+    /**
+     * 指向栈顶的指针
+     */
+    private int top;
+
+    /**
+     * 栈的容量
+     */
+    private int maxSize;
+
+
+    public MyStack(int size) {
+        this.maxSize = size;
+        array = new int[size];
+        top = -1;
+    }
+
+
+    /**
+     * 插入元素
+     *
+     * @param value
+     */
+    public void push(int value) {
+        if (top < maxSize - 1) {
+            array[++top] = value;
+        }
+    }
+
+
+    /**
+     * 弹出元素
+     *
+     * @return
+     */
+    public int pop() {
+        return array[top--];
+    }
+
+
+    /**
+     * 访问栈顶元素
+     *
+     * @return
+     */
+    public int peep() {
+        return array[top];
+    }
+
+
+    /**
+     * 栈是否是空
+     *
+     * @return
+     */
+    public boolean isEmpty() {
+        return (top == -1);
+    }
+
+
+    /**
+     * @return
+     */
+    public boolean isFull() {
+        return (maxSize - 1) == top;
+    }
+
+
+    public static void main(String[] args) {
+
+        MyStack myStack = new MyStack(4);
+
+        myStack.push(10);
+        myStack.push(20);
+        myStack.push(1);
+        myStack.push(-1);
+
+        System.out.println("isFull:" + myStack.isFull());
+        System.out.println("peek:" + myStack.peep());
+
+        while (!myStack.isEmpty()) {
+            System.out.println("弹出：" + myStack.pop());
+            System.out.println("栈内元素个数：" + myStack.top);
+        }
+    }
+
+
+}
diff --git a/src/main/java/com/chen/dataStructure/stack/RevertString.java b/src/main/java/com/chen/dataStructure/stack/RevertString.java
@@ -0,0 +1,28 @@
+package com.chen.dataStructure.stack;
+
+/**
+ * 利用栈实现字符串逆序
+ *
+ * @author :  chen weijie
+ * @Date: 2019-03-06 12:59 AM
+ */
+public class RevertString {
+
+
+    public static void main(String[] args) {
+
+
+        String str = "how are you ";
+        char[] charArray = str.toCharArray();
+        ArrayStack myStack = new ArrayStack();
+        for (char c : charArray) {
+            myStack.push(c);
+        }
+
+        while (!myStack.isEmpty()) {
+            System.out.print(myStack.pop());
+        }
+
+    }
+
+}
diff --git a/src/main/java/com/chen/dataStructure/stack/TestMatch.java b/src/main/java/com/chen/dataStructure/stack/TestMatch.java
@@ -0,0 +1,60 @@
+package com.chen.dataStructure.stack;
+
+/**
+ * 利用栈判断分隔符是否匹配
+ * 比如：<abc[123]abc>这是符号相匹配的，如果是 <abc[123>abc] 那就是不匹配的。
+ * <p>
+ * 　对于 12<a[b{c}]>，我们分析在栈中的数据：遇到匹配正确的就消除
+ *
+ * @author :  chen weijie
+ * @Date: 2019-03-06 1:04 AM
+ */
+public class TestMatch {
+
+
+    //遇到左边分隔符了就push进栈，遇到右边分隔符了就pop出栈，看出栈的分隔符是否和这个有分隔符匹配
+
+
+    public static void main(String[] args) {
+
+        ArrayStack arrayStack = new ArrayStack(3);
+
+        String str = "12<a[b{c}]>";
+
+        char[] chars = str.toCharArray();
+
+        for (char c : chars) {
+
+            switch (c) {
+
+                case '{':
+                case '[':
+                case '<':
+                    arrayStack.push(c);
+                    break;
+                case '}':
+                case ']':
+                case '>':
+                    if (!arrayStack.isEmpty()) {
+                        char ch = arrayStack.pop().toString().toCharArray()[0];
+                        if (c == '}' && ch != '{' || c == ']' && ch != '[' ||
+                                c == '>' && ch != '<') {
+                            System.out.println("Error:" + ch + "-" + c);
+
+                        }
+                    }
+                    break;
+                default:
+                    break;
+
+
+            }
+
+
+        }
+
+
+    }
+
+
+}
