阅读 43

数据结构- 栈 & 队列

栈(Stack)

分为顺序结构和链表结构 特点:先进后出,后进先出

顺序结构

存储线性表的数据元素的方式 = 一段地址连续的存储单元

在类的内部使用数组来存储元素,数组的大小会根据需要动态的变化,因为有一个resize()方法,使用N来表示栈顶的上面一个位置,入栈时,先将元素放入data[N],N再进行加一的操作;反之,出栈时,先将N减一,取出元素,再置此时data[N]的值为nul

public class ArrayStack<Item> implements Iterable<Item> {

    private Item[] data = (Item[]) new Object[1]; // 栈里的数据
    private int N = 0; // 栈的元素个数

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

    public int length(){
        return N;
    }

    public void resize(int len){
        Item[] temp = (Item[]) new Object[len];
        for (int i=0; i<N; i++){
            temp[i] = data[i];
        }
        data = temp;
    }

    public void push(Item item){
        if (N == data.length){
            this.resize(2* data.length);
        }
        data[N++] = item;
    }

    public Item pop(){
        Item item = data[--N];
        data[N] = null; // 避免对象游离
        if (N>0 && N==data.length/4){
            this.resize(data.length/2);
        }
        return item;
    }

    @Override
    public Iterator<Item> iterator() {
        return new ReverseArrayIterator();
    }

    // 内部类
    public class ReverseArrayIterator implements Iterator<Item>{
        private int i = N;

        public boolean hasNext(){
            return i>0;
        }

        public Item next(){
            return data[--i];
        }

        public void remove(){

        }
    }

    public static void main(String[] args) {
        ArrayStack<Integer> testStack = new ArrayStack<>();
        testStack.push(1);
        testStack.push(2);
        testStack.push(3);
        testStack.push(4);
        for (Integer i:testStack){
            System.out.println(i);
        }
        testStack.pop();
        for (Integer i:testStack){
            System.out.println(i);
        }
    }
}
复制代码

链式结构

结构特点 存储线性表的数据元素的方式 = 一段地址不连续、任意的存储单元 ​ 设定一个top指针表示栈顶,所以显然当top为null时,表示栈空。入栈:新建一个oldTop变量指向此时的top指向,再让top指向新插入的元素结点,再设其next指针指向oldTop;出栈:只需在取出元素之后让栈顶指针指向下一个元素即可

public class Stack<Item> implements Iterable<Item> {
    private Node top;
    private int N;

    private class Node{
        Item item;
        Node next;

        public Node(Item item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    public boolean isEmpty(){
        return top==null;
    }

    public int length(){
        return N;
    }

    public void push(Item item){
        Node oldTop = top;
        top = new Node(item,oldTop);
        N = N + 1;
    }

    public Item pop(){
        Item item = top.item;
        top = top.next;
        return item;
    }

    @Override
    public Iterator<Item> iterator() {
        return new StackIterator();
    }

    private class StackIterator implements Iterator<Item>{

        private Node current = top;

        @Override
        public boolean hasNext() {
            return current != null;
        }

        @Override
        public Item next() {
            Item item = current.item;
            current = current.next;
            return item;
        }
    }
}
复制代码

队列

特点:先进先出

顺序队列

特点:使用一组地址连续的内存单元依次保存数据,也可以定义一个特定大小的结构数组作为队列

public class CirQueue {
    private Object[] objs;
    private int front = 0;// 头指针
    private int rear = 0;// 尾指针
    private int size;// 空间大小
    private int length = 0;

    // 初始化
    public CirQueue(int size) {
        this.size = size;
        objs = new Object[size];
    }

    // 计算长度(即队列元素个数)
    public int getLength() {
        return length;
    }

    // 判空
    public boolean isEmpty() {
        if (front == rear) {
            return true;
        }
        return false;
    }

    // 判满
    public boolean isFull() {
        if ((rear + 1) % size == front) {
            return true;
        }
        return false;
    }

    // 入队
    public boolean enQueue(Object n) {
        if (isFull()) {
            return false;
        }
        rear = (rear + 1) % size;// 体现循环
        objs[rear] = n;
        length++;
        return true;
    }

    // 出队
    public Object deQueue() {
        Object n = null;
        if (!isEmpty()) {
            front = (front + 1) % size;// 体现循环
            n = objs[front];
            objs[front] = null;
            length--;
        }
        return n;
    }

    // 输出
    public void show() {
        for (Object obj : objs) {
            if (obj == null) {
                System.out.print("空   ");
            } else {
                System.out.print(obj.toString() + "  ");
            }
        }
        System.out.println("");
    }
}
复制代码

链式队列

public class QueueLink implements Queue {
 
    // 定义一个节点内部类
    class Node {
        private Object data;
        private Node next;
 
        public Node(Object obj) {
 
            this.data = obj;
 
        }
 
        public Node() {
             
        }
 
    }
 
    // 定义链式队列的一些属性
    private Node head; // 头指针(引用)
    private Node rear; // 尾指针(引用)
    private int length; // 队列的长度,开始为1
    private Node temp; // 临时指针(引用)
 
    // 初始化队列,空头指针
    public QueueLink() {
        head = new Node();
        rear = head;
        length = 1;
 
    }
 
    // 初始化队列,有数据头指针
    public QueueLink(Object obj) {
        head = new Node(obj);
        rear = head;
        length = 1;
    }
 
    public boolean clear() {
        // TODO Auto-generated method stub
        if(this.length==1){
             
            return true;
        }else if(length==2){
             
            head.next=null;
            //没有引用的节点java会自动回收内存
             
        }else {
             
            while(head.next.next!=null){
                head.next=head.next.next;
                 
                 
            }
             
            head.next=null;
            return true;
             
        }
        return false;
         
         
         
    }
 
    // 判空
    public boolean isEmpty() {
        // TODO Auto-generated method stub
 
        if (this.length() == 1) {
 
            return true;
        } else {
 
            return false;
        }
    }
 
    // 获得队列的长度
    public int length() {
        // TODO Auto-generated method stub
        return this.length;
    }
 
    // 添加一个节点
    public void offer(Object x) {
        this.temp = new Node(x);
 
        // 队列使用尾插法
        rear.next = temp;
        rear = temp;
        this.length++;
 
        // TODO Auto-generated method stub
 
    }
 
    // 查看第一个节点
    public Node peek() {
        // TODO Auto-generated method stub
        if (length == 1) {
 
            temp=null;
        } else {
 
            temp= head.next;
        }
        return temp;
    }
    //删除第一个节点
    public Node poll() {
        // TODO Auto-generated method stub
         
         
        if(length==1){
            //无法删除
            temp=null;
             
        }else
         
        if(length==2){
            this.temp= head.next;
            //置空下一个节点就可以了
            head.next=null;
            length--;
             
        }else{
            this.temp= head.next;
            this.head.next=this.head.next.next;
            length--;
        }
         
         
         
        return temp;
    }
    //test
    public static void main(String[] args) {
        QueueLink linkQueue = new QueueLink();
        System.out.println("队列是否为空:"+linkQueue.isEmpty());
        System.out.println("连续入队-------------------------------");
        for(int i=0;i<5;i++){
            linkQueue.offer((char)(97+i));
        }
        System.out.println("队列长度为:"+linkQueue.length());
        System.out.println("队首元素为:"+linkQueue.peek().data);
  
        //出队
        System.out.println("连续出队-------------------------------");
        for(int i=0;i<4;i++){
            Object data=linkQueue.poll();
        }
        System.out.println("队列长度为:"+linkQueue.length());
         
    }
 
}
复制代码
文章分类
Android
文章标签