原 用长度可变数组实现栈和队列

为什么要定义可变数组

        因为数组的长度固定了的，不能增长，在现实生活中我们往往需要添加或修改内容，所以一般的数组满足不了我们的要求，需要定义一个长度可变的数组来让我们增加或修改其中的数据。

 

 

     定义可变数组的思路

        主要是可变，可变就意味的数组的长度是可以变化的，所以我们可以在开始定义一个长度为0的数组，之后每增加一个元素就增加一个数组长度，同样的，每删除一个就减少一个数组长度。数组的方法一般包括添加元素，删除元素，修改元素，查看元素，查看长度 。

 

package com.lfw.array;  
  
//自定义长度可变的数组  
public class MyArray {  
    // 定义一个初始长度是0的数组，用来缓存数据  
    private String[] src = new String[0];  
  
    /**  
     * 添加数据的方法  
     *   
     * @param s  
     *            表示要保存的元素  
     */  
    public void add(String s) {  
        // 定义一个新数组，长度是原数组长度+1  
        String[] dest = new String[src.length + 1];  
        // 将新元素放到新数组的最后一个位置  
        dest[dest.length - 1] = s;  
        // 将原数组中的数据按照下标顺序拷贝到新数组  
        for (int i = 0; i < src.length; i++) {  
            dest[i] = src[i];  
        }  
        // 将src指向新数组  
        src = dest;  
    }  
  
    /**  
     * 根据下标提取元素的方法  
     *   
     * @param index  
     *            要提取的元素的下标  
     * @return 返回提取到的元素  
     */  
    public String get(int index) {  
        return src[index];  
    }  
  
    /**  
     * 获得长度可变数组中元素个数[长度]  
     *   
     * @return 返回元素个数  
     */  
    public int size() {  
        return src.length;  
    }  
  
    /**  
     * 将新元素插入到指定位置  
     *   
     * @param s  
     *            要插入的新元素  
     * @param index  
     *            要插入的位置  
     */  
    public void insert(String s, int index) {  
        if (index < 0 || index >= src.length) {  
            // 抛出异常对象  
            throw new IndexOutOfBoundsException("下标越界！");  
        }  
  
        // 定义一个新数组，长度是原数组长度+1  
        String[] dest = new String[src.length + 1];  
        // 将新元素放到指定位置  
        dest[index] = s;  
        // 将下标小于index的元素按照相同的下标位置拷贝到新数组  
        for (int i = 0; i < index; i++) {  
            dest[i] = src[i];  
        }  
  
        // 从原数组index位置开始，拷贝到新数组index+1的位置  
        for (int i = index; i < src.length; i++) {  
            dest[i + 1] = src[i];  
        }  
        src = dest;  
  
    }  
  
    /**  
     * 删除指定位置的元素  
     *   
     * @param index  
     *            要删除的元素的下标  
     */  
    public void delete(int index) {  
        if (index < 0 || index >= src.length) {  
            // 抛出异常对象  
            throw new IndexOutOfBoundsException("下标越界！");  
        }  
        // 定义一个新数组长度是原数组长度-1  
        String[] dest = new String[src.length - 1];  
        // 将下标小于index的元素按下相同位置拷贝到新数组  
        for (int i = 0; i < index; i++) {  
            dest[i] = src[i];  
        }  
        // 将下标大于index的拷贝到新数组index-1的位置  
        for (int i = index + 1; i < src.length; i++) {  
            dest[i - 1] = src[i];  
        }  
        src = dest;  
  
    }  
  
    /**  
     * 修改指定位置的元素  
     *   
     * @param index  
     *            要修改的元素的下标  
     * @param newStr  
     *            修改后的元素值  
     */  
    public void modify(int index, String newStr) {  
        src[index] = newStr;  
    }  
  
}  

栈的实现

    栈最大的特点就是LIFO（Last Int First Out) 后进先出，栈的一般方法包括入栈，查看栈顶元素，弹出栈顶元素，判断栈是否为空。（用数组实现栈的时候，我们只需要对栈顶元素进行操作，所以我们可以认为入栈方法共和数组的添加元素方法是一样的，我们只需要注重后进先出这一特点对最后加入的元素进行操作）

 

package com.lfw.array;  
  
  
public class Stack <E>{  
  
    Node head = null;// 空的链表，头结点一定为null  
    Node last = null;// 空的链表，尾结点也为null  
    int count = 0;// 结点的个数，默认是0  
  
    // 将数据压入栈  
    public void push(E s) {  
        Node Object = new Node(s);  
        // 将新结点作为链表的新结点  
        Object.next = head;  
        head = Object;    
        count++;  
    }  
  
    // 查看栈顶的数据  
    public E look() {  
        if(head != null) {  
            return head.data ;  
        }  
        return null;  
      
          
  
    }  
      
    //弹出栈顶的数据[移除]  
    public E poll(){  
        if(head != null) {  
            Node n = head;  
            head = head.next ;  
            n.next = null;  
            count--;  
            return n.data ;  
        }  
        if (count == 0) {  
            return null;  
        }  
      
        return null;  
    }  
      
    //获得栈的长度  
    public int size(){  
        return count;  
    }  
      
  
      
    //判断栈是否为空  
    public boolean isEmpty(){  
        return count == 0;  
    }  
    // 定义一个内部类，表示结点类  
    class Node {  
        E data;// 结点中的元素[数据]  
        Node next;// 对下一个结点的引用  
  
        public Node(E data) {  
            this.data = data;  
        }  
    }  
}  

写一个主类调用一下

package com.lfw.array;  
  
  
public class Test {  
  
    public static void main(String[] args) {  
          
        Stack sta = new Stack();  
        sta.push("张三");  
        sta.push("李四");  
        sta.push("王五");  
        sta.push("赵六");  
        sta.push("唐七");  
          
          
        while(!sta.isEmpty()) {  
            Object s2 = sta.poll();  
            System.out.println("弹出栈顶元素为"+s2);  
        }  
      
    }  
      
      
      
}  

结果为

 

 

队列的实现

    队列不同于栈，队列的特点是后进后出。代码如下

package com.lfw.array;  
  
public class Queue {  
    private String[] src = new String[0];  
  
    public void add(String s) {  
        String[] dest = new String[src.length + 1];  
        dest[dest.length - 1] = s;  
  
        for (int i = 0; i < src.length; i++) {  
            dest[i] = src[i];  
        }  
  
        src = dest;  
    }  
  
    public String poll() {  
        if (src.length == 0) {  
            return null;  
        }  
        String s = src[0];  
          
        String[] dest = new String[src.length - 1];  
          
        for (int i = 0; i < src.length - 1; i++) {  
            dest[i] = src[i+1];  
        }  
  
        src = dest;  
        return s;  
          
    }  
  
    public int size() {  
        return src.length;  
    }  
  
    public boolean isEmpty() {  
        return src.length == 0;  
    }  
}  

同样的可以写一个主类调用一下

package com.lfw.array;  
  
  
public class Test {  
  
    public static void main(String[] args) {  
          
        Queue eu = new Queue();  
        eu.add("张三");  
        eu.add("李四");  
        eu.add("王五");  
        eu.add("赵六");  
        eu.add("唐七");  
          
          
        while(!eu.isEmpty()) {  
            Object s2 = eu.poll();  
            System.out.println("弹出对列元素为"+s2);  
        }  
      
    }  
      
      
      
}  

 

结果如下

 

 

总结：其实用可变数组编写栈和数列时，就是要抓住栈和数列的特点，一个先进先出，一个后进后出，其实添加元素的方法都一样，只是取元素的时候不同，根据各自的特点编写不同的代码就行。