关于利用数组实现线性表,栈以及队列

最新推荐文章于 2024-08-15 14:47:41 发布

车夫～

最新推荐文章于 2024-08-15 14:47:41 发布

阅读量241

点赞数

文章标签： java 数据结构算法

本文链接：https://blog.csdn.net/qq_43606370/article/details/126942602

版权

根据数组实现栈/队列, 用数组实现一个线性表

1.使用数组实现一个数据结构是线性表的数据容器/集合类

/**
 * @Description: TODO: 使用数组实现一个数据结构是线性表的数据容器/集合类
 */
public class LinkList<T> {
    private Object[] obj;
    private int size;

    private final static int INIT_CAPACITY = 10;
    private static final int MAX_CAPACITY = Integer.MAX_VALUE - 8;

    public LinkList() {
        this.obj = new Object[INIT_CAPACITY];
    }

    public LinkList(int actualParameter) {
        if (actualParameter < 0 || actualParameter > MAX_CAPACITY) {
            throw new IllegalArgumentException("参数异常！");
        }
        this.obj = new Object[actualParameter];
    }

    /**
     * 添加数据
     *
     * @param value
     * @return
     */
    public boolean add(T value) {
        if (size == obj.length) {
            int newParameter = getNewParameter();
            obj = getNewObj(newParameter);
        }
        obj[size] = value;
        size++;
        return true;
    }

    //获取扩容后的数组
    private Object[] getNewObj(int newParameter) {
        Object[] objects = new Object[newParameter];

        for (int i = 0; i < obj.length; i++) {
            objects[i] = obj[i];
        }
        obj = objects;
        return obj;
    }

    //获取扩容的容量
    private int getNewParameter() {
        int oldParameter = obj.length;

        if (oldParameter == MAX_CAPACITY) {
            throw new RuntimeException("数组已经到达最大容量！");
        }

        int newParameter = oldParameter * 2;

        if (newParameter < 0 || newParameter > MAX_CAPACITY) {
            newParameter = MAX_CAPACITY;
        }
        return newParameter;
    }

    /**
     * 删除第index个元素；
     *
     * @param index
     * @return
     */
    public T remove(int index) {
        if (isEmpty()) {
            throw new RuntimeException("数组为空！");
        }
        if (index <= 0 || index >= size) {
            throw new IllegalArgumentException("输入下标有误！");
        }
        Object oldValue = obj[index - 1];
        for (int i = index - 1; i < size; i++) {
            obj[i] = obj[i + 1];
        }
        size--;

        return (T) oldValue;
    }

    /**
     * 根据下标查找对应元素
     *
     * @param index
     * @return
     */
    public T get(int index) {
        if (isEmpty()) {
            throw new RuntimeException("数组为空！");
        }
        if (index <= 0 || index >= size) {
            throw new IllegalArgumentException("输入数据有误！");
        }

        Object oldValue = obj[index - 1];
        return (T) oldValue;
    }

    /**
     * 根据下标修改对应元素
     * @param index
     * @param value
     * @return
     */
    public T set(int index, T value) {
        if (isEmpty()) {
            throw new RuntimeException("数组为空！");
        }
        if (index <= 0 || index >= size) {
            throw new IllegalArgumentException("输入有误！");
        }
        T oldValue = get(index);
        obj[index - 1] = value;

        return oldValue;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }
}

//测试
public class Test {
    public static void main(String[] args) {
        LinkList<String> linkList = new LinkList<>(2);

        linkList.add("aa");
        linkList.add("bb");
        linkList.add("cc");
        linkList.add("dd");
        linkList.add("ee");

        // System.out.println(linkList);

        // System.out.println(linkList.remove(2));
        // System.out.println(linkList);

        System.out.println(linkList.get(3));

        System.out.println(linkList.set(4, "gg"));
        System.out.println(linkList);

    }
}

2.使用数组实现一个数据结构是栈的数据容器/集合类

/**
 * @Description: TODO：使用数组实现一个数据结构是栈的数据容器/集合类
 */
public class ListArrayStack<T> {
    private Object[] obj;
    private int size;

    private final static int INIT_CAPACITY = 10;
    private static final int MAX_CAPACITY = Integer.MAX_VALUE - 8;

    public ListArrayStack() {
        this.obj = new Object[INIT_CAPACITY];
    }

    public ListArrayStack(int actualParameter) {
        if (actualParameter < 0 || actualParameter > MAX_CAPACITY) {
            throw new IllegalArgumentException("参数异常！");
        }
        this.obj = new Object[actualParameter];
    }

