堆栈与队列的不同之处

在这篇文章中，我们将详细讨论 “堆栈与队列 “的问题。

内容

• 什么是堆栈？
• 什么是队列？
• 堆栈和队列之间的区别。
• 堆栈和队列的相似之处。
• 实施。

什么是堆栈？

堆栈是一种线性数据结构，其中插入和删除操作都发生在一端。它是基于**LIFO（后进先出）**原则，插入和删除都只发生在一端。所以，堆栈基本上是一个从一端关闭的容器。在数组中，我们可以在任何时候访问数组中的任何元素，而在堆栈中，我们只能以顺序的方式访问堆栈中的元素。在堆栈中，我们只能插入相同数据类型的元素。

在堆栈中执行的操作

1. push(x) :它用来插入一个元素到堆栈的顶部。
   
   
2. pop() 。它将元素从顶部移除并返回其值。
   
   
3. peek() 。它返回存在于顶部的元素。
4. size()。它返回当前大小的尺寸。
5. isEmpty() 。如果堆栈是空的，即如果堆栈中没有任何元素存在，则返回真。

什么是队列？

队列是一种线性数据结构，它基于**先进先出（FIFO）**原则，即先插入的元素将先被删除。
与堆栈不同，队列是从两端打开的，从一端插入，从另一端删除。在队列中，插入的一端被称为 “后“，而删除的一端被称为 “前”。

在队列中执行的操作

1. enqueue() :它用于向队列中添加或插入一个项目。
2. dequeue() 。它用于从队列中删除一个项目并返回。
   
3. getFront() 。它返回队列中发生删除的前端元素。
4. getRear()。它返回队列的后部元素，在那里发生插入。
5. size() 。它返回队列的大小。

堆栈和队列之间的区别

1. 堆栈遵循LIFO（Last in First Out）原则，最后插入的元素将被首先删除。
   而队列遵循FIFO（First in First Out）原则，最先插入的元素将被首先删除。

2. 堆栈只从一端开放，插入和删除都从这一端发生，这也被称为顶部。 而
   队列则从两端开放。插入发生的那一端被称为后端，而删除发生的另一端被称为前端。

3. 堆栈主要执行推入和弹出两种操作。推入操作用于在堆栈中添加一个元素，弹出操作用于从堆栈中删除元素。 而
   队列也主要执行两个操作enqueue和dequeue。enqueue操作用于在队列中插入一个元素，而dequeue操作则是将元素从队列中移除。

4. 如果top==max-1，则堆栈被认为是满的，
   同样，如果rear==max-1，则队列被认为是满的
   。

5. 如果top==-1，则堆栈被认为是空的；如果
   front==-1或front=rear+1，则队列被认为是满的
   。

6. 堆栈被看作是垂直集合，而
   队列被看作是水平集合。

堆栈和队列的相似之处

1. 堆栈和队列都是线性数据结构，也就是说，它们中的元素是按顺序存储的。
2. 它们的大小都很灵活，可以根据输入的要求而增长。
3. 堆栈和队列都可以通过使用数组和关联列表来实现。

实现

在这里，我将使用关联列表来实现堆栈和队列，因为它是实现堆栈和队列的最有效的方法。

堆栈的关联列表实现

import java.io.*;
import java.util.*;

class Node{
    int data;
    Node next;
    Node(int d){
        data=d;
        next=null;
    }
}

class MyStack{
    Node head;
    int size;
    MyStack(){
        head=null;
        size=0;
    }
    
    void push(int x){
        Node temp=new Node(x);
        temp.next=head;
        head=temp;
        size++;
    }
    
    int pop(){
        if(head==null)
        {
            return Integer.MAX_VALUE;
        }
        int res=head.data;
        Node temp=head;
        head=head.next;
        size--;
        return res;
    }
    
    int peek(){
        if(head==null)
        {
            return Integer.MAX_VALUE;
        }
        return head.data;
    }
    
    int size(){
        return size;
    }
    
    boolean isEmpty(){
        return head==null;
    }
}

class Test{

public static void main (String[] args)
{
	MyStack s=new MyStack();
    s.push(15);
    s.push(10);
    s.push(25);
    System.out.println(s.pop());
    System.out.println(s.size());
    System.out.println(s.peek());
    System.out.println(s.isEmpty());
}
}

队列的关联列表实现

import java.util.*;
import java.io.*;
import java.lang.*;
class Node { 
	int val; 
	Node next; 

	 
	public Node(int val) 
	{ 
		this.val = val; 
		this.next = null; 
	} 
} 


class Queue { 
	Node front, rear; 

	public Queue() 
	{ 
		this.front = this.rear = null; 
	} 

	
	void enqueue(int val) 
	{ 

		
		Node temp = new Node(val); 

		
		if (this.rear == null) { 
			this.front = this.rear = temp; 
			return; 
		} 

		
		this.rear.next = temp; 
		this.rear = temp; 
	} 

	 
	void dequeue() 
	{ 
		
	if (this.front == null) 
			return; 

		
		Node temp = this.front; 
		this.front = this.front.next; 

		
		if (this.front == null) 
			this.rear = null; 
	} 
} 

 
public class Test { 
	public static void main(String[] args) 
	{ 
		Queue q = new Queue(); 
		q.enqueue(10); 
		q.enqueue(20); 
		q.dequeue(); 
		q.dequeue(); 
		q.enqueue(30); 
		q.enqueue(40); 
		q.enqueue(50); 
		q.dequeue(); 
		System.out.println("Queue Front : " + q.front.val); 
		System.out.println("Queue Rear : " + q.rear.val); 
	} 
} 

堆栈与队列的动态实现的主要区别是：

1. 在堆栈中，我们只定义了一个指向堆栈顶部元素的指针 “head”，而在队列中，我们定义了两个指针 “front “和 “rear”，分别指向队列的第一个和最后一个元素。
2. 当在堆栈中插入元素时，我们使头部指针指向我们要插入的元素，而在队列中我们使后部指针指向我们要插入的元素。
3. 当从堆栈中移除一个元素时，我们使头部指针指向head.next，而在队列中我们使前部指针指向front.next。