数据结构与算法分析-Java描述（1）

主要就是来贴学习代码的，视频中使用面向对象的思想，设计了基于java语言的一些基本线性结构，分别有面向对象的数组，栈，队列，单链表，循环链表，双向链表（非循环和循环）还有递归的两个好玩的实例。

1. 栈

   public class MyStack {
   	
   	int[] elements;
   	
   	public MyStack() {
   		elements = new int[0];
   	}
   
   	//压入元素
   	public void push(int element) {
   		int[] newArr = new int[elements.length+1];
   		for(int i = 0; i < elements.length; i++) {
   			newArr[i] = elements[i];
   		}
   		newArr[elements.length] = element;
   		elements = newArr;
   	}
   	
   	//取出栈顶元素
   	public int pop() {
   		if(elements.length == 0) {
   			throw new RuntimeException("空栈");
   		}
   		int element = elements[elements.length - 1];
   		//创建一个新的数组
   		int[] newArr = new int[elements.length - 1];
   		//原数组中除了最后一个元素的其他元素都放入新的数组中
   		for(int i = 0; i< elements.length-1; i++) {
   			newArr[i] = elements[i];
   		}
   		elements = newArr;
   		return element;
   	}
   	
   	//获取栈顶元素
   	public int peek() {
   		return elements[elements.length-1];
   	}
   	
   	//栈是否为空
   	public boolean isEmpty() {
   		return elements.length == 0;
   	}
   }

   把栈类比于弹夹就可以，先进后出，压栈就是装弹，弹栈就是扣下扳机。
2. 队列

   public class MyQueue {
   	
   	int[] elements;
   	
   	public MyQueue() {
   		elements = new int[0];
   	}
   	
   	//入队
   	public void add(int element) {
   		int[] newArr = new int[elements.length+1];
   		for(int i = 0; i < elements.length; i++) {
   			newArr[i] = elements[i];
   		}
   		newArr[elements.length] = element;
   		elements = newArr;
   	}
   	
   	//出队
   	public int poll() {
   		//把第0个取出
   		int element = elements[0];
   		
   		int[] newArr = new int[elements.length-1];
   		
   		for(int i = 0;i<elements.length;i++) {
   			newArr[i] = elements[i+1];
   		}
   		
   		elements = newArr;
   		
   		return element;
   	}
   	
   	//判断为空
   	public boolean isEmpty() {
   		return elements.length == 0;
   	}
   
   }

   队列就是队伍，先进的先出去。
3. 单链表

   public class Node {
   	
   	//节点内容
   	int data;
   	//下一个节点
   	Node next;
   	
   	public Node(int data) {
   		this.data = data;
   	}
   	
   	//为节点追加节点
   	//改变方法类型，可以连续追加，每次返回的都是统一的类型
   	public Node append(Node node) {
   		//当前节点
   		Node currentNode = this;//使用this可以取本类
   		//循环向后找
   		while(true) {
   			//取出下一个节点
   			Node nextNode = currentNode.next;
   			//如果下一个节点为null，当前节点已经是最后一个节点
   			if(nextNode == null) {
   				break;
   			}
   			//赋给当前节点
   			currentNode = nextNode;
   		}
   		//把需要追加的节点  追加为  找到的当前节点的   下一个节点
   		currentNode.next = node;
   		return this;
   	}
   	
   	//获取下一个节点
   	public Node next() {
   		return this.next;
   	}
   	
   	public void show() {
   		Node currentNode = this;
   		while(true) {
   			System.out.print(currentNode.data+" ");
   			currentNode = currentNode.next;
   			if(currentNode == null) {
   				break;
   			}
   		}
   		System.out.println();
   	}
   	
   	//删除下一个节点
   	public void removeNext() {
   		//取出下一个节点的下一个节点
   		Node newNext = next.next;
   		//将下下节点赋给下一个节点
   		this.next = newNext;
   	}
   	
   	//插入一个节点作为当前节点的下一个节点
   	public void after(Node node) {
   		//取出下一个节点，作为下下一个节点
   		Node newNext = next;
   		//把新节点作为当前节点的下一个节点
   		this.next = node;
   		//把下下一个节点设置为新节点的下一个节点
   		node.next = newNext;
   	}
   	
   	
   	public int getData() {
   		return this.data;
   	}
   	
   	public boolean isLast() {
   		return next == null;
   	}
   
   }

   每个单链表节点所包含的有节点内容和下一个节点。
4. 循环链表

   public class LoopNode {
   
   	//节点内容
   	int data;
   	//下一个节点
   	LoopNode next = this;
   		
   	public LoopNode(int data) {
   		this.data = data;
   	}
   		
   		
   	//获取下一个节点
   	public LoopNode next() {
   		return this.next;
   	}
   		
   	//删除下一个节点
   	public void removeNext() {
   		//取出下一个节点的下一个节点
   		LoopNode newNext = next.next;
   		//将下下节点赋给下一个节点
   		this.next = newNext;
   	}
   		
   	//插入/追加一个节点作为当前节点的下一个节点
   	public void after(LoopNode node) {
   		//取出下一个节点，作为下下一个节点
   		LoopNode newNext = next;
   		//把新节点作为当前节点的下一个节点
   		this.next = node;
   		//把下下一个节点设置为新节点的下一个节点
   		node.next = newNext;
   	}
   	
   	
   	public int getData() {
   		return this.data;
   	}
   	
   	public boolean isLast() {
   		return next == null;
   	}
   }

   相比于单链表就多了一个尾指针指向首节点。
5. 双向循环链表

   public class DoubleNode {
   	
   	//上一个
   	DoubleNode pre = this;
   	//下一个
   	DoubleNode next = this;
   	
   	int data;
   	
   	public DoubleNode(int data) {
   		this.data = data;
   	}
   	
   	//增加节点
   	public void after(DoubleNode node) {
   		//原来的下一个节点
   		DoubleNode newNext = next;
   		//把新节点作为当前节点的下一个节点
   		this.next = node;
   		//把当前节点做新节点的前一个节点
   		node.pre = this;
   		//让原来的下一个节点的上一个节点为新节点
   		newNext.pre = node;
   	}
   	
   	public DoubleNode next() {
   		return this.next;
   	}
   	
   	public DoubleNode pre() {
   		return this.pre;
   	}
   	
   	public int getData() {
   		return this.data;
   	}
   
   }

   

   双向循环链表图解：前后互指，尾指头

6. 递归 

1.斐波那契数列（又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*））

//打印第n项斐波那契数列
public static int febonacci(int i) {
	if(i == 1 || i == 2) {
		return 1;
	}else {
		return febonacci(i-1)+febonacci(i-2);
	}
}

2.汉诺塔（由三根杆子A，B，C组成的。A杆上有N个(N>1)穿孔圆盘，盘的尺寸由下到上依次变小。要求按下列规则将所有圆盘移至C杆：每次只能移动一个圆盘；大盘不能叠在小盘上面。）

/**
* @param n 共有n个盘子
* @param from 开始的柱子
* @param in 中间的柱子
* @param to 目标柱子
* 无论有多少个盘子，都认为只有两个盘子，上面的所有盘子和最下面的一个盘子
*/
public static void hanoi(int n,char from,char in,char to) {
	if(n==1) {
		System.out.println("第1个盘子从"+from+"移到"+to);
	}else {
		//移动上面的所有盘子到中间位置
		hanoi(n-1,from,to,in);
		//移动下面的盘子
		System.out.println("第"+n+"个盘子从"+from+"移到"+to);
		//把上面的所有盘子从中间位置移到目标位置
		hanoi(n-1,in,from,to);
	}
}