Java单链表的实现

/**
 * 
 */
package com.handy.ds;

/**
 * @author handy 2012-3-15
 */
class Node {
	int data;
	Node next;

	public Node() {

	}

	public Node(int data, Node next) {
		this.data = data;
		this.next = next;
	}
}

public class SingleLinkedList {
	private Node head;

	/**
	 * @return the head
	 */
	public Node getHead() {
		return head;
	}

	/**
	 * @param head
	 *            the head to set
	 */
	public void setHead(Node head) {
		this.head = head;
	}

	public SingleLinkedList() {
		head = new Node();
	}

	public boolean isEmpty() {
		if (head.next == null)
			return true;
		else
			return false;
	}

	public boolean addToLast(int elem) {
		if (isEmpty()) {
			head.next = new Node(elem, null);
			return true;
		} else {
			Node curr = head.next, prev = null;
			while (curr != null) {
				prev = curr;
				curr = curr.next;
			}
			Node newNode = new Node(elem, null);
			prev.next = newNode;
			return true;
		}

	}

	public boolean addToFirst(int elem) {

		if (isEmpty()) {
			head.next = new Node(elem, null);
			return true;
		} else {
			Node p = new Node(elem, head.next);
			head.next = p;
			return true;
		}
	}

	public void printList() {
		if (head.next == null) {
			System.out.print("空");
		}
		for (Node p = head.next; p != null; p = p.next)
			System.out.print(p.data + ",");
		System.out.println();

	}

	public boolean insert(int posValue, int elem) {
		if (isEmpty() && posValue == 0) {
			head.next = new Node(elem, null);
			return true;
		} else {
			Node prev = head, curr = head.next, newNode = new Node(elem, null);
			while (curr != null && curr.data != posValue) {
				if (curr.next == null)
					return false;
				prev = curr;
				curr = curr.next;
			}
			newNode.next = curr;
			prev.next = newNode;
			return true;
		}

	}

	public int removeFirst() {
		if (isEmpty()) {
			return -1;
		} else {
			Node temp = head.next;
			if (temp.next != null)// 有两个以上节点
				head = temp.next;
			else
				head.next = null; // 一个节点
			return temp.data;
		}

	}

	public int removeLast() {

		if (isEmpty()) {
			return -1;
		} else {
			int temp = 0;
			Node prev = head, curr = head.next;

			while (curr != null) {
				if (curr.next == null) {
					temp = curr.data;
					prev.next = null;
					// System.out.println(1);
				}
				prev = curr;
				curr = curr.next;
				return temp;
			}
			return temp;
		}

	}

	public boolean remove(int elem) {
		if (isEmpty())
			return false;
		else {
			Node prev = head, curr = head.next;
			while (curr != null && curr.data != elem) {
				if (curr.next == null) {
					return false;
				}

				prev = curr;
				curr = curr.next;

			}

			prev.next = curr.next;

			return true;
		}
	}

	// 返还重复节点 的个数
	public int getSameNumber(int value) {
		int count = 0;
		Node curr = head.next;
		while (curr != null) {
			if (curr.data == value)
				count++;
			curr = curr.next;
		}
		return count;
	}

	// 去掉重复节点
	public boolean removeSame() {
		Node p = head;
		Node curr1 = head.next;
		Node curr2 = null;
		int temp;
		while (curr1 != null) {
			if (getSameNumber(curr1.data) > 1) {
				temp = curr1.data;
				curr2 = curr1;
				while (curr2 != null) {
					// 去掉所有值为temp的节点
					remove(temp);
					curr2 = curr2.next;
				}
			}

			curr1 = curr1.next;

		}
		return true;
	}

	// 1.将单链表逆置
	public boolean reverse1() {
		if (isEmpty())
			return false;

		Node p = head, q = head.next;
		Node r;

		while (q != null) {
			r = q.next;
			q.next = p;
			p = q;
			q = r;

		}
		head.next.next = null;
		head.next = p;
		return true;
	}

	// 2.将单链表逆置
	public boolean reverse2() {
		if (isEmpty())
			return false;
		int size = 0;
		for (Node p = head.next; p != null; p = p.next)
			size++;
		int[] array = new int[size];
		int i;
		Node p;
		for (p = head.next, i = 0; p != null && i < size; p = p.next, i++)
			array[i] = p.data;
		for (p = head.next, i = 0; p != null && i < size; p = p.next, i++)
			p.data = array[size - 1 - i];

		return true;
	}

	// 判断链表是否存在循环
	public boolean isContainsLoop() {
		Node p = head, n = p;
		while (n.next != null && p != null) {
			p = p.next;
			n = n.next.next;
			if (p == n)
				return true;
		}
		return false;
	}

	// 使链表变为有循环的链表
	public void turnToLoopLink() {
		Node p = head;
		while (p.next != null) {
			p = p.next;
		}
		p.next = head.next;
	}

	// 去掉链表的循环
	public void turnToNoLoopLink() {
		Node p = head.next;
		while (p.next != null && p.next != head.next) {
			p = p.next;
		}
		p.next = null;
	}

	// 返还链表大小
	public int getSize() {
		Node p = head;
		int size = 0;
		while (p.next != null) {
			size++;
			p = p.next;
		}
		return size;
	}

	// 单链表按数据从小到大排序
	public void sortList() {
		Node p = head.next;
		int size = this.getSize();
		for (int i = 1; i < size; i++) {
			p = head.next;
			for (int j = 0; j < size - i; j++) {
				
				if (p.next != null && p.data > p.next.data) {
					int temp = p.data;
					p.data = p.next.data;
					p.next.data = temp;
				}
				p = p.next;
			}
		}

	}
}