数据结构-链表

复习:


数据结构：就是一个有一定规则的能够存储数据的一个内存中空间。


最基础的存储空间: 变量（单个存储空间），数组（连续存储空间）


1、栈 : 内部就是数组，单个变量实现（链表）
   
   a、stack   b、自定义（数组，可变的数组）


   原则：先进后出


2、队列


   原则：先进先出， 


   线性队列，循环队列。


   都使用到两个变量标示符，都是处于上增加的状态。






数据结构中，链表结构；


1、变量，数组


2、链表的结构是使用多个变量来实现的。


3、链表和数组对比，数组在遍历的时候效率比较高，进行修改删除插入操作，
   数组效率就比较低（需要把空的空间补充完整）。


   链表遍历效率低，增删改的操作，效率是比较高的。

异常处理

package com.salmon.test;
/**
 * 描述节点类
 * @author salmon
 *
 */
public class Node {

	// 用来放本身这个节点上存储数据
	private Object  obj;
	//指向下一个节点引用
	private Node   next;
	//
	public   Node(Object obj){
		this.obj = obj;
		this.next = null;
	}
	
	public Object getObj() {
		return obj;
	}
	public void setObj(Object obj) {
		this.obj = obj;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	
}

package com.salmon.test;

/**
 * 描述节点之间关系，链表   单项链表
 * 
 * @author salmon
 * 
 */
public class LinkedDemo {

	// 计数器
	private int num = 0;
	// 表头
	private Node head;

	// 给这个链表中添加节点
	public void add(Object obj) {
		Node node = new Node(obj);
		// 第一个进来
		if (head == null) {
			head = node;
		} else {
			// 不是第一个
			// 把原来的表头放在临时 变量上
			Node temp = head;
			// 把当前的节点作为表头
			head = node;
			// 让这个新表头 执行之前的标头
			head.setNext(temp);
		}
		// 数量都在累加
		num++;
	}

	// 链表的长度
	public int size() {
		return num;
	}

	// 查看表头
	public Object queryHead() {
		return head.getObj();
	}

	// 取出表头
	public Object deleteHead() {
		Object obj = head.getObj();
		head = head.getNext();
		num--;
		return obj;
	}

	// 查看链表中指定的一个节点
	public Object queryNode(Object obj) {
		Object o = null;
		// 判断你要查看节点是不是 表头
		if (head.getObj().equals(obj.toString())) {
			o = head.getObj();
		} else {
			// 如果不是表头
			Node node = this.getNode(head.getNext(), obj);
			o = node.getObj();
		}
		return o;
	}

	// 查找某一个节点
	private Node getNode(Node node, Object obj) {
		if (node.getObj().equals(obj.toString())) {
			return node;
		} else {
			return getNode(node.getNext(), obj);
		}
	}

	// 指定节点删除
	public Object deleteNode(Object obj) {
		Object o = null;
		// 判断你要查看节点是不是 表头
		if (head.getObj().equals(obj.toString())) {
			o = head.getObj();
			head = head.getNext();
		} else {
			// 如果不是表头
			Node node = this.delNode(head, obj);
			o = node.getObj();
		}
		return o;
	}

	// 删除节点
	private Node delNode(Node node, Object obj) {
		Node n = node.getNext();
		//  用当前节点的上一个节点 指向 当前节点的下一个
		if (n.getObj().equals(obj.toString())) {
			node.setNext(n.getNext());
			return n;
		} else {
			return getNode(node.getNext(), obj);
		}
	}

}

package com.salmon.test2;
/**
 * 描述节点类
 * @author salmon
 *
 */
public class Node {

	// 用来放本身这个节点上存储数据
	private Object  obj;
	//指向下一个节点引用
	private Node   next;
	// 指向上一个节点引用
	private Node   up;
	
	public   Node(Object obj){
		this.obj = obj;
		this.next = null;
		this.up = null;
	}
	
	public Object getObj() {
		return obj;
	}
	public void setObj(Object obj) {
		this.obj = obj;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}

	public Node getUp() {
		return up;
	}

	public void setUp(Node up) {
		this.up = up;
	}
	
}

package com.salmon.test2;

/**
 * 描述节点之间关系，链表   双向链表
 * 
 * @author salmon
 * 
 */
public class LinkedDemo {

	// 计数器
	private int num = 0;
	// 表头
	private Node head;
    private Node end;
	// 给这个链表中添加节点
	public void add(Object obj) {
		Node node = new Node(obj);
		// 第一个进来
		if (head == null) {
			// 把当前节点作为头  并且也是尾
			head = node;
			end = node;
		} else {
			// 不是第一个
			// 把原来的表头放在临时 变量上
			Node temp = head;
			// 把当前的节点作为表头
			head = node;
			// 让这个新表头 执行之前的标头
			head.setNext(temp);
			// 指向它的上一个节点
			temp.setUp(head);
			
		}
		// 数量都在累加
		num++;
	}

	// 链表的长度
	public int size() {
		return num;
	}
	// 查看尾
	public Object queryEnd(){
		return  end.getObj();
	}
	// 查看表头
	public Object queryHead() {
		return head.getObj();
	}
	// 删除表尾
	public Object deleteEnd(){
		 Object o = end.getObj();
		 end = end.getUp();
		 num--;
		 return o;
	}
	// 取出表头
	public Object deleteHead() {
		Object obj = head.getObj();
		head = head.getNext();
		num--;
		return obj;
	}

	// 查看链表中指定的一个节点
	public Object queryNode(Object obj) {
		Object o = null;
		// 判断你要查看节点是不是 表头
		if (head.getObj().equals(obj.toString())) {
			o = head.getObj();
		} else {
			// 如果不是表头
			Node node = this.getNode(head.getNext(), obj);
			o = node.getObj();
		}
		return o;
	}

	// 查找某一个节点
	private Node getNode(Node node, Object obj) {
		if (node.getObj().equals(obj.toString())) {
			return node;
		} else {
			return getNode(node.getNext(), obj);
		}
	}

	// 指定节点删除
	public Object deleteNode(Object obj) {
		Object o = null;
		// 判断你要查看节点是不是 表头
		if (head.getObj().equals(obj.toString())) {
			o = head.getObj();
			head = head.getNext();
		} else {
			// 如果不是表头
			Node node = this.delNode(head, obj);
			o = node.getObj();
		}
		return o;
	}

	// 删除节点
	private Node delNode(Node node, Object obj) {
		Node n = node.getNext();
		//  用当前节点的上一个节点 指向 当前节点的下一个
		if (n.getObj().equals(obj.toString())) {
			node.setNext(n.getNext());
			return n;
		} else {
			return getNode(node.getNext(), obj);
		}
	}
	//  从表尾  开始  进行链表遍历
	public  void  info(){
		this.getNode2(end);
	}
	private  void  getNode2(Node node){
		System.out.println(node.getObj());
		if(node.getUp() != null){
			getNode2(node.getUp());
		}
	}
	

}