背包、队列和栈

三中基础集合数据类型的使用 

可迭代的基础数据类型的API

背包（Bag）

public class Bag<Item> implemrnts Iterable<Item>                                                         Bag()                 构造函数                                    void add(Item item)                添加一个元素                                     boolean isEmpty()                判断该背包是否为空                                                     int size()               度量该背包有多少元素

先进先出 FIFO 队列（Queue）

public class Queue<Item> implemrnts Iterable<Item>                                                        Queue()                                构造函数                               void                 enqueue(Item item)              添加一个元素                               Item                         dequeue()                    去掉一个最先加进来的元素                               boolean                 i sEmpty()                      判断该队列是否为空                               int                                 size()                       度量该背包有多少元素

后进先出 LIFO 栈（Stack）

public class Stack<Item> implemrnts Iterable<Item>                                                        Stack()                        构造函数                             void         push(Item item)                      添加一个元素                             Item         pop()                                     去掉一个最后加进来的元素                             boolean   isEmpty()                               判断该队列是否为空                                             int size()                                度量该背包有多少元素

一、背包是一种不支持从中删除元素的集合数据类型-----目的是帮助实例收集元素并迭代遍历所有元素。

例：计算一组样本数据的几个特征数（平均数、方差、标准差......）

public class Stats {
	
	public static void main(String[] args) {
		//创建一个背包对象用于收集盛放double类型的数据
		Bag<Double> dlist = new Bag<Double>();
		while(!StdIn.isEmpty()) {
			dlist.add(StdIn.readDouble());
		}
		
		int N = dlist.size();//元素个数
		double sum = 0;
		//遍历背包dlist求元素总和，然后求平均数
		for(double d:dlist) {
			sum+=d;
		}
		double mean = sum/N;
		
		//遍历背包，求离差平方和，然后求其标准差
		double s = 0;
		for(double d:dlist) {
			s+=(d-mean)*(d-mean);
		}
		
		double stdvar = Math.sqrt(s/N);
		
		StdOut.printf("Mean: %.2f\n",mean);
		StdOut.printf("StdVar: %.2f\n",stdvar);
		
	}

}

二、队列（Queue），先进先出队列

例：按顺序返回输入的数组

    public static int[] readInts() {
		Queue<Integer> intList = new Queue<Integer>();
		for(int i = 1;i<=100;i++) {
			intList.enqueue(i);
		}
		int N = intList.size();
		int[] a = new int[N];
		for(int i=0;i<N;i++) {
			a[i] = intList.dequeue();
		}
		return a;
		
	}

三、下压栈（简称栈）是一种后进后出策略的集合类型

例：（Dijkstra）算数表达式求值：

Dijkstra算法图解

public class ArithmeticExpression {
	public static void main(String[] args) {
        //操作数栈，用于存放操作数
		Stack<Double> numbers = new Stack<Double>();
        //操作符栈，用于存放操作符
		Stack<String> operaters = new Stack<String>();
		
		
		while(!StdIn.isEmpty()) {
            //用str变量存储读取变量
			String str = StdIn.readString();
			if(str.equals("(")) continue;//忽略左括号。

//将操作符全都放入操作符栈中
			else if(str.equals("+")) {operaters.push(str);}
			else if(str.equals("-")) {operaters.push(str);}
			else if(str.equals("*")) {operaters.push(str);}
			else if(str.equals("/")) {operaters.push(str);}
			else if(str.equals("sqrt")) {operaters.push(str);}
//遇到右括号则将后进入操作数栈的两个数字进行运算处理
			else if(str.equals(")")) {
				
					double a = numbers.pop();
					String s = operaters.pop();
					if(s.equals("+")) {a=numbers.pop()+a;}
					if(s.equals("-")) {a=numbers.pop()-a;}
					if(s.equals("*")) {a=numbers.pop()*a;;}
					if(s.equals("/")) {a=numbers.pop()/a;;}
					if(s.equals("sqrt")) {a=Math.sqrt(a);}
					numbers.push(a);
				
			}
			else {numbers.push(Double.parseDouble(str));}
			
		}
//最终剩余一个操作数时，该数即为运算的值
		System.out.println(numbers.pop());
	}
}