单链表的简单实现

节点类：

package net.hkh.classic.list;

import java.io.Serializable;

/**
* @desc: 节点类
* @author: houkh
* @date： Dec 3, 2014
*/
public class Node implements Comparable<Object>, Serializable {

private static final long serialVersionUID = 1L;

private Node next;
private Object value;

public Node() {
next = null;
value = null;
}

public Node(Object value) {
next = null;
this.value = value;
}

public Node(Node next, Object value) {
this.next = next;
this.value = value;
}

public Node getNext() {
return next;
}

public void setNext(Node next) {
this.next = next;
}

public Object getValue() {
return value;
}

public void setValue(Object value) {
this.value = value;
}

public int compareTo(Object node) {
if (node instanceof Node) {
Node nodeTwo = (Node) node;
String valueTwo = nodeTwo.getValue().toString();
String valueOne = value.toString();
try {
Integer intOne = Integer.valueOf(valueOne);
Integer intTwo = Integer.valueOf(valueTwo);
return intOne - intTwo;
} catch (Exception e) {

}
return valueOne.compareTo(valueTwo);
} else {
System.out.println("Must be a Node");
return 0;
}
}

public boolean equals(Object value) {
if (value.toString().equals(this.value.toString())) {
return true;
}
return false;
}

public String toString() {
return value.toString();
}
}


单链表类：
package net.hkh.classic.list;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import net.hkh.util.BeanUtils;
import net.hkh.util.SortUtils;

/**
* @desc：单链表
* @author: houkh
* @date： Dec 3, 2014
*/
public class SingleLinkedList implements Serializable {
private static final long serialVersionUID = 1L;

private Node head;// 头结点
private Node tail;// 尾结点
private int length;// 长度

public SingleLinkedList() {
this.head = null;
this.tail = null;
this.length = 0;
}

public void addHead(Node node) {
node.setNext(head);
head = node;
length++;
}

public void addTail(Node node) {
if (tail != null) {
tail.setNext(node);
tail = node;
} else {
head = tail = node;
}
length++;
}

public void addNode(int index, Node node) {
if (index >= length) {
System.out.println("Out of index");
return;
} else {
if (index == 0) {
addHead(node);
} else if (index == length - 1) {
addTail(node);
} else {
Node curNode = head;
while (index > 0) {
curNode = curNode.getNext();
index--;
}
node.setNext(curNode.getNext());
curNode.setNext(node);
length++;
}
}
}

public void delHead() {
if (head == null) {
System.out.println("Null Pointer");
return;
} else if (length == 1) {
head = tail = null;
length = 0;
return;
}
head = head.getNext();
length--;
}

public void delTail() {
if (head == null) {
System.out.println("Null Pointer");
return;
} else if (length == 1) {
head = tail = null;
length = 0;
return;
} else {
Node curNode = head;
while (curNode.getNext().getNext() != null) {
curNode = curNode.getNext();
}
curNode.setNext(null);
tail = curNode;
length--;
}
}

public void delNode(int index) {
if (index >= length) {
System.out.println("Out of index");
return;
}
if (index == 0) {
delHead();
return;
}
if (index == length - 1) {
delTail();
return;
}
Node curNode = head;
while (index > 1) {
curNode = curNode.getNext();
index--;
}
Node next = curNode.getNext().getNext();
curNode.getNext().setNext(null);
curNode.setNext(next);
length--;
}

public void setHead(Object value) {
head.setValue(value);
}

public void setTail(Object value) {
tail.setValue(value);
}

public void setNode(int index, Object value) {
Node curNode = getNode(index);
curNode.setValue(value);
}

public Node getHead() {
return head;
}

public Node getTail() {
return tail;
}

public Node getNode(int index) {
if (index >= length) {
System.out.println("Out of index");
return null;
}
if (index == 0) {
return getHead();
}
if (index == length - 1) {
return getTail();
}
Node curNode = head;
while (index > 0) {
curNode = curNode.getNext();
index--;
}
return curNode;
}

public int getLength() {
return length;
}

/**
* @desc 检查某值是否在链表中
* @param value
* @return
*
*/
public boolean contains(Object value) {
Node curNode = head;
while (curNode.getNext() != null) {
if (curNode.getValue().equals(value)) {
return true;
}
curNode = curNode.getNext();
}
return false;
}

/**
* @desc 如果node在list中存在，则返回第一次出现的位置，否则返回-1
* @param node
* @return
*
*/
public int indexOf(Object value) {
Node curNode = head;
int index = 0;
while (curNode.getNext() != null) {
if (curNode.getValue().equals(value)) {
return index;
}
curNode = curNode.getNext();
index++;
}
return -1;
}

/**
* @desc 交换两个节点的值
* @param one
* @param another
*
*/
public void swap(int one, int another) {
if (one >= length || another >= length) {
System.out.println("Out of index");
return;
}
Node oneNode = head;
Node anotherNode = head;
while (one > 0) {
one--;
oneNode = oneNode.getNext();
}
while (another > 0) {
another--;
anotherNode = anotherNode.getNext();
}
Object tmp = oneNode.getValue();
oneNode.setValue(anotherNode.getValue());
anotherNode.setValue(tmp);
}

/**
* @desc 正序排序
*
*/
public void sort() {
List<Node> list = new ArrayList<Node>();
Node curNode = head;
while (curNode.getNext() != null) {
list.add(curNode);
curNode = curNode.getNext();
}
list.add(curNode);
SortUtils.sort(list);
for (int i = 0; i < list.size(); i++) {
this.setNode(i, list.get(i).getValue());
}
}

/**
* @desc 逆序排序
*
*/
public void reverseSort() {
List<Node> list = new ArrayList<Node>();
Node curNode = head;
while (curNode.getNext() != null) {
list.add(curNode);
curNode = curNode.getNext();
}
list.add(curNode);
SortUtils.reverseSort(list);
for (int i = 0; i < list.size(); i++) {
this.setNode(i, list.get(i).getValue());
}
}

public void print() {
Node curNode = head;
while (curNode.getNext() != null) {
System.out.print(curNode.getValue() + "->");
curNode = curNode.getNext();
}
System.out.print(curNode.getValue() + "\n");
}

public boolean equals(Object value) {
if (value instanceof SingleLinkedList) {
SingleLinkedList list = (SingleLinkedList) value;
int len = list.length > this.length ? this.length : list.length;
for (int i = 0; i < len; i++) {
Node one = this.getNode(i);
Node two = list.getNode(i);
if (!one.equals(two)) {
return false;
}
}
if (this.length == list.length) {
return true;
} else {
return false;
}
} else {
return false;
}
}

public static void main(String[] args) throws Exception {
SingleLinkedList list = new SingleLinkedList();
list.addTail(new Node(1));
list.addTail(new Node(2));
list.addTail(new Node(3));
list.addHead(new Node(4));
list.addHead(new Node(5));
list.addNode(0, new Node(6));
list.addNode(5, new Node(7));
list.addNode(3, new Node(8));
list.addNode(5, new Node(9));
list.print();
System.out.println(list.getLength());
SingleLinkedList anotherList = (SingleLinkedList) BeanUtils
.cloneTo(list);
System.out.println(list == anotherList);
System.out.println(list.equals(anotherList));
}
}