算法--基础算法--栈、队列、背包（链表实现）、动态数组

游离：保留一个不需要的对象的引用.

 foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组。foreach 语句用于循环访问集合以获取所需信息，但不应用于更改集合内容以避免产生不可预知的副作用。
 

    语法格式:
                               for(type x : conllection){

                               }

   实例：

                         public class Test {

                           public static void main(String[] args)  {

                               int[] a = {1,2,3};

                               for(int i : a)

                               System.out.print(i + ",");

                            }

                          }  
当使用foreach循环来迭代输出数组元素或集合元素时，通常不要对循环变量进行赋值，虽然这种赋值在语法上是允许的，但没有太大的实际意义，而且极容易引起错误。

用foreach来迭代访问数组元素时，foreach中的循环变量相当于一个临时变量，系统会把数组元素依次赋给这个临时变量，而这个临时变量并不是数组元素，它只是保存了数组元素的值。因此，如果希望改变数组元素的值，则 不能使用这种foreach循环。

算法1.1--下压（LIFO）栈（能够动态调整数组大小的实现）

优点：几乎达到了任意集合类数据类型实现的最佳性能：

每项操作的用时都与集合大小无关；

空间需求总是不超过集合大小乘以一个常数；

ResizingArrayQueue的缺点在于某些push()和pop()操作会调整数组的大小：这项操作的耗时和栈大小成正比。

import java.util.Iterator;
public class ResizingArrayStack<Item> implements Iterable<Item> 
{
private Item[] a=(Item[]) new Object[1];  //栈元素
private int N=0;                                       //元素数量
public boolean isEmpty()      { return N==0; }
public int size()                     { return N;        }
private void resize(int max)
{   //将栈移动到一个大小为max的新数组
Item[] temp=( Item[] ) new Object[max];
for(int i=0;i<N;i++)
temp[i]=a[i];
a=temp;
}
public void push(Item item)
{ //将元素添加到栈顶
if(N==a.length) resize(2*a.length);
a[N++]=item;
}
public Item pop()
{ //从栈顶删除元素
Item item=a[--N];
a[N]=null;       //避免对象游离
if(N>0 && N==a.length/4) resize(a.length/2);
return item;
}
public Iterator<Item> iterator()
{
return new ReverseArrayIterator();
}
private class ReverseArrayIterator implements Iterator<Item>
{ //支持后进先出的迭代
private int i=N;
public boolean hasNext() { return i>0; }
public Item next()             { return a[--i]; }
public void remove()        {                   }

}

       //测试用例
public static void main(String[] args) {
ResizingArrayStack<Integer> s = new ResizingArrayStack<Integer>();
for (int i = 0; i < 10; i++) {
s.push(i);
}
for (Integer integer : s) {
System.out.println("foreach:" + integer);
}
ResizingArrayStack<Integer>.ReverseArrayIterator r = (ResizingArrayStack<Integer>.ReverseArrayIterator) s.iterator();
while (r.hasNext()) {
System.out.println("iterator:" + r.next());
}
}

｝

这份泛型可迭代的Stack API的实现是所有集合类抽象数据类型实现对模版。

算法1.2--下压堆栈（链表实现)

import java.util.Iterator;
public class Stack<Item> implements Iterable<Item> 
{
private Node first;  //栈顶（最近添加的元素）
private int N;         //元素数量
private class Node
{ //定义了节点的嵌套类
Item item;
Node next;
}
public boolean isEmpty() { return first==null; }  //或：N==0
public int size()                { return N; }
public void push(Item item)
{ //向栈顶添加元素
Node oldfirst=first;
first=new Node();
first.item=item;
first.next=oldfirst;
N++;
}
public Item pop()
{ //从栈顶删除元素
Item item=first.item;
first=first.next;
N--;
return item;
}
//iterator()的实现请见算法1.4中下部分内容（支持迭代）
public Iterator<Item> iterator() {
// TODO Auto-generated method stub
return new listIterator() ;
}
private class listIterator implements Iterator<Item> {
private Node current = first;
public boolean hasNext() {
return current != null;
}
// 获取头结点
public Item next() {
Item item = current.item;
current = current.next;
return item;
}
}
//测试用例main()是实现如下
public static void main (String[] args) {
Stack<String> stack=new Stack<String>();
for (String string : args) {
if (!string.equals("-")) {
stack.push(string);
}
else if (!stack.isEmpty()) {
System.out.print(stack.pop()+" ");
}
}
System.out.println("("+stack.size()+" left on stack"+")");
}
}

这份泛型的Stack实现的基础是链表数据结构。它可以用于创建任意数据类型的栈。

算法1.3--先进先出队列

import java.util.Iterator;
public class Queue<Item> implements Iterable<Item>
{
private Node first;   //指向最早添加的节点的链接
private Node last;   //指向最近添加的节点的链接
private int N;          //队列中的元素数量
private class Node
{ //定义了结点的嵌套类
Item item;
Node next;
}
public boolean isEmpty() { return first==null; } //或：N==0
public int size()                { return N; }
public void enqueue(Item item)
{ //向表尾添加元素
Node oldlast=last;
last=new Node();
last.item=item;
last.next=null;
if(isEmpty())  first=last;
else               oldlast.next=last;
N++;
}
public Item dequeue()
{ //从表头删除元素
Item item=first.item;
first=first.next;
if(isEmpty())  last=null;
N--;
return item;
}
//iterator（）的实现--在类名后面加上implements Iterable<Item>   （支持迭代）
public Iterator<Item> iterator()
{
return new listIterator();
}
public class listIterator implements Iterator<Item>
{
private Node current=first;
public boolean hasNext()
{
return current!=null;
}
public Item next() 
{
Item item=current.item;
current=current.next;
return item;
}
}
//测试用例
public static void main(String[] args)
{
Queue<String> queue=new Queue<String>();
for(String string : args)
{
if(!queue.equals('-'))
queue.enqueue(string);
else if(!queue.isEmpty())
System.out.println(queue.dequeue()+" ");
}
System.out.println("("+queue.size()+" left on  Stack"+")");
}
}

这份泛型的Queue实现的基础是链表数据结构。它可以用于创建任意数据类型的队列。

算法1.4--背包

通过add()添加元素，size()和isEmpty()方法和Stack中完全相同。就是把push()改为add(),删除pop()即可。

import java.util.Iterator;
public class Bag<Item> implements Iterable<Item> 
{
private Node first;  //栈顶（最近添加的元素）
private int N;         //元素数量
private class Node
{ //定义了节点的嵌套类
Item item;
Node next;
}
public boolean isEmpty() { return first==null; }  //或：N==0
public int size()                { return N; }
public void add(Item item)
{ //向栈顶添加元素
Node oldfirst=first;
first=new Node();
first.item=item;
first.next=oldfirst;
N++;
}
//iterator()的实现请见算法1.4
public Iterator<Item> iterator() {
// TODO Auto-generated method stub
return new listIterator() ;
}
private class listIterator implements Iterator<Item> {
private Node current = first;
public boolean hasNext() {
return current != null;
}
// 获取头结点
public Item next() {
Item item = current.item;
current = current.next;
return item;
}
}
//测试用例
public static void main (String[] args) {
Bag<Integer> bag=new Bag<Integer>();
/*for (String string : args) 
if (!string.equals("-")) 
bag.add(string);  */
for (int i = 0; i < 10; i++) {
bag.add(i);
}
for (Integer integer : bag) {
System.out.println("foreach:" + integer);
}
    System.out.println("("+bag.size()+" left on bag"+")");
}
}