算法学习（4）-------数据结构基础之栈和队列

一、栈

      

1、栈的概念

      栈是一种逻辑结构，线性数据结构，它的元素遵循先入后出原则（FILO,First In Last Out),最早进入的元素存放的位置叫栈底，最后进入的元素存放的位置叫栈顶。
      栈这种数据结构既可以用数组来实现，也可以用链表来实现。
      

2、栈的操作

      （1）入栈
      入栈就是把元素放入栈中，栈只允许从栈顶一侧放入元素，新放入的元素成为栈顶。
      （2）出栈
      出栈就是将元素从栈中弹出，弹出的元素只能是栈顶，然后，栈顶的前一个元素变为新的栈顶。

出栈和入栈都只涉及一个元素，时间复杂度为O（1），下面是数组实现栈的代码；

import java.util.Arrays;
import java.util.EmptyStackException;

public class ArrayStack {

	private int[] data = new int[10];
	private int size;// 元素个数

	// 入栈
	public void push(int dataT) {
		// 判断数组长度是否够
		if (size > data.length) {
			data = Arrays.copyOf(data, data.length * 2);
		}
		data[size++] = dataT;
	}

	// 查看栈顶元素
	public int peek() {
		if (size == 0) {
			throw new EmptyStackException();
		}
		return data[size - 1];
	}

	// 移除栈顶
	public int pop() {
		int dataT = this.peek();
		size--;
		return dataT;
	}

	// 判断栈是不是空
	public boolean empty() {
		return size == 0;
	}

	// 返回元素在栈中的位置
	public int research(int dataT) {
		for (int i = size - 1; i >= 0; i--) {
			if (dataT == data[i]) {
				return size - i;
			} else {
				return -1;
			}
		}
		return -1;
	}
	
	public static void main(String[] args)
	{
		ArrayStack as = new ArrayStack();
		as.push(1);
		as.push(2);
		as.push(23);
		as.push(24);
		as.push(25);
		as.push(26);
		int result = as.peek();
		System.out.println(result);
		System.out.println("-----------------------");
		as.pop();
		int resultT = as.peek();
		System.out.println(resultT);
		System.out.println("-----------------------");
		int i = as.research(25);
		System.out.println(i);
		
		
	}
}

---

二、队列

      

1、队列的概念

      队列是一种逻辑结构，线性数据结构，它的元素遵循先入先出原则（FIFO,First In First Out),队列的出口端叫队头，入队的那一端叫队尾。队列就是像排队过隧道的车
      队列这种数据结构既可以用数组来实现，也可以用链表来实现。
      

2、队列的操作

      （1）入队
      入队就是把元素放入队列中，队列只允许从队尾一侧放入元素，新放入的元素成为队尾。
      （2）出队
      出队就是将元素移出队列，只能移出队头，然后，队头的后一个元素变为新的队。

出队和入队都只涉及一个元素，时间复杂度为O（1），但是因为不断出队，用数组实现的队列队头一侧的空间就没用了，导致队列的容量越来越小，所以采用循环队列来维持队列容量，代码如下：

public class MyQueue {
	private int[] array;
	private int front;
	private int rear;
	
	public MyQueue(int capacity) {
		this.array = new int[capacity];
	}
	
	/**
	 * 入队
	 * @param element 入队的元素
	 */
	public void enQueue(int element) throws Exception{
		if((rear + 1) % array.length == front) {
			throw new Exception("队列已满");
		}
		array[rear] = element;
		rear = (rear+1)%array.length;
	}
	
	/**
	 * 出队
	 * 
	 */
	public int deQueue() throws Exception{
		if(rear == front)
		{
			throw new Exception("队列已空");
		}
		
		int deQueueElement = array[front];
		front = (front + 1) % array.length;
		return deQueueElement;
	}
	
	/**
	 * 输出队列
	 */
	public void output()
	{
		for(int i = front; i != rear; i=(i+1)%array.length)
		{
			System.out.println(array[i]);
		}
	}
	
	public static void main(String[] args) throws Exception{
		MyQueue myQueue = new MyQueue(10);
		myQueue.enQueue(1);
		myQueue.enQueue(2);
		myQueue.enQueue(3);
		myQueue.enQueue(4);
		myQueue.enQueue(5);
		myQueue.enQueue(6);

		myQueue.deQueue();
		myQueue.deQueue();
		myQueue.output();
		
		
		
	}
}

---