基本知识:
队列:先进先出。场景:排队购票
栈:先进后出。 场景:邮箱
以下是对栈和队列的基本操作,分别通过数组和链表进行实现
import java.util.LinkedList;
/**
*
* @author
*/
class Node<T> {
Node next;
T data;
public Node() {
}
public Node(T data) {
this.data = data;
}
}
class myLink {
Node head;
//头插法、相当于栈、插入一个节点先进后出
public void add(Node newNode) {
newNode.next = head;
head = newNode;
// if (head == null) {
// head = newNode;
// } else {
// newNode.next = head;
// head = newNode;
// }
}
public boolean delete(Node delNode) {
if (delNode == null || delNode.next == null) {
return false;
}
Node temp = delNode.next;
delNode.data = temp.data;
delNode.next = temp.next;
return true;
}
void display() {
Node temp = head;
while (temp != null) {
System.out.println(temp.data);
temp = temp.next;
}
}
}
class Stack<T> {
Node top;
//进栈 //头插法、相当于栈、插入一个节点先进后出
public void push(T data) {
Node newNode = new Node(data);
newNode.next = top;
top = newNode;
}
//出栈
public T pop() {
if (top == null) {
return null;
} else {
T data = (T)top.data;
top = top.next;
return data;
}
}
public boolean isEmpty(){
return top==null;
}
//返回栈顶
public T peek() {
return (T)top.data;
}
//时间复杂度O(n^2)空间复杂度O(n)
public Stack<T> sortStack(Stack<T> unsortedStack){
Stack sortedStack=new Stack();
while(!unsortedStack.isEmpty()){
int temp=(Integer)unsortedStack.pop();
while(!sortedStack.isEmpty()&&(Integer)unsortedStack.peek()>temp){
unsortedStack.push((T) sortedStack.pop());
}
sortedStack.push(temp);
}
return sortedStack;
}
}
//设计一个栈,除了pop、push外,还支持min方法(时间复杂度都为1)
//缺点:用了多余的空间记录每个节点的min
class StackWithMin extends Stack<NodeWithMin>{
public void push(int data){
int newMin=Math.min(data, min());
super.push(new NodeWithMin(data, newMin));
}
public int min(){
if (this.isEmpty()) {
return Integer.MAX_VALUE;
}else{
return peek().min;
}
}
}
class NodeWithMin{
public int data;
public int min;
public NodeWithMin(int data, int min) {
this.data = data;
this.min = min;
}
}
//节省空间
class StackWithMin1 extends Stack<Integer>{
Stack<Integer> temp;
public StackWithMin1() {
temp=new Stack<>();
}
public void push(int data){
if (data<=min()) {
temp.push(data);
}else{
super.push(data);
}
}
@Override
public Integer pop(){
int data=(int)super.pop();
if (data==min()) {
temp.pop();
}
return data;
}
public int min(){
if (temp.isEmpty()) {
return Integer.MAX_VALUE;
}else{
return temp.peek();
}
}
}
//队列
class Queue {
Node first, last;
//入队、新增元素添加到了表尾部 //尾插法、先进先出
void enQueue(Object data) {
if (first == null) {
first = new Node(data);
last = first;
} else {
last.next = new Node(data);
last = last.next;
}
}
//出队
Object deQueue() {
if (first != null) {
Object data = first.data;
first = first.next;
return data;
}
return null;
}
}
//不同种类的动物的先进先出,为每种动物创建一个队列,然后将两者放入包裹类中
abstract class Animal{
private int order;
protected String name;
public Animal(String name){
this.name=name;
}
public void setOrder(int order){
this.order=order;
}
public int getorder(){
return order;
}
public boolean isOlderThan(Animal animal){
return this.order<animal.order;
}
}
class Dog extends Animal{
public Dog(String name){
super(name);
}
}
class Cat extends Animal{
public Cat(String name){
super(name);
}
}
class AnimalQueue{
LinkedList<Dog>dogs=new LinkedList<>();
LinkedList<Cat>cats=new LinkedList<>();
private int order=0;
public void enAnimalQueue(Animal animal){
animal.setOrder(order);
order++;
if (animal instanceof Dog) {
dogs.addLast((Dog)animal);
}else if (animal instanceof Cat) {
cats.addLast((Cat)animal);
}
}
public Animal deAnimalQueue(){
//查看首部弹出最旧的值
if(dogs.size()==0){
return cats.poll();
}else if(cats.size()==0){
return dogs.poll();
}
//如果两种动物都有选择个自最老的
Dog dog=dogs.peek();
Cat cat=cats.peek();
if (dog.isOlderThan(cat)) {
return dogs.poll();
}else{
return cats.poll();
}
}
}
//数组实现
class StackByArr<T> {
private T[] stack;
private int N;
public StackByArr(int N) {
stack = (T[]) new Object[N];
}
public boolean isEmpty() {
return N == 0;
}
public int size() {
return N;
}
private void resize(int max) {
T[] temp = (T[]) new Object[max];
System.arraycopy(stack, 0, temp, 0, max);
stack = temp;
}
public void push(T data) {
if (N == stack.length) {
resize(2 * stack.length);
}
stack[N++] = data;
}
public T pop() {
stack[N] = null; //避免对象游离
if (N > 0 && N == stack.length / 4) {
resize(stack.length / 2);
}
return stack[--N];
}
}
class QueueByArr<T> {
T[] queue;
int head = 0;
int tail = 0;
int N = 0;
public QueueByArr(int size) {
this.queue = (T[]) new Object[size];
}
public boolean isEmpty() {
return head == queue.length;//线性实现,浪费了一些空间,可改进为循环实现
}
public boolean isFull() {
return tail == queue.length - 1;
}
public void enQueue(T data) {
if (isFull()) {
System.out.println("队列已满");
}
{
queue[++tail] = data;
}
}
public T deQueue() {
if (isEmpty()) {
System.out.println("队列已空");
}
return queue[head++];
}
}
public class Test {
public static void main(String[] args) {
System.out.println("MyStack Test:");
Stack stack = new Stack();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack.pop());
stack.push(4);
System.out.println(stack.pop());
System.out.println("MyQueue Test:");
Queue queue = new Queue();
queue.enQueue('a');
queue.enQueue('b');
queue.enQueue('c');
System.out.println(queue.deQueue());
queue.enQueue('d');
System.out.println(queue.deQueue());
System.out.println("MyLink Test:");
myLink mLink = new myLink();
Node node1 = new Node(1);
Node node2 = new Node(2);
Node node3 = new Node(3);
mLink.add(node1);
mLink.add(node2);
mLink.add(node3);
mLink.display();
mLink.delete(node2);
System.out.println("删除节点之后:");
//删除节点后
mLink.display();
}
}