栈，队列，列表 demo

1　　列表，队列，栈 概念解析

列表，队列，栈 都属于线性数据结构

 

列表和队列栈的关系：

列表是一种数据项构成的有限序列，即按照一定的线性顺序，排列而成的数据项的集合，在这种数据结构上进行的基本操作包括对元素的的查找，

栈和队列是两种特殊类型的列表。

 

栈和队列的关系：

区别：栈的特点是先进后出；队列的特点是先进先出；

相同：栈和队列的共同点是只允许在端点处插入和删除元素；队列的操作与栈的操作类似，不同的是队列的删除是在 表的头部（front）进行．

 

列表和队列的关系：

区别：列表不会去重，队列会

参考：https://blog.csdn.net/neodav/article/details/7208917　

 

 

他们的特点：是否会有线程问题？

|--List: 元素是有序的(怎么存的就怎么取出来，顺序不会乱)，元素可以重复（角标1上有个3，角标2上也可以有个3）因为该集合体系有索引，
|-- ArrayList：底层的数据结构使用的是数组结构（数组长度是可变的百分之五十延长）（特点是查询很快，但增删较慢）线程不同步
|-- LinkedList：底层的数据结构是链表结构（特点是查询较慢，增删较快）
|-- Vector：底层是数组数据结构 线程同步（数组长度是可变的百分之百延长）（无论查询还是增删都很慢，被ArrayList替代了）

参考：https://www.cnblogs.com/zouzz/p/6397878.html

 

2　　主要应用：

列表的应用：数组和链表

栈的应用：linkedList

队列的应用：linkedList

 

 

3　　Demo相关：

数组demo：

package com.array.Array;
 
public class ArrayShuZu {
    public static void main(String[] args) {
        int array[]=new int []{8,2,4,7,9,5,6,3,1,0} ;
        utilArraySorting uas = new utilArraySorting() ;
        utilArraySorting.order(array);
        uas.getArray(array);
        System.out.println("\n-------------我是锋利的分割线-------");
        utilArraySorting.reverse(array);
        uas.getArray(array);
    }
}
 
 
class utilArraySorting{
   public static void  order(int array[]){
       int a[]=array ;
       for (int x = 0; x < array.length-1; x++) {
           for(int y=0;y<array.length-x-1;y++){
               if(array[y]>array[y+1]) {
                   int temp = array[y + 1] ;
                   array[y+1]=array[y] ;
                   array[y] = temp;
                }
           }
       }
   }
   public static void reverse(int array[]){
 
       int tail=array.length-1;
       int head=0;
       for(int x=0;x<=array.length/2;x++){
           int temp=array[head] ;
           array[head]=array[tail] ;
           array[tail]=temp;
           head++ ;
           tail-- ;
       }
   }
   public void getArray(int array[]){
       for(int a:array){
           System.out.print(a) ;
       }
   }
}
 

参考：https://blog.csdn.net/qq_36823679/article/details/89981228

 

 

栈demo：

1　　LinkedList 实现栈的demo

说明：LinkedList具有能够直接实现栈所有功能的方法，因此可以直接将LinkedList作为栈使用。

测试类：

package com.array.Array;

public class QueneTest {
    
    
    /*public static void main(String[] args) {
        QueuePerson qPerson1 = new QueuePerson("张一丰");
        QueuePerson qPerson2 = new QueuePerson("张二忌");
        QueuePerson qPerson3 = new QueuePerson("李三思");
        QueuePerson qPerson4 ;
        MyQueue<QueuePerson> mQueue1 = new MyQueue<QueuePerson>();
        
        *//**
         * 插入队尾
         *//*
        mQueue1.offer(qPerson1);
        System.out.println(mQueue1);

        mQueue1.offer(qPerson2);
        System.out.println(mQueue1);
        
        mQueue1.offer(qPerson3);
        System.out.println(mQueue1);
        
        *//**
         * 查看队列是否为空
         *//*
        boolean a = mQueue1.empty();
        
        *//**
         * 打印队列
         *//*
        System.out.println(mQueue1.toString());
        
        //检索并不移除此队列的头
        qPerson4 = mQueue1.element();
        System.out.println(qPerson4);
        System.out.println(mQueue1);
        
        //检索并移除此队列的头
        qPerson4 = mQueue1.poll();
        System.out.println(qPerson4);
        System.out.println(mQueue1);
        mQueue1.poll();
        System.out.println(mQueue1);
        mQueue1.poll();
        System.out.println(mQueue1);
        
    }*/

    
    public static void main(String[] args) {
        QueuePerson qPerson1 = new QueuePerson("张一丰");
        QueuePerson qPerson2 = new QueuePerson("张二忌");
        QueuePerson qPerson3 = new QueuePerson("李三思");
        QueuePerson qPerson4 ;
        MyStack<QueuePerson> mStack = new MyStack<QueuePerson>();
        
        
        
        /**
         * 入栈（插入队首）
         */
        mStack.push(qPerson1);
        System.out.println(mStack);

        mStack.push(qPerson2);
        System.out.println(mStack);
        
        mStack.push(qPerson3);
        System.out.println(mStack);
        
        /**
         * 栈是否为空
         */
        boolean bEmpty = mStack.empty();
        
        /**
         * 打印栈
         */
        System.out.println(mStack.toString());
        
        //出栈，但不删除
        qPerson4 = mStack.peek();
        System.out.println(qPerson4);
        System.out.println(mStack);
        
        //出栈
        qPerson4 = mStack.pop();
        System.out.println(qPerson4);
        System.out.println(mStack);
        mStack.pop();
        System.out.println(mStack);
        mStack.pop();
        System.out.println(mStack);
        
    }
}

 

