链表的构造，获取，删除，顺序输出，倒序输出，反转

线性表的数据结构图：



链表简介：
    链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，这些节点不必在内存中相连。每个节点由数据部分Data和链部分Next，Next指向下一个节点，这样当添加或者删除时，只需要改变相关节点的Next的指向，效率很高。
    链表的实现还有其它的方式，常见的有循环单链表，双向链表，循环双向链表。 循环单链表 主要是链表的最后一个节点指向第一个节点，整体构成一个链环。 双向链表 主要是节点中包含两个指针部分，一个指向前驱元，一个指向后继元，JDK中LinkedList集合类的实现就是双向链表。** 循环双向链表** 是最后一个节点指向第一个节点。



操作的源码如下：
package com.wpao.data;

public class NodeTest {

/**
* @param args
*/
public static void main(String[] args) {
NodeTest nodetest = new NodeTest ();
Node<Students> head = null;
Node<Students> tail = null;
System.out.println("原链表：");
head = nodetest.constructNode(head);

Node<Students> remove = nodetest.remove(head,0);
nodetest.eachNode(remove);

Node<Students> get = nodetest.get(head, 0);
System.out.println("******"+((get!=null) ? get.item.toString():"不存在"));

/*
System.out.println("反转后：");
head = nodetest.fanzhuanNode(head);
nodetest.eachNode(head);

System.out.println("倒序便利：");
nodetest.reverseNode(head);

System.out.println("顺序便利：");
nodetest.eachNode(head);
*/
}

/**
* 删除特定元素：
* @param head
* @param i
* @return
*/
public Node<Students> remove(Node<Students> head,int i){
Node<Students> curr = null;
Node<Students> previous = null;

if(i<1){
System.out.println(" 该元素不存在，当前下标："+i+",设定第一个元素为1.");
}

curr = head;
int j = 1;
while(curr != null){
if(i==j){
if(previous==null){
return null;
}
previous.next = curr.next;
return head;
}
previous = curr;
curr = curr.next;
j+=1;
}

return head;
}

/**
* 获取特定元素：
* @param head
* @param i
* @return
*/
public Node<Students> get(Node<Students> head,int i){
Node<Students> curr = null;

if(i<1){
System.out.printl
4000
n(" 该元素不存在，当前下标："+i+",设定第一个元素为1.");
}

curr = head;
int j = 1;
while(curr != null){
if(i==j){
return curr;
}
curr = curr.next;
j+=1;
}

return null;
}

/**
* 将链表的顺序进行反转：逐一改变相邻两节点之间的关系，返回之前的尾节点处理;
* 注意点：对象的引用是同一个内存区域，一个引用修改，另一个引用也发生修改;
* @param head
* @return
*/
public Node<Students> fanzhuanNode (Node<Students> head){
Node<Students> curr = head;//i节点;
Node<Students> next = null;//i+1点;
Node<Students> previous = null;//i-1点;

while(curr != null){
next = curr.next;
if (next ==null){
curr.next = previous;
return curr;
}
curr.next = previous;
previous = curr;
curr = next;
}
return null;
}

/**
* 倒序便利：采用递归的思想，逐步取出最后一个元素，后输出;
* @param head
*/
public void reverseNode (Node<Students> head){
if(head!=null){
reverseNode(head.next);
System.out.println(" "+head.item);
}
}

/**
* 顺序便利：输出当前元素，然后将当前元素的指向为下一个元素;
* @param head 头节点：
*/
public void eachNode(Node<Students> head){
if(head==null){
System.out.println(" 链表为空！");
}

Node<Students> curr = head;
while(curr != null){
System.out.println(" "+curr.item);
curr = curr.next;
}
}

/**
* 构造链表：
* @param head 头节点;
* @param tail 尾节点;
*/
public Node<Students> constructNode(Node<Students> head){

//构造第一个节点：
head = new Node(new Students(1,"first1"));
Node<Students> tail = head;

//构造第二个节点：
tail.next = new Node(new Students(2,"first2"));
tail = tail.next;

for(int i=3;i<10;i++){
tail.next = new Node(new Students(i,"first"+i));
tail = tail.next;
}
return head;
}

}

/**
* 节点声明：
* @author dada
*
* @param <E>
*/
class Node<E> {

E item;
Node<E> next;

//构造函数
Node(E element) {
this.item = element;
this.next = null;
}
}

class Students {
private int id;
private String name;

public Students(int id, String name) {
super();
this.id = id;
this.name = name;
}

public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

@Override
public String toString() {
return " "+"Students [id=" + id + ", name=" + name + "]";
}
}