    /**
     * 添加数据到栈数组:进栈
     */
    public boolean push(T value) {
        //数组满了，扩展数组
        if (size == obj.length) {
            int newParameter = getNewParameter();
            obj = getNewObj(newParameter);
        }
        obj[size] = value;
        size++;
        return true;
    }

    //获取扩容后的数组
    private Object[] getNewObj(int newParameter) {
        Object[] objects = new Object[newParameter];

        for (int i = 0; i < obj.length; i++) {
            objects[i] = obj[i];
        }
        return obj = objects;
    }

    //获取扩容的容量
    private int getNewParameter() {
        int oldParameter = obj.length;

        int newParameter = oldParameter * 2;

        if (newParameter < 0 || newParameter > MAX_CAPACITY) {
            newParameter = MAX_CAPACITY;
        }

        if (oldParameter == newParameter) {
            throw new RuntimeException("数组已经到达最大容量！");
        }

        return newParameter;
    }

    /**
     * 出栈
     */
    public T pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈为空！");
        }

        size--;
        Object o = obj[size];
        obj[size] = null;


        return (T) o;
    }

    /**
     * 读取栈顶元素
     */
    public T getTop() {
        if (isEmpty()) {
            throw new RuntimeException("栈为空！");
        }
        return (T) obj[size - 1];
    }

    //判断是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }
}

//测试
public class Test {
    public static void main(String[] args) {
        ListArrayStack<String> stack = new ListArrayStack<String>(2);

        stack.push("aa");
        stack.push("bb");
        stack.push("cc");
        stack.push("dd");

        // System.out.println(stack);
        System.out.println(stack.getTop());

        System.out.println(stack.pop());
        System.out.println(stack.getTop());
        // System.out.println(stack);

        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.getTop());

    }
}

3.使用数组实现一个数据结构是循环队列的数据容器/集合类

/**
 * @Description: TODO: 使用数组实现一个数据结构是循环队列的数据容器/集合类
 */
public class ListArrayQueue<T> {
    private Object[] obj;
    private int size;
    private int head;
    private int end;

    private final static int INIT_CAPACITY = 10;
    private static final int MAX_CAPACITY = Integer.MAX_VALUE - 8;

    public ListArrayQueue() {
        this.obj = new Object[INIT_CAPACITY];
    }

    public ListArrayQueue(int actualParameter) {
        if (actualParameter < 0 || actualParameter > MAX_CAPACITY) {
            throw new IllegalArgumentException("参数异常！");
        }
        this.obj = new Object[actualParameter];
    }

    /**
     * 入队
     */
    public boolean enQueue(T value) {
        if (size == obj.length) {
            int newParameter = getNewParameter();
            obj = getNewObj(newParameter);
        }
        obj[end] = value;
        end = (end + 1) % obj.length;
        size++;
        return true;
    }

    //获取扩容后的数组
    private Object[] getNewObj(int newParameter) {
        Object[] objects = new Object[newParameter];

        for (int i = 0; i < obj.length; i++) {
            objects[i] = obj[(head + i) % obj.length];
        }
        obj = objects;
        head = 0;
        end = size;

        return obj;
    }

    //获取扩容的容量
    private int getNewParameter() {
        int oldParameter = obj.length;

        if (oldParameter == MAX_CAPACITY) {
            throw new RuntimeException("数组已经到达最大容量！");
        }

        int newParameter = oldParameter * 2;

        if (newParameter < 0 || newParameter > MAX_CAPACITY) {
            newParameter = MAX_CAPACITY;
        }
        return newParameter;
    }

    /**
     * 出队
     */
    public T deQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空！");
        }
        Object o = obj[head];
        obj[head] = null;
        head = (head + 1) % obj.length;
        size--;
        return (T) o;
    }

    /**
     * 读取队列头数据
     */
    public T getTop() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空！");
        }

        return (T) obj[head];
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }
}

//测试
public class Test {
    public static void main(String[] args) {
        ListArrayQueue<String> queue = new ListArrayQueue<>(3);
        queue.enQueue("aa");
        queue.enQueue("bb");
        queue.enQueue("cc");
        queue.enQueue("dd");
        queue.enQueue("ee");

        // System.out.println(queue);

        System.out.println(queue.getTop());

        System.out.println(queue.deQueue());
        System.out.println(queue.getTop());
        System.out.println(queue.deQueue());
        System.out.println(queue.getTop());
        System.out.println(queue.deQueue());
        System.out.println(queue.getTop());
        System.out.println(queue);

    }
}