lindedlist实现类：

package com.array.Array;

import java.util.LinkedList;

 

public class MyStack<T> {

    private LinkedList<T> storage = new LinkedList<T>();

 

     /** 入栈 */

    public void push(T v) {

       storage.addFirst(v);

    }

 

     /** 出栈，但不删除 */

    public T peek() {

       return storage.getFirst();

    }

 

     /** 出栈 */

    public T pop() {

       return storage.removeFirst();

    }

 

     /** 栈是否为空 */

    public boolean empty() {

       return storage.isEmpty();

    }

 

     /** 打印栈元素 */

    public String toString() {

       return storage.toString();

    }

}

 

基类：

package com.array.Array;

public class QueuePerson {
    private String personName;

    public String getPersonName() {
        return personName;
    }

    public void setPersonName(String personName) {
        this.personName = personName;
    }

    public QueuePerson(String personName) {
        super();
        this.personName = personName;
    }

    @Override
    public String toString() {
        return "QueuePerson [personName=" + personName + "]";
    }
    
    

}

 

打印日志：

[QueuePerson [personName=张一丰]]
[QueuePerson [personName=张二忌], QueuePerson [personName=张一丰]]
[QueuePerson [personName=李三思], QueuePerson [personName=张二忌], QueuePerson [personName=张一丰]]
[QueuePerson [personName=李三思], QueuePerson [personName=张二忌], QueuePerson [personName=张一丰]]
QueuePerson [personName=李三思]
[QueuePerson [personName=李三思], QueuePerson [personName=张二忌], QueuePerson [personName=张一丰]]
QueuePerson [personName=李三思]
[QueuePerson [personName=张二忌], QueuePerson [personName=张一丰]]
[QueuePerson [personName=张一丰]]
[]

 

参考：https://blog.csdn.net/liuxiao723846/article/details/50504987

 

 

2　　栈的常用方法：

package com.geely.design.pattern.behavioral.interpreter;

import java.util.Stack;

/**
 * Created by ddwei
 * 栈有先进后出，后进先出的特性
 *
 */
public class TestStack {

    public static void main(String [] args){
        Stack stack = new Stack();
        //栈放值
        stack.push("中华");
        stack.push("我家");
        stack.push("程序猿");


        //在堆栈中搜索element，如果发现了，则返回它相对于栈顶的偏移量。否则，返回-1。
        int x = stack.search("我家");
        int y = stack.search("攻城狮");
        System.out.println(x);
        System.out.println(y);
        System.out.println("==========================================我是分隔符=====================================================");


        //栈顶取值并不删除栈顶元素
        String a = stack.peek().toString();
        String b = stack.peek().toString();
        System.out.println(a);
        System.out.println(b);
        System.out.println("==========================================我是分隔符=====================================================");

        //栈顶取值并删除栈顶元素
        String c = stack.pop().toString();
        String d = stack.pop().toString();

        System.out.println(c);
        System.out.println(d);
        System.out.println("==========================================我是分隔符=====================================================");

        //判断栈是否为空
        boolean e = stack.empty();
        System.out.println(e);
    }
}

 

 

应用2：（栈的数据类型为int）

设计模式中：

https://www.cnblogs.com/1446358788-qq/p/12315728.html#_label0

 

应用3：（栈的数据类型为类）

设计模式中：

https://www.cnblogs.com/1446358788-qq/p/12355447.html

 

 

队列demo：

1　　LinkedList 实现栈

说明：使用java.util.Queue接口,其底层关联到一个LinkedList（双端队列）实例。由于只暴露部分基于队列实现的接口，所以可以提供安全的队列实现。

 

