精华内容
下载资源
问答
  • 的概念:弹压,就像子弹壳装弹,一粒一粒压进去,但是打出来的时候从上面打出来的,最先压进去的最后弹出来,如果进去顺序123,打出来顺序321,这就是后进先出队列的概念:就是我们平时排队,按次序来,你...
    栈的概念:是弹压,就像子弹壳装弹,一粒一粒压进去,但是打出来的时候是从上面打出来的,最先压进去的最后弹出来,如果进去顺序是123,打出来顺序是321,这就是后进先出
    队列的概念:就是我们平时排队,按次序来,你排在第1个,那你就第一个轮到,就是先进先出,先到先来
    展开全文
  • 1.2:背包,队列

    2016-02-21 10:15:18
    增加在队尾,减少在队头背包:背包本质上和前两者没有什么不同,可以是,也可以是队列,使用这个概念意在表示在个别情况下元素处理的顺序不重要,可以是“先进先出”也可以是“后进先出” 这三种数据类型称之为 ...

    1:概念

    首先介绍下三者的概念:

    1.     :所谓的“栈”也称之为“后进先出队列”,可以想像成放在桌上的一叠书,每次无论增加还是减少都在顶部。
    2. 队列:“先进先出队列”,类比生活中的排队。增加在队尾,减少在队头
    3. 背包:背包本质上和前两者没有什么不同,可以是栈,也可以是队列,使用这个概念意在表示在个别情况下元素处理的顺序不重要,可以是“先进先出”也可以是“后进先出”

    这三种数据类型称之为 “集合数据类型

    2:API

    3:栈的数组的实现以及对其一些改进

    首先为了简单起见,我们先使用数组来表示栈:

    import edu.princeton.cs.algs4.StdIn;
    import edu.princeton.cs.algs4.StdOut;
    
    class FixedCapacityStackOfStrings {
    	private String[] a;
    	private int size;
    	
    	public FixedCapacityStackOfStrings(int n) {
    		a = new String[n];
    	}
    	
    	public void push(String item) {
    		a[size++] = item;
    	}
    	
    	public String pop() {
    		return a[--size];
    	}
    	
    	public boolean isEmpty() {
    		return size == 0;
    	}
    	
    	public int size() {
    		return size;
    	}
    }
    
    public class Test {
    	public static void main(String args[]) {
    		FixedCapacityStackOfStrings s = new FixedCapacityStackOfStrings(100);
    		
    		while(!StdIn.isEmpty()) {
    			String item = StdIn.readString();
    			if(!item.equals("-"))
    				s.push(item);
    			else if(!s.isEmpty()) 
    				System.out.print(s.pop() + " ");
    		}
    		
    	}
    }

    结果如下:


    由于该种栈只支持“String”类型,所以可以用泛型对其进行改进,以便符合其它类型的栈

    import edu.princeton.cs.algs4.StdIn;
    
    class FixedCapacityStack<Item> {
    	private Item[] a;
    	private int size;
    	
    	public FixedCapacityStack(int n) {
    		a = (Item[]) new Object[n];
    	}
    	
    	public void push(Item item) {
    		a[size++] = item;
    	}
    	
    	public Item pop() {
    		return a[--size];
    	}
    	
    	public boolean isEmpty() {
    		return size == 0;
    	}
    	
    	public int size() {
    		return size;
    	}
    }
    
    public class Test {
    	public static void main(String args[]) {
    		FixedCapacityStack<String> s = new FixedCapacityStack(100);
    		
    		while(!StdIn.isEmpty()) {
    			String item = StdIn.readString();
    			if(!item.equals("-"))
    				s.push(item);
    			else if(!s.isEmpty()) 
    				System.out.print(s.pop() + " ");
    		}
    		System.out.println(s.size());
    	}
    }

    但是这样依旧还有一些缺点,比如说大小的调整。因为无法实现确定栈的大小,只能采取多分配大一些的空间,这样无疑绘很浪费。所以进一步改进如下:

    import java.util.Iterator;
    
    import edu.princeton.cs.algs4.StdIn;
    
    class FixedCapacityStack<Item> implements Iterable<Item>{
    	private Item[] a;
    	private int size = 0;	//元素的大小
    	
    	private void resize(int len) {	//该方法将a[]大小扩大(缩小)到len
    		Item[] temp = (Item[]) new Object[len];
    		for(int i = 0; i < len; i++)
    			temp[i] = a[i];
    		a = temp;
    	}
    	
    	public FixedCapacityStack(int n) {
    		a = (Item[]) new Object[n];
    	}
    	
    	public void push(Item item) {
    		if(size == a.length)	
    			resize(2 * a.length);
    		
    		a[size++] = item;
    	}
    	
    	public Item pop() {
    		Item item = a[--size];
    		
    		a[size] = null;	//避免对象游离
    		if(size > 0 && size == a.length)
    			resize(a.length / 2);
    		
    		return item;
    	}
    	
    	public boolean isEmpty() {
    		return size == 0;
    	}
    	
    	public int size() {
    		return size;
    	}
    	
    	//为了能够使用foreach打印,实现了一个iterator()方法以及一个ReverseArrayIterator内部类
    	public Iterator<Item> iterator() {
    		return new ReverseArrayIterator();
    	}
    	
    	private class ReverseArrayIterator implements Iterator<Item>{
    		private int i = size;
    		
    		public boolean hasNext() {
    			return i > 0;
    		}
    		
    		public Item next() {
    			return a[--i];
    		}
    		
    		public void remove() {}
    		
    	}
    }
    

    这段代码相比前面两个做了3点优化:

    1. 实现了数组可自动调整
    2. 在pop()方法中使用了a[size] = null; 避免对象游离
    3. 新增加一个iterator()方法以及一个ReverseArrayIterator内部类,以便能够使用foreach()方法打印该对象

    尽管这是数组来表示栈最好的方式,但是数组里面空间的浪费依然不可避免。所以下面给出另一种数据结构来表示栈

    4:使用链表来表示栈

    import java.util.Iterator;
    
    public class Stack<Item> implements Iterable<Item>{
    	private Node top;	//栈顶元素
    	private int size;	//元素数量
    	private class Node {
    		Item item;
    		Node next;
    	}
    	
    	public boolean isEmpty() {
    		return top == null;
    	}
    	
    	public int size() {
    		return size;
    	}
    	
    	public void push(Item item) {
    		Node oldTop = top;
    		top = new Node();
    		top.item = item;
    		top.next = oldTop;
    		size++;
    	}
    	
    	public Item pop() {
    		Item item = top.item;
    		top = top.next;
    		size--;
    		
    		return item;
    	}
    	
    	//以下部分是为了实现foreach打印
    	public Iterator<Item> iterator() {
    		return new ListIterator();
    	}
    	
    	private class ListIterator implements Iterator<Item> {
    		private Node current = top;
    		
    		public boolean hasNext() {
    			return current != null;
    		}
    		
    		public void remove() {}
    		
    		public Item next() {
    			Item item = current.item;
    			current = current.next;
    			return item;
    		}
    	}
    }
    
    public class Test {
    	public static void main(String args[]) {
    		Stack<String> s = new Stack();
    		
    		while(!StdIn.isEmpty()) {
    			String item = StdIn.readString();
    			if(!item.equals("-"))
    				s.push(item);
    			else if(!s.isEmpty()) 
    				System.out.print(s.pop() + " ");
    		}
    		
    	}
    }

    5:用链表实现队列以及背包

    链表实现队列

    import java.util.Iterator;
    
    
    public class Queue<Item> implements Iterable<Item>{
    	private Node first;
    	private Node last;
    	private int size;
    	private class Node {
    		Item item;
    		Node next;
    	}
    	
    	public boolean isEmpty() {
    		return first == null;
    	}
    	
    	public int size() {
    		return size;
    	}
    	
    	public void push(Item item) {
    		Node oldLast = last;
    		last = new Node();
    		last.item = item;
    		last.next = null;
    		
    		if(isEmpty())
    			first = last;
    		else
    			oldLast.next = last;
    		size++;
    	}
    	
    	public Item pop() {
    		Item item = first.item;
    		first = first.next;
    		
    		if(isEmpty())
    			last = null;
    		size--;
    		
    		return item;
    	}
    	
    	//以下部分是为了实现foreach打印
    	public Iterator<Item> iterator() {
    		return new ListIterator();
    	}
    		
    	private class ListIterator implements Iterator<Item> {
    		private Node current = first;
    			
    		public boolean hasNext() {
    			return current != null;
    		}
    			
    		public void remove() {}
    			
    		public Item next() {
    			Item item = current.item;
    			current = current.next;
    			return item;
    		}
    	}
    }
    


    用链表实现背包

    import java.util.Iterator;
    
    public class Bag<Item> implements Iterable {
    	private Node first;
    	private int size;
    	private class Node {
    		Item item;
    		Node next;
    	}
    	
    	public void add(Item item) {
    		Node oldFirst = first;
    		first = new Node();
    		first.item = item;
    		first.next = oldFirst;
    		size++;
    	}
    	
    	//以下部分是为了实现foreach打印
    	public Iterator<Item> iterator() {
    		return new ListIterator();
    	}
    			
    	private class ListIterator implements Iterator<Item> {
    		private Node current = first;
    				
    		public boolean hasNext() {
    			return current != null;
    		}
    				
    		public void remove() {}
    				
    		public Item next() {
    			Item item = current.item;
    			current = current.next;
    			return item;
    		}
    	}
    }
    






    展开全文
  • 本代码实现所需功能所需要理解的是栈后进先出队列是先进先出的特点,并掌握入队、入栈、出队、出栈的函数实现。 `//整体思路:利用后进先出队列的先进先出的特点,将一个数组序列分别输入队列中,然后...

    用栈和队列实现判断是否是回文序列

    在学习了栈和队列之后,为加强对栈和队列的熟练运用,特此运用栈和队列进行回文判断。虽然很麻烦,本来一个for循环就能解决的问题,但是增强了对栈和队列的理解和运用,还是值得一试的。
    本代码实现所需功能所需要理解的是栈有后进先出、队列是先进先出的特点,并掌握入队、入栈、出队、出栈的函数实现。
    `//整体思路:利用栈的后进先出和队列的先进先出的特点,将一个数组序列分别输入队列和栈中,然后分别依次弹出每个元素,如果每次弹出的都相同,则是回文序列,否则不是 
    

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    struct SeqQueue
    {
    int max;
    int front;
    int rear;
    char *dui;
    };
    typedef struct SeqQueue PSeqQueue;
    PSeqQueue createEmptyQueue_seq(int m) //创建队列
    {
    PSeqQueue q=(PSeqQueue)malloc(sizeof(PSeqQueue));
    if(q!=NULL)
    {
    q->dui=(char
    )malloc(sizeof(char)*m);
    if(q->dui)
    {
    q->max=m;
    q->front=0;
    q->rear=0;
    return q;
    }
    }
    else free(q);
    printf(“out of space!”);
    return NULL;
    }
    int isEmptyQueue(PSeqQueue p) //判断是否为空队列,若是空队列,返回0 ,有最好,无也行
    {
    if(p->front==p->rear) return 0;
    else return 1;
    }
    void enQueue_seq(PSeqQueue p,char x) //入队
    {
    if((p->rear)==p->max) printf(“Full Queue\n”);
    else
    {
    p->dui[p->rear]=x;
    p->rear=(p->rear+1)%(p->max);
    }
    }
    char deQueue_seq(PSeqQueue p) //出队
    {

    	int a=p->front;
    	p->front=(p->front+1)%(p->max);
    	return(p->dui[a]);
    

    }

    struct seqStack
    {
    int max;
    int t;
    char *s;
    };
    typedef struct seqStack PSeqStack;
    PSeqStack createEmptyStack(int m) //开始创建栈
    {
    PSeqStack q=(PSeqStack)malloc(sizeof(char));
    if(q!=NULL)
    {
    q->s=(char
    )malloc(sizeof(char)*m);
    q->t=-1;
    return q;
    }
    else {
    free(q);
    printf(“failed”);
    return NULL;
    }
    }
    void push_seq(PSeqStack p,char x)
    {
    if(p->t>=(p->max)-1) printf(“overflow”);
    else {
    p->t+=1;
    p->s[p->t]=x;
    }
    }
    char pop_seq(PSeqStack p)
    {
    if(p->t==-1) printf(“underflow”);
    else {
    int a=p->t;
    p->t=p->t-1;
    return(p->s[a]);
    }
    }
    int isEmptyStack(PSeqStack p)
    {
    if(p->t=-1) return 0;
    else return 1;
    }
    int main()
    {
    char str[50];
    printf(“请输入一个字符串:\n”);
    gets(str);
    int m=strlen(str);
    PSeqQueue duilie=createEmptyQueue_seq(m);
    PSeqStack zhan=createEmptyStack(m);
    int i,j;
    for(i=0;i<m;i++) //将数组str的元素入队和入栈
    {
    enQueue_seq(duilie,str[i]);
    push_seq(zhan,str[i]);
    }
    for(i=0;i<m;i++) //将数组str的元素出队和出栈,同时判断输出的元素是否相同
    {
    char a=deQueue_seq(duilie);
    char b=pop_seq(zhan);
    if(a!=b)
    {
    printf(“不是回文序列!”);
    return 0;
    }
    }
    printf(“是回文序列!”);
    return 0;
    }`

    展开全文
  • 栈是一种有序线性表,只能在表的一端进行插入和删除,最后插入的元素被第一个删除,所以栈是一种后进先出的线性表; 接下来还是上图 二、源码 这里直接看源代码吧,因为用单链表以及数组实现,如果前几篇...

    一、队列和栈

       什么是队列?队列是一种只能在一端插入,另外一端删除的有序线性表,队列中第一个插入也就第一个被移除,所以队列是一种先进先出的线性表;

       什么是栈?栈是一种有序线性表,只能在表的一端进行插入和删除,最后插入的元素被第一个删除,所以栈是一种后进先出的线性表;

       接下来还是上图

       

    二、栈源码

       这里直接看源代码吧,因为用单链表以及数组实现,如果前几篇看懂了实现一个栈还是很简单的,那我们直接看起源码来吧;

       还是老样子先看继承结构:

    public class Stack<E> extends Vector<E> 

       这里看下Stack这个类继承Vector这个类,那么我们就需要跳进去看下这个类的实现

    public class Vector<E>
        extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

      看到这个结构我们一定会很熟悉一下就想到了ArryList这个接口,所以这里不做过多的强调一些方法,这里只说一些重点内容;

       1).Vertor类所有方法都实现了同步,这里除去迭代的方法,因为每一个方法上都增加了synchronized这个关键字;

       2).这里强调一下扩容的方法,这里还的看下这个构造函数,才能对比出差别

        public Vector(int initialCapacity, int capacityIncrement) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            this.elementData = new Object[initialCapacity];
            this.capacityIncrement = capacityIncrement;
        }
        private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                             capacityIncrement : oldCapacity);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            elementData = Arrays.copyOf(elementData, newCapacity);
        }

       这个构造函数初始化了一个capacityIncrement变量这个影响了数组扩容的大小,如果不指定就是默认扩展一倍,看到这里如果看过的第一篇的读者就知道与ArryList的差别了,忘记的了也没关系,可以翻看一下,这里我们稍微延伸性下,由于每个操作都是同步的方法,肯定在操作会影响性能,但是我们通常进行的单一操作,不管是添加还是删除或者等等一系列操作,我们肯定还需要声明一个锁来保证操作的安全性,所以这就需要2个锁来解决线程的安全问题,想到这里大家就明白为什么Vector这个类被废弃了吧。接下来我们还是继续Stack这个类在Vector这个类上主要包括了栈的push和 pop 操作,以及取堆栈顶点的 peek方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search方法。

     三、队列源码

    public interface Queue<E> extends Collection<E> 

        同样是直接看源码吧,这里看到了Collection这个类,这里需要提一下Collections这2个是不同的类,Collection这个类是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。而这个Collections是一个包装类,它包含有各种有关集合操作的静态多态方法。此类不能实例化,就像一个工具类,服务于Java的Collection框架,关于这个类我后面会介绍下这个类的API,先说今天的重点吧,下图是Collection继承结构,图虽然有些不标准,相信大家基本上还是能看明白的。这里说下每个分支基本上能干什么事,对Connlection这个体系的集合有简单的明白;

       首先说一下Iterable,可以通过这个获取一个Iterator,使用这个进行迭代,下面是接口里面包含的方法;

      Iterator<T> iterator();

       接下来说Collection,这个里面主要包含一些对集合操作的方法,另外还有进行遍历的方法;剩下的子类就是对其扩展这里说下之间的不同,List这个接口是有序集合,可以根据索引进行值的查找,另外List里面可以允许重复值的出现;下面将List不同的API列出来让大家更明朗一些,可能没有复制全,因为源码注释有点多,另外就是List还提供listIterator这个方法,这个继承Iterator这个类,是集合可以向前迭代。

        E get(int index);
    
        E set(int index, E element);
    
        void add(int index, E element);
    
        E remove(int index);
    
        int indexOf(Object o);
    
        int lastIndexOf(Object o);
    
        ListIterator<E> listIterator();
    
        ListIterator<E> listIterator(int index);
    
        List<E> subList(int fromIndex, int toIndex);

        接下来是Set这个不允许保存重复的元素,Set在Collection的接口上没做什么变动,完全一样,SortedSet这个接口最要是一些排序接口,TreeSet主要实现了SortedSet这个接口,内部方法相对比较简单,主要通过Comparator这个接口进行实现一系列的接口;NavigableSet这个接口主要扩展SortedSet具有搜索元素的方法,这个里面的接口我感觉说不容易很没明白大家写个测试程序看下就可以,真的没什么搞头(我有测试程序大家想要可以私聊下我);

    public interface SortedSet<E> extends Set<E> {
         //返回一个比较器
        Comparator<? super E> comparator();
        //返回2个元素之间的集合
        SortedSet<E> subSet(E fromElement, E toElement);
       //返回小于该元素的集合
        SortedSet<E> headSet(E toElement);
      //返回大于或者等于该元素的集合
        SortedSet<E> tailSet(E fromElement);
         E first();//set中第一个元素  
        E last();//set中最后一个元素  
    }

        最后来一下今天的主题Queue,这里主要说下注意的地方Queue使用时要尽量避免Collection的add()和remove()方法,而是要使用offer()来加入元素,使用poll()来获取并移出元素。它们的优点是通过返回值可以判断成功与否,add()和remove()方法在失败的时候会抛出异常。 如果要使用头部元素而不移出该元素,使用
    element()或者peek()方法;接下来说下Deque这个接口,这个需要说下双端队列和队列的差别,队列只允许在一端插入,在另外一端删除,而双端队列是一种扩展,它可以在两端进行删除和插入;因为可以在两端访问所以是一种具有栈和队列性质的数据结构,这里需要说一下Stack这个接口因为是同步线程,我们在选择实现队列的时候应该优先选择Deque这个接口,下面可以列一个简单的对应关系,让大家明白这个接口内部方法与队列和接口的对应关系;

        

     

     四、结束语

       其实队列和栈里面的东西还有好多应用场景,以后有遇到再说喽,等等把map这些都说完的时候我做一个完整的集合的继承结构,接下来就是树喽,最近还有想法写下SSH,java我也进入到框架学习了,还有好多路要走,加油吧!

     

    转载于:https://www.cnblogs.com/wtzbk/p/7125989.html

    展开全文
  • 队列

    2019-10-25 10:14:19
    栈和队列 栈:限定仅在表尾进行插入和删除操作的线性表。允许插入和删除的一端称为栈顶,另一端称为栈底。...判断插在栈1还是栈2;2.1 若在栈1插入,则top1加1;在top1处填入x;2.2 若在栈2插入,则top2减...
  • 题目描述 用两个来实现一个队列 完成队列的Push和Pop操作 队列中的元素为int类型 ...栈是有序的 LIFO,也就是后进先出队列是有序的FIFO,也就是先进先出。 当然无论是栈还是队列,在Python中一般都用...
  • LIFO(last in first out)后进先出 2、队列 特点: 队列队头删除数据,队尾插入数据 FIFO(first in first out)先进先出一、那么如何利用两个实现一个队列? 我们知道不管队列中插入数据,还是删除数
  • 数据结构之 队列

    2020-05-27 13:20:37
    队列是计算机中基本的两个数据结构,可以达到后进先出队列可以先进先出。在实际应用上,我们可以使用进行逆序遍历链表,非递归中序遍历二叉树,括号匹配,函数调用等等;可以使用队列对二叉树进行层次遍历...
  • " 编程的本质来源于算法,而算法的本质来源于数学,编程只不过将数学题进行代码化。...栈栈 (Stack)一种后进先出(last in first off,LIFO)的数据结构。线性表用数组来实现的,对于这种只能一头插入删除...
  • 两个队列实现一个

    2019-06-24 15:54:21
    栈是后进先出 2.队列 我们现在想用连个队列来第一个输出4怎么办,大家很容易就想到按照下图的方法把队列中的123移到另一个队列,然后第一个队列只剩一个值4,pop这个值就行了。 当最后一个4pop后,你会发现...
  • 学习算法和数据结构:队列

    千次阅读 2018-02-04 00:37:25
    :LIFO(后进先出队列:FIFO(先进先出) 栈是限定仅在表尾进行插入和删除的线性表 队列是仅允许在一端插入在另一端删除的线性表 不论栈还是队列一种访问受限制的线性表 *补充:给定n个数,求...
  • 由于栈是一种后进先出的数据结构,而队列是一种先进先出的数据结构,两者互相实现时要借助一个辅助的/队列,主要的思想还是根据两个相同的数据运算来达到互相实现。 1,两个实现队列 保证辅助为空,而...
  • 学完队列想想其实就是学它们的思想(后进先出队列:先进先出),其实抓住了这两个关键内容,再记住一些常用操作格式,就好! 一、先讲讲的总结: 1.首先栈是后进先出的线性表(只在表尾进行操作)...
  • 队列的概念

    2017-08-07 15:31:00
    队列是非常重要的数据结构,后面要学习的很多算法都依赖于这俩数据结构,只要学过编程的人应该都对这两个东东有所耳闻,这里还是对其进行复习一下,进一步认识它们的...而为啥栈是后进先出的呢?下面看一下存...
  • 1、队列是先进先出,栈是后进先出。 2、队列的操作还是队列和出队列,入队列就把数据放到队列的尾部,出队列就把队列中的第一个数据拿出来。 队列需要两个标识,top和tail,分别标识队列的第一个元素和最后一个...
  • 现在要出栈,后进先出那么4要出栈。但是q1一个 队列,先进先出,那么 1 2 3出队列 q2 1 2 3 入队列,q1中此时剩余4,把4出对列达到出栈的效果。这个时候如果我们又加入一个元素5,那么我们应该把5放到 q1还是q2,...
  • 【探讨】队列

    2019-10-07 21:47:05
    又叫做后进先出(LIFO)结构。而队列对元素的插入和删除操作具有限制的数据结构的一员。队列又叫做先进先出(FIFO)结构。利用这两个,我们就可以做到请求管理了,当然要真正实现请求管理,其实还是有蛮多的工作要...
  • 队列(java)

    2018-04-29 17:13:51
    又称为后进先出的线性表的顺序存储结构:如用数组实现,:下标为0的一端的链式存储结构:链栈的入栈操作:链栈的出栈操作:Stack和VectorStack继承Vector,是栈结构,他们本质还是数组public class Vector...
  • 「@Author:Runsen」❝编程的本质来源于算法,而算法的本质来源于数学,编程只不过将数学题进行代码化。「---- Runsen」❞算法,一门既不容易入门,也不容易...栈栈 (Stack)一种后进先出(last in first off,LIF...
  • 队列知识点梳理

    2019-02-23 12:26:28
     特性:后进先出 出入数据都在栈顶 可以看作只能进行尾插尾删的线性表   底层选择链式空间还是连续空间? 顺序表只要不在头部和中间进行增删,就不需要进行数据的搬移,那么效率就非常高,并且顺序结构的...
  • C++算法之 两个队列实现一个

    万次阅读 2014-12-09 10:48:19
    现在要出栈,后进先出那么4要出栈。但是q1一个 队列,先进先出,那么 1 2 3出队列 q2 1 2 3 入队列,q1中此时剩余4,把4出对列达到出栈的效果。 这个时候如果我们又加入一个元素5,那么我们应该把5放到 q1还是...
  • 就像一个箱子,后放的在上边,所以后进先出先进后出,在栈顶做插入和删除操作 堆和它们不同,不存在先进后出还是先进先出。 **************************************************
  • 栈是后进先出的线性表,它只在一端进行操作;而与之相反的队列是一种先进先出的线性表,它只允许在表的一端进行插入,而在另一端进行删除元素。在操作过程中,都要建立一个空表初始化。时刻注意队列是否为空。 ...
  • 栈是一种LIFO(Last-In-First-Out,后进先出)的数据结构。其实通俗的讲就是最新添加的项最早被移除。而中项的插入(叫做推入)和移除(叫做弹出),只发生在一个位置——的顶部。 在ECMAScript中数组也提供...
  • 基本数据结构之队列

    千次阅读 2012-08-30 19:59:10
    前言:最近看各大公司的面试笔试题,发现对队列的考察还是挺多,而且这两个都经典的数据结构,...又称为后进先出LIFO (Last In First Out)或先进后出FILO (First In Last Out)线性表。  栈顶(Top):允许进行插
  • 就像一个箱子,后放的在上边,所以后进先出。 (堆和它们不同,不存在先进后出还是先进先出) 1.(Stack)操作系统在建立某个进程时或者线程(在支持多线程的操作系统中线程)为这个线程建立的...
  • 因为的特性是后进先出(LIFO),而队列的特性先进先出(FIFO),那两个连在一块儿,第一个先进后出,然后从第一个再入第二个还是先进后出,这样,先是倒序入第一,然后再倒序入第二个,倒序的倒序就是...
  • 这个题目作为的开始,我们需要先了解一下包括栈顶,底,栈顶指示器,空栈,满,上溢,下溢等概念,栈是一种特殊的一种顺序表,的特性是后进先出,并且不能插队进栈出栈。的基本操作还是比较容易的,...

空空如也

空空如也

1 2 3 4
收藏数 66
精华内容 26
关键字:

后进先出是队列还是栈