精华内容
下载资源
问答
  • java堆栈队列

    2014-04-15 20:56:09
    java中自带实现堆栈队列的方法 堆栈

    java中自带实现堆栈与队列的方法

    堆栈

    package test.java;


    import java.util.Stack;


    /**
     * 堆栈类的使用
     * @author KING
     */
    public class TestStack {
    /*
    * public class Stack<E>extends Vector<E>Stack 类表示后进先出(LIFO)的对象堆栈。它通过五个操作对类
    * Vector 进行了扩展 ,允许将向量视为堆栈。它提供了通常的 push 和 pop 操作,以及取堆栈顶点的 peek 方法、测试堆栈是否为空的
    * empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。
    */
    public static void main(String[] args) {
    Person person1 = new Person();
    person1.setName("111");
    Person person2 = new Person();
    person2.setName("222");
    Person person3 = new Person();
    person3.setName("333");
    Person person4 = new Person();
    person4.setName("444");
    Stack<Person> stack = new Stack<Person>();
    stack.push(person1);// 把项压入堆栈顶部
    stack.push(person2);
    stack.push(person3);
    stack.push(person4);
    System.out.println(stack.toString());// 堆栈带toString()方法
    System.out.println(stack.peek());// 查看堆栈顶部的对象,但不从堆栈中移除它
    System.out.println(stack.search(person1));// 返回对象在堆栈中的位置,以 1 为基数
    System.out.println(stack.empty());// 测试堆栈是否为空。
    stack.pop();// 移除堆栈顶部的对象,并作为此函数的值返回该对象。
    System.out.println(stack.toString());
    }


    }

    队列

    本以为队列和堆栈一样也是实例化一个类来实现,写出来才发现,原来他是通过接口来实现的。

    package test.java;


    import java.util.LinkedList;
    import java.util.Queue;


    public class TestQueue {
    /**
    * 接口 Queue<E> 已知实现类有:
    * AbstractQueue, ArrayBlockingQueue, ArrayDeque,
    * ConcurrentLinkedQueue, DelayQueue, LinkedBlockingDeque,
    * LinkedBlockingQueue, LinkedList, PriorityBlockingQueue, PriorityQueue,
    * SynchronousQueue
    */
    public static void main(String[] args) {
    Person person1 = new Person();
    person1.setName("111");
    Person person2 = new Person();
    person2.setName("222");
    Person person3 = new Person();
    person3.setName("333");
    Person person4 = new Person();
    person4.setName("444");
    Queue<Person> queue = new LinkedList<Person>();
    /*
    * 如果可能,offer 方法可插入一个元素,否则返回 false。这与 Collection.add
    * 方法不同,该方法只能通过抛出未经检查的异常使添加元素失败。offer
    * 方法设计用于正常的失败情况,而不是出现异常的情况,例如在容量固定(有界)的队列中。
    */
    queue.offer(person1);
    queue.offer(person2);
    queue.offer(person3);
    queue.offer(person4);
            /*
             * 当我想用queue.toString()方法时在我的myeclipse中竟然显示他是一个object的toString.
             * 结果发现竟然还能用。经过查找toString在AbstractCollection类中,是myeclipse的显示问题
             */
    System.out.println(queue.toString());
    System.out.println(queue.peek());// element() 和 peek() 返回,但不移除,队列的头。
    /*
    * remove() 和 poll()
    * 方法可移除和返回队列的头。到底从队列中移除哪个元素是队列排序策略的功能,而该策略在各种实现中是不同的。remove() 和 poll()
    * 方法仅在队列为空时其行为有所不同:remove() 方法抛出一个异常,而 poll() 方法则返回 null。
    */
    System.out.println(queue.poll());
    System.out.println(queue.peek());
    }


    }

    用于实现测试的Person类

    package test.java;


    /**
     * 此类用来测试一些最基本的java编程思想
     */
    public class Person {
    private String name;// 声明成private只有在类的内部才能用(类名.)的方法调用。
    public int age;//共有成员变量
    protected final int headNum = 1;// 声明称protected一般情况下是为了继承,只有在一个包中的类才能访问


    /**
    * 所有的变量无论声明成私有的还是共有的都能够通过调用类中的方法来获得
    */
    public String getName() {
    return name;
    }


    public void setName(String name) {
    this.name = name;
    }


    public int getAge() {
    return age;
    }


    public void setAge(int age) {
    this.age = age;
    }


    public int getHeadNum() {
    return headNum;
    }


    @Override
    public String toString() {// toString是为了能够方便的输出类所有的成员变量,若果不构建toString方法无法直接输出一个类。
    return "Person [name=" + name + ", age=" + age + ", headNum=" + headNum
    + "]";
    }

    }

    展开全文
  • C#堆栈队列

    2021-05-09 16:33:48
    C#堆栈队列 此前已经采用 Array类和ArrayList类来把数据像列表一样组织在一起. 尽管这两种数据结构可以方便的把数据组织起来进行处理, 但是它们都没有为设计和实现实际问题的解决方案提供真正的抽象。 堆栈(stack)...

    C#堆栈和队列

    此前已经采用 Array类和ArrayList类来把数据像列表一样组织在一起. 尽管这两种数据结构可以方便的把数据组织起来进行处理, 但是它们都没有为设计和实现实际问题的解决方案提供真正的抽象。
    堆栈(stack)和队列(queue)是两种面向列表(list-oriented)的数据结构, 它们都提供了易于理解的抽象. 堆栈中的数据只能在表的某一端进行添加和删除操作, 反之队列中的数据则在表的一端进行添加操作而在表的另一端进行删除操作. 堆栈被广泛用于从表达式计算到处理方法调用的任何编程语言的实现中. 而队列则用在区分优先次序的操作系统处理以及模拟现实世界的事件方面, 比如银行出纳柜台的队列, 以及建筑物内电梯的操作。
    C#为使用这些数据结构提供了两种类:Stack 类和Queue类. 本章将会讨论如何使用这些类并且介绍一些实用的例子。

    堆栈, 堆栈的实现以及Stack 类

    正如前面提到的那样, 堆栈是最频繁用到的数据结构之一. 在堆栈中, 数据项只能从表的末端进行访问. 可访问的这端被称为是栈顶. 堆栈的标准模型是自助餐厅的盘子堆. 人们始终要从顶部拿走盘子, 而且当洗碗工或者杂工把盘子放回盘子堆的时候也是把它放在盘堆的顶部. 堆栈是著名的后进先出(LIFO)数据结构.

    堆栈的操作

    堆栈最基本的两种操作就是向堆栈内添加数据项以及从堆栈中删除数据项. Push(进栈)操作是向堆栈内添加数据项. 而把数据项从堆栈内取走则用 Pop(出栈)操作. 这些操作的实例说明可参见图5-1.

    展开全文
  • C#堆栈队列总结

    2019-10-14 11:17:27
    C#中的System.Collection类中包含栈和队列的数据结构,当然自己实现一个类也完全可以,这里主要介绍C#中的栈和队列。 一、栈(FILO) F12看Stack的定义。箭头所指的方法一般是我们常用的,可以看到这些方法都是...

    C#中的System.Collection类中包含栈和队列的数据结构,当然自己实现一个类也完全可以,这里主要介绍C#中的栈和队列。

    一、栈(FILO)

    F12看Stack的定义。箭头所指的方法一般是我们常用的,可以看到这些方法都是虚方法,说明我们可以创建自己的特殊栈类,继承该类然后对这些方法进行改写。注意这里的ToArray()方法,是将该栈的一个副本保存到一个数组中,需要一个object类型数组来接受它(当然可以类型转换),而CopyTo()功能更强,可以指定将该栈中的元素拷贝到一个数组中的指定位置。注意拷贝到数组中的顺序都是以它出栈的顺序来的。

    注:C#给定栈的默认大小是10,如果超过,则会自动增加空间,但是会出现额外性能损耗,假如堆栈里有20个元素且已经达到总容量,那么再增加一个元素会产生20+1个操作,因为给新元素腾出空间,需要移动栈里的每一个元素(这说明栈的底层应该也是数组实现的),所以最好在声明栈时给出栈的空间大小。

    下面示例一个栈的简单应用《十进制转其他进制的算法》:

            private static void NewMethod()
            {
                Stack stack2 = new Stack();
                //十进制转其他进制的方法
                Stack<int> stack = new Stack<int>();
                WriteLine("请输入要转换的十进制数:");
                int Num = int.Parse(ReadLine());
                WriteLine("请输入要转换的进制基数:");
                int baseNum = int.Parse(ReadLine());
                int temp = Num;
                do
                {
                    stack.Push(temp % baseNum);
                    temp = temp / baseNum;
                }
                while (temp != 0);
                WriteLine("转换后的结果为:");
                int j = stack.Count;
                for (int i = 0; i < j; i++)
                {
                    Write(stack.Pop());
                }
                WriteLine();
            }

    二、队列(FIFO)

    C#队列默认空间是32个,默认增加因子为2.0,也就是超过空间容量则会自动翻倍。大家也可以使用上述构造方法,设定初始容量和增长因子。其他方法与栈类似。注意这些都是虚方法,都可以在其父类中进行重写,比如基于该队列,我们可以构造一个优先队列类。

        public struct Patient
        {
            //值类型
            public int priority;
            public string name;
        }
        class PQueue : Queue
        {
            public PQueue() { }
            public override object Dequeue()
            {
                object[] patients;
                patients = this.ToArray();
                //下面的代码是将patients数组中的每一个元素按照其priority属性
                //由大到小排序 用了冒泡法排序
                //由于队列中元素的默认类型为object类,所以下面涉及了大量的装箱和拆箱操作
                //所有的类型都继承与object,当没有使用new时,object对象是值类型,否则是引用类型
                for (int i = 0; i < patients.Length-1; i++)
                {
                    for (int j = 0; j < patients.Length -i-1; j++)
                    {
                        //这里进行了拆箱操作
                        if(((Patient)patients[j]).priority < ((Patient)patients[j + 1]).priority)
                        {
                            //这里的object是值类型,进行了一次拆箱操作
                            object temp = patients[j];
                            patients[j] = patients[j + 1];
                            patients[j + 1] = temp;
                            //这里进行了一个装箱操作
                        }
                    }
                }
                this.Clear();
                for (int i = 0; i < patients.Length; i++)
                {
                    Enqueue(patients[i]);
                }
                return base.Dequeue();
            }
        }

    这里构造了一个优先队列类,出队列的时候会进行排序操作,按照优先级由高到低出队列。

            static void Main(string[] args)
            {
                PQueue pQueue = new PQueue();
                Patient[] patients = new Patient[3];
                for (int i = 0; i < patients.Length; i++)
                {
                    patients[i].priority = i;
                    patients[i].name = "order" + i;
                }
                //队列里目前是 0 order0  1 order1  2 order2
                for (int i = 0; i < patients.Length; i++)
                {
                    pQueue.Enqueue(patients[i]);
                }
                Patient nextPatient = (Patient)pQueue.Dequeue();
                //输出的时候队列已经倒序了
                WriteLine(nextPatient.priority + " " + nextPatient.name);
                //输出2 Order2
            }

    关于队列有很多应用,可以考虑使用System.Collection中的这些已提供的数据结构。 

     

    展开全文
  • "队列测试程序" << std::endl; Queque queque; queque.AddQ(1); queque.AddQ(2); queque.AddQ(3); queque.AddQ(4); queque.AddQ(5); queque.show(); queque.DeleteQ(); queque.show(); //queque.~...
  • java堆栈队列的相关函数使用堆栈队列 不对具体原理进行介绍,简单记录使用方式。 堆栈 后进先出(LIFO),java中一般使用Stack类。 public class run { public static void main(String[] args) { ...

    java堆栈、队列的相关函数使用


    不对具体原理进行介绍,简单记录使用方式。

    堆栈

    后进先出(LIFO),java中一般使用Stack类。

    public class run {
    
    	public static void main(String[] args) {
    		Stack<Integer> stack = new Stack<>();
    		//入栈,返回该元素
    		int pushItem = stack.push(1);
    		stack.push(2);
    		stack.push(3);
    		stack.push(4);	//stack:4 3 2 1
    		
    		//判断栈是否为空,空则返回true
    		if(!stack.isEmpty()){
    			//出栈,删除并返回栈顶元素;如果堆栈为空,会抛出异常
    			int popItem = stack.pop();	//popItem:4   stack:3 2 1
    		}
    		
    		//查看并返回栈顶元素,但是不删除它
    		int peekItem = stack.peek();	//peekItem:3   stack:3 2 1
    		
    		//查看某元素的位序,从栈底开始,即按照入栈顺序,栈底元素为0;没有该元素返回-1
    		int index = stack.indexOf(0);	//index:0
    
    		//查看某元素的位序,从栈顶开始,栈顶元素为1;没有该元素返回-1
    		int index2 = stack.search(0);	//index2:3
    
    	}
    }
    
    

    队列

    先进先出(FIFO),java中一般使用继承了Queue接口的LinkedList类。

    public class run {
    
    	public static void main(String[] args) {
    		Queue<Integer> queue = new LinkedList<>();
    
    		//入队列,成功返回true,失败返回false
    		queue.offer(1);
    		queue.offer(2);
    		queue.offer(3);
    		queue.offer(4);	//queue:1 2 3 4
    
    		//判断队列是否为空,空则返回true
    		if(!queue.isEmpty()){
    			//出队列,删除并返回队首元素;如果队列为空,则返回null
    			int head = queue.poll();	//head:1   queue:2 3 4
    		}
    		
    		//查看并返回队首元素,但是不删除它
    		int headItem = queue.peek();	//headItem:2   queue:2 3 4
    
    	}
    }
    
    展开全文
  • 堆栈队列 1、 堆栈 使用 LinkedList 实现堆栈:   /** * 使用 LinkedList 双向链表实现堆栈 * 2008.12.21 */   import java.util.LinkedList;   ...
  • 栈(stack)又名堆栈,它是一种先进后出(FILO)的线性表。其限制是仅允许在表的一端进行插入和删除运算。 队列 是一种先进先出的线性表。其限制仅在表的一端(尾端)进行插入,另一端(首端)进行删除的线性表,先进先...
  • 原理:堆栈类的底层是由栈实现的,栈是一种先进后出的数据结构,所以SplStack类的一些继承自SplDoublyLinkedList类的方法有一些理解上的不同,如rewind方法,spl使用rewind方法后指针将指向图中的栈顶,push和pop...
  • 实现list集合的常用子类用3个,Vector ,ArrayList, LinkedList 其中ArrayList是一个初始量为10的列表,是一个可变的数组集合类,继承List接口,除了覆盖List集合的所有方法,还有特有的方法 package org.blog.test;...
  • 接口是面向对象的一个重要的概念,利用接口使设计与实现分离,同时它也弥补了Java只支持但继承的不足,利用接口可以完成多继承的一些功能。 定义一个能够取数和送数的接口PutandGet,掌握接口的定义。 定义一个...
  • 它有两个基本操作:在队列尾部加人一个元素,和从队列头部移除一个元素就是说,队列以一种先进先出的方式管理数据,如果你试图向一个 已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索,将...
  • QueueQueue接口与List、Set同一级别,都是继承了Collection接口。LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限(即在方法中的参数类型如果是Queue时,就完全只能访问Queue接口所定义的...
  • LInkedList实现队列(Queue)和堆栈(Stack)

    千次阅读 2020-09-19 18:07:03
    通过LinkedList继承关系图我们可以发现,LinedList实现了Queue接口,Queue接口与List、Set同一级别,都是继承了Collection接口。Queue接口窄化了对LinkedList的方法的访问权限(即在方法中的参数类型如果是Queue时,...
  • 队列堆栈 队列和栈是常用和重要的数据结构。队列只允许在表的一端插入,在另一端删除,允许插入的一端叫做队尾,允许 除的一端叫做队头,是一种先进先出线性表。栈只允许在表的一端进行插入和删除操作...
  • 这篇文章的内容是受Vaidehi Joshi的“排队或不排队” 以及Base CS系列视频堆栈队列的启发在Vaidehi的帖子中,她解释了队列如何工作并显示了一些使队列入队和出队的“函数/方法”,这是一个简单直接的示例,向您...
  • 【Java】Java双端队列Deque使用详解

    万次阅读 多人点赞 2018-09-15 18:14:05
    Deque是一个双端队列接口,继承自Queue接口,它们共同的实现类是LinkedList。 Deque的功能很强大: 代替普通队列Queue:先进先出、队尾进队头出 可以作为双端队列:队尾和队头都可以进出 还可以作为堆栈...
  • 表,队列堆栈 我们再数据结构里面的上一级抽象可以具有 【实现】和【操作】 抽象表的《实现》 而实现是指,具体在内存空间中的表现形式 在【内存空间】中分为两个【区】,分别是【栈空间】,【堆空间】  ...
  • TestQueue.java package collection.others.... 将指定的元素插入此队列(如果立即可行且不会违反容量限制),在成功时返回 true,如果当前没有可用的空间,则抛出 IllegalStateException。 * 2. E element() 获取,但
  • 尽管某些实现将直接C用作其内部,但是此框架是相当高级的,并且在大多数情况下使用组合而不是继承。 该项目以“ Cocoa数据结构框架”的形式开始存在,该框架最初由Phillip Morelock于2002年撰写,目的是编写...
  • Deque双端队列

    2021-04-05 04:32:53
    Deque是一个双端队列接口,继承自Queue接口,Deque的实现类是LinkedList、ArrayDeque、LinkedBlockingDeque,其中LinkedList是最常用的。 Deque用途: //普通队列(一端进另一端出): Queue queue = new LinkedList();...
  • Java Deque双端队列

    2020-10-17 23:01:24
    Deque是一个双端队列接口,继承自Queue接口,Deque的实现类是LinkedList、ArrayDeque、LinkedBlockingDeque,其中LinkedList是最常用的。 Deque有三种用途: 普通队列(一端进另一端出): Queue queue = new ...
  • Java队列介绍&用队列实现栈

    万次阅读 2020-06-04 16:40:58
    本文将介绍队列的概念以及Java中队列Queue的继承关系。第二部分将用队列实现栈。
  • Java双端队列

    2021-07-10 20:39:39
    Java中双端队列Deque是一种数据结构,可以在其两端插入或删除元素,是队列与栈的结合,可以用于实现堆栈,列表和列表的操作,继承Queue接口。。 以下实例总结了Deque的实现与常用方法展示 public class Double...
  • C++ 队列

    2018-03-24 11:37:56
    C++ 队列 C++是C语言的继承,C语言是过程化程序设计语言,C++是面向对象的程序设计语言,过程化意思是编程的作用倾向于提供输入通过一系列的代码得到一个输出,面向对象则使适用于模块化设计,C语言的局限性在大型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,495
精华内容 14,998
关键字:

堆栈继承队列