测试类：

package com.array.Array;

public class QueneTest {
    
    
    /*public static void main(String[] args) {
        QueuePerson qPerson1 = new QueuePerson("张一丰");
        QueuePerson qPerson2 = new QueuePerson("张二忌");
        QueuePerson qPerson3 = new QueuePerson("李三思");
        QueuePerson qPerson4 ;
        MyQueue<QueuePerson> mQueue1 = new MyQueue<QueuePerson>();
        
        *//**
         * 插入队尾
         *//*
        mQueue1.offer(qPerson1);
        System.out.println(mQueue1);

        mQueue1.offer(qPerson2);
        System.out.println(mQueue1);
        
        mQueue1.offer(qPerson3);
        System.out.println(mQueue1);
        
        *//**
         * 查看队列是否为空
         *//*
        boolean a = mQueue1.empty();
        
        *//**
         * 打印队列
         *//*
        System.out.println(mQueue1.toString());
        
        //检索并不移除此队列的头
        qPerson4 = mQueue1.element();
        System.out.println(qPerson4);
        System.out.println(mQueue1);
        
        //检索并移除此队列的头
        qPerson4 = mQueue1.poll();
        System.out.println(qPerson4);
        System.out.println(mQueue1);
        mQueue1.poll();
        System.out.println(mQueue1);
        mQueue1.poll();
        System.out.println(mQueue1);
        
    }*/

    
    public static void main(String[] args) {
        QueuePerson qPerson1 = new QueuePerson("张一丰");
        QueuePerson qPerson2 = new QueuePerson("张二忌");
        QueuePerson qPerson3 = new QueuePerson("李三思");
        QueuePerson qPerson4 ;
        MyStack<QueuePerson> mStack = new MyStack<QueuePerson>();
        
        
        
        /**
         * 入栈（插入队首）
         */
        mStack.push(qPerson1);
        System.out.println(mStack);

        mStack.push(qPerson2);
        System.out.println(mStack);
        
        mStack.push(qPerson3);
        System.out.println(mStack);
        
        /**
         * 栈是否为空
         */
        boolean bEmpty = mStack.empty();
        
        /**
         * 打印栈
         */
        System.out.println(mStack.toString());
        
        //出栈，但不删除
        qPerson4 = mStack.peek();
        System.out.println(qPerson4);
        System.out.println(mStack);
        
        //出栈
        qPerson4 = mStack.pop();
        System.out.println(qPerson4);
        System.out.println(mStack);
        mStack.pop();
        System.out.println(mStack);
        mStack.pop();
        System.out.println(mStack);
        
    }
}

 

linkedList实现栈：

package com.array.Array;

import java.util.LinkedList;

 

public class MyStack<T> {

    private LinkedList<T> storage = new LinkedList<T>();

 

     /** 入栈 */

    public void push(T v) {

       storage.addFirst(v);

    }

 

     /** 出栈，但不删除 */

    public T peek() {

       return storage.getFirst();

    }

 

     /** 出栈 */

    public T pop() {

       return storage.removeFirst();

    }

 

     /** 栈是否为空 */

    public boolean empty() {

       return storage.isEmpty();

    }

 

     /** 打印栈元素 */

    public String toString() {

       return storage.toString();

    }

}

 

基类：

package com.array.Array;

public class QueuePerson {
    private String personName;

    public String getPersonName() {
        return personName;
    }

    public void setPersonName(String personName) {
        this.personName = personName;
    }

    public QueuePerson(String personName) {
        super();
        this.personName = personName;
    }

    @Override
    public String toString() {
        return "QueuePerson [personName=" + personName + "]";
    }
    
    

}

 

打印日志：

[QueuePerson [personName=张一丰]]
[QueuePerson [personName=张二忌], QueuePerson [personName=张一丰]]
[QueuePerson [personName=李三思], QueuePerson [personName=张二忌], QueuePerson [personName=张一丰]]
[QueuePerson [personName=李三思], QueuePerson [personName=张二忌], QueuePerson [personName=张一丰]]
QueuePerson [personName=李三思]
[QueuePerson [personName=李三思], QueuePerson [personName=张二忌], QueuePerson [personName=张一丰]]
QueuePerson [personName=李三思]
[QueuePerson [personName=张二忌], QueuePerson [personName=张一丰]]
[QueuePerson [personName=张一丰]]
[]

 

参考：https://blog.csdn.net/liuxiao723846/article/details/50504987

 

 

设计模式中：（ArrayList先进后出的特性）

https://www.cnblogs.com/1446358788-qq/p/12381521.html