背包、栈、队列 链表的元素增删实现 初步总结

一

背包的概念：是一种不支持从中删除元素的集合数据类型，它能够帮助用例收集元素并且迭代所有元素。

队列：是一种基于先进先出（FIFO）的集合数据类型

下压栈：是一种基于后进先出（LIFO）的集合数据类型

1. 定容栈的实现:   给定数组大小

public class FixedCapacityStackOfStrings{
    private String[] a ;
    private int N;
    public FixedCapacityStackOfStrings(int cap){
        a = new String[cap];
    }
    public boolean isEmpty(){ return N == 0}
    
    public int size(){return N;}
    public void push(String item){
        a[N++] = item;   // 这里面是N++ 而不是++N的原因是，数组是从0开始索引的，所以a[0]被赋值时，N = 1，  
//当删除一个元素时，应该时--N，而不是N--，因为索引的值比个数少一。即a[N-1]
    }
    public String pop(){
        return a[--N];
    }
}

但是数组表示栈内容而不能动态调整数组，这导致了浪费大量的内存，所以需要动态调整数组的大小

2. 动态调整数组的大小的下压栈实现

public class ResizingArrayStack<Item> implements Iterable<Item>{
    private Item[] a = (Item[]) new Object[1];
    private int N = 0;
    public boolean isEmpty(){ return N==0;}
    public int size(){ return N;}
    private void resize(int max){
        Item[] temp = (Item[]) new Object[max];
        for(int i = 0;i < N ; i++) 
            temp[i] = a[i];
        a = temp;
    }
    public void push(Item item){
        if(N==a.length) resize(2*a.length);
        a[N++] = item;
    }
    public Item pop(){
        Item item = a[--N];
        a[N] = null;
        if(N>0 && N < a.length/4) resize(2*a.length);
        return item;
    }

    public Iterator<Item> iterator(){
        return new ReverseArrayIterator();
    }
    private class ReverseArrayIterator implements Iterator<Item>{
        private int i = N;
        public boolean hasNext(){return i > 0 ;}
        public Item next(){return a[--i];}
        public void remove(){}
    }
}

二

链表:是一种递归的数据结构,它或者为空(null),或者是含有泛型元素的结点和指向另一条链表的引用

面向对象编程,用一个嵌套类来定义结点的抽象数据类型:

private class Node{

        Item item;

        Node next;

}

2.1 在表头插入结点 ,从表头删除结点,在表尾添加结点,表尾删除结点

public class LianBiao<Item> implements Iterable{
    private class Node{
        Item item;
        Node next;
    }
    private Node first;
    private Node last;
    private int n;
    
    public boolean isEmpty(){return n == 0;}
    public int size(){return n = 0;}
    
    //在集合的头部加入元素
    public void pushHead(Item item){
        Node old = first;
        first = new Node();
        first.item = item;
        first.next = old;
    }

    //在集合头部删除元素
    public Item popHead(){
        Item item = first.item;
        first = first.next;
        return item;
    }
    
    //在集合的尾部插入元素
    public void pushLast(Item item){
        Node old = last;
        last = new Node();
        last.item = item;
        if(isEmpty()){first = last;}
        else{old.next = last;}
        n++;
    }

    //在集合的尾部删除元素
    public void deleteLast(){
        Node current = first;
        while(current.next.next!= null){
            current = current.next;
        }
        current.next = null;
    }
    
    public Iterator iterator(){return new ListIterator();}
    private class ListIterator implements Iterator<Item> {
        private Node current = first;
        public boolean hasnext(){
            return current != null;
        }
        public Item next(){
            //后进先出
            Item item = current.item;
            current = current.next;
            return item;
        }
    }


//代码出处:https://blog.csdn.net/qq_34453300/article/details/87559191?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_title~default-1.control&spm=1001.2101.3001.4242
}

学完链表后,可以用在表头添加元素,在表头删除元素表示栈的操作;  在表尾添加元素,在表头删除元素表示队列