Java中的LinkedList简单实现

LinkedList结构是双向链表为了方便具体方法的实现，我们在链表的开头和结尾分别加了一个标记节点；开头处的叫头节点，结尾处的叫尾节点；
由于是双向链表，所以每个节点都有两个指针，分别是next和prev；

如下为方法简介：

虽然和java自带的LinkedList的方法还有差距，但是这只是我自己根据java提供的方法，自己实现的，一些细节上的东西，没有去深究，因为写出来只是为了更好地理解链表

1. void add(AnyType data)在尾部增加一个节点
2. add(int index, AnyType data)在指定的索引前面增加一个节点
3. addFirst(AnyType data)在开头增加一个节点
4. addLast(AnyType data)在结尾增加一个节点
5. boolean contains(AnyType data)测试是否包含指定元素
6. int indexOf(AnyType data)返回指定元素第一次出现的索引
7. void set(AnyType data, int index)通过索引修改指定节点的内容
8. void remove(int index)删除指定位置的节点
9. void remove(AnyType data)删除指定内容的节点
10. void removeFirst()删除第一个节点
11. void removeLast()删除最后一个节点
12. int size()返回链表的长度
13. AnyType getData(int index)返回指定位置的节点的内容
14. void showList()展示链表内容
15. void clear()清空链表
16. void push(AnyType data)入栈操作
17. void pop()出栈操作

Node节点类

链表的每一项都是一个节点Node，每个Node上有两个指针域和一个数据域

class Node<AnyType> {

	public AnyType data;//数据域
	public Node<AnyType> next;//指向后一个节点的指针
	public Node<AnyType> prev;//指向前一个节点的指针
	
	public Node(AnyType data, Node<AnyType> prev, Node<AnyType> next) {//有参构造
		this.data = data;
		this.prev = prev;
		this.next = next;
	}
	
	public Node() {//无参构造
	}
	
}

LinkedList实现：

开始有头结点begin和尾节点end，以及链表大小标记nodeSum

public class MyLinkedList2<AnyType> {
	private Node<AnyType> begin;
	private Node<AnyType> end;
	private int nodeSum;

	public MyLinkedList2() {
		this.begin = new Node<AnyType>(null, null, end);
		this.end = new Node<AnyType>(null, begin, null);
		this.nodeSum = 0;
	}

	public void add(AnyType data) {
		if (this.nodeSum == 0) {
			Node<AnyType> newNode = new Node<>(data, this.begin, this.end);
			this.begin.next = newNode;
			this.end.prev = newNode;
			this.nodeSum++;
		} else {
			Node<AnyType> newNode = new Node<>(data, this.end.prev, this.end);
			this.end.prev.next = newNode;
			this.end.prev = newNode;
			this.nodeSum++;
		}
	}

	public void add(int index, AnyType data) {
		Node<AnyType> pointNode = new Node<>();
		pointNode = this.begin;
		if (index < this.nodeSum) {
			for (int i = 0; i <= index; i++) {
				pointNode = pointNode.next;
			}
			Node<AnyType> newNode2 = new Node<>(data, pointNode.prev, pointNode);
			pointNode.prev.next = newNode2;
			pointNode.prev = newNode2;
			this.nodeSum++;
		}
	}

	public void addFirst(AnyType data) {
		Node<AnyType> newNode = new Node<>(data, this.begin, this.begin.next);
		this.begin.next.prev = newNode;
		this.begin.next = newNode;
		this.nodeSum++;

	}

	public void addLast(AnyType data) {
		Node<AnyType> newNode = new Node<>(data, this.end.prev, this.end);
		this.end.prev.next = newNode;
		this.end.prev = newNode;
		this.nodeSum++;
	}
	
	public boolean contains(AnyType data){
		Node<AnyType> newNode = new Node<>();
		newNode = this.begin;
		boolean flag = false;
		for(int i = 0;i<this.nodeSum;i++){
			newNode = newNode.next;
			if(newNode.data.equals(data) || newNode.data==data){
				flag = true;
				break;
			}else{
				flag = false;
			}
		}
		return flag;
	}
	
	public int indexOf(AnyType data){
		Node<AnyType> newNode = new Node<>();
		newNode = this.begin;
		int flag = 0;
		for(int i = 0;i<this.nodeSum;i++){
			newNode = newNode.next;
			if(newNode.data.equals(data) || newNode.data==data){
				flag = i;
				break;
			}else{
				flag = 0;
			}
		}
		return flag;
	}
	
	public void set(AnyType data, int index) {
		Node<AnyType> pointNode = new Node<>();
		pointNode = this.begin;
		for (int i = 0; i <= index; i++) {
			pointNode = pointNode.next;
		}
		pointNode.data = data;
	}

	public void remove(int index) {
		Node<AnyType> pointNode = new Node<>();
		pointNode = this.begin;
		for (int i = 0; i <= index; i++) {
			pointNode = pointNode.next;
		}
		pointNode.prev.next = pointNode.next;
		pointNode.next.prev = pointNode.prev;
		this.nodeSum--;
	}

	public void remove(AnyType data) {
		Node<AnyType> newNode = new Node<>();
		newNode = this.begin;
		for (int i = 0; i < this.nodeSum; i++) {
			newNode = newNode.next;
			if (newNode.data.equals(data) || newNode.data == data) {
				newNode.prev.next = newNode.next;
				newNode.next.prev = newNode.prev;
				break;
			}
		}
		this.nodeSum--;
	}

	public void removeFirst() {
		this.remove(0);
	}

	public void removeLast() {
		this.remove(this.nodeSum - 1);
	}

	public int size() {
		return this.nodeSum;
	}

	public AnyType getData(int index) {
		Node<AnyType> newNode = new Node<>();
		newNode = this.begin;
		if (index < this.nodeSum) {
			for (int i = 0; i <= index; i++) {
				newNode = newNode.next;
			}
		} else {
			newNode = this.begin;
		}
		return newNode.data;
	}

	public void showList() {
		Node<AnyType> newNode = new Node<>();
		newNode = this.begin;
		for (int i = 0; i < this.nodeSum; i++) {
			newNode = newNode.next;
			System.out.println(newNode.data);
		}
	}

	public void clear() {
		this.begin.next = this.end;
		this.end.prev = this.begin;
		this.nodeSum = 0;
	}

	public void push(AnyType data) {
		this.addFirst(data);
	}

	public void pop() {
		this.removeLast();
	}

	public static void main(String[] args) {测试函数
		MyLinkedList2<String> mll = new MyLinkedList2<>();
		mll.add("zhangsan");
		mll.add("lisi");
		mll.add("wangwu");
		mll.add("zhaoliu");
		mll.add("sunqi");
		mll.add("dengba");
		mll.add("wangjiu");
		mll.add("sunshi");
		mll.add(5, "moqixia");
		mll.set("zhangjiaozhu", 3);
		mll.remove("lisi");
		mll.removeFirst();
		mll.removeLast();
		System.out.println(mll.contains("zhangjiaozhu")+"     "+mll.indexOf("zhangjiaozhu")+"     "+mll.getData(5));
		mll.showList();
		mll.clear();
		System.out.println(mll.size());
	}
}

/*输出内容：
true     1     wangjiu
wangwu
zhangjiaozhu
sunqi
moqixia
dengba
wangjiu
0


*/