链接表是一种真正的动态数据结构，由一个个节点相互连接而构成，每一个节点包含数据和引用。相比于数组，查询速度慢，删除头元素方便，下面就是链表的实现过程
public class LinkedList<E> {
private class Node { //定义一个私有内部类代表每一个结点
public E e; //声明数据
public Node next; //声明结点引用，用于指向下一个结点
public Node(E e, Node next) {
this.e = e;
this.next = next;
}
public Node(E e) {
this(e, null);
}
public Node() {
this(null, null);
}
@Override
public String toString() {
return e.toString();
}
}
private Node dummyHead; //声明一个虚拟头结点，便于插入操作
private int size; //声明链表此寸大小
public LinkedList() { //无参构造函数生成一个数据和引用为空的结点
dummyHead = new Node(null, null);
size = 0;
}
public int getSize() { //获取链表尺寸大小
return size;
}
public boolean isEmpty() { //判断链表是否为空
return size==0;
}
//向链表中添加元素，对于链表来说是没有索引概念，这个index是对于用户来说的相当于数组中index
public void add(int index, E e) {
//判断索引合法性
if(index < 0 || index > size)
throw new IllegalArgumentException("Add failed.Illegal index.");
//从虚拟头结点开始遍历，一直遍历到要插入位置前一个结点
Node prev = dummyHead;
for(int i = 0; i < index; i++) {
prev = prev.next;
}
prev.next = new Node(e, prev.next); //将插入结点与下一个结点来连接，其上一个结点来连接此结点
size++; //维护size，自增加1
}
public void addFirst(E e) { //向链表头部添加结点
add(0, e);
}
public void addLast(E e) { //向链表尾部添加结点
add(size, e);
}
//根据索引获取元素
public E get(int index) {
//判断索引合法性
if(index < 0 || index >= size)
throw new IllegalArgumentException("Get failed.Illegal index.");
//从虚拟头结点下一个结点开始遍历，直到找到对应index结点
Node cur = dummyHead.next;
for(int i = 0; i < index; i++) {
cur = cur.next;
}
return cur.e;
}
public E getFirst() { //获取头部元素
return get(0);
}
public E getLast() { //获取尾部元素
return get(size - 1);
}
//修改指定位置的元素
public void set(int index, E e) {
//判断索引合法性
if(index < 0 || index >= size)
throw new IllegalArgumentException("Set failed.Illegal index.");
//从虚拟头结点开始遍历，找到相应节点
Node cur = dummyHead.next;
for(int i = 0; i < index; i++) {
cur = cur.next;
}
cur.e = e; //修改元素值
}
//判断是否包含相应元素
public boolean contain(E e) {
//从虚拟头结点开始循环整个链表，判断是否有相应的值
Node cur = dummyHead.next;
while(cur != null) {
if(cur.e.equals(e))
return true;
cur = cur.next;
}
return false;
}
//根据索引删除相应结点
public E remove(int index) {
//判断索引合法性
if(index < 0 || index >= size)
throw new IllegalArgumentException("Remove failed.Illegal index.");
//从虚拟头结点开始遍历，找到删除位置前一个节点，即前驱结点
Node prev = dummyHead;
for(int i = 0; i < index; i++) {
prev = prev.next;
}
Node retNode = prev.next; //保存这个删除结点，便于后面返回其值
prev.next = retNode.next; //将前驱结点指向删除结点下一个结点
retNode.next = null; //断开删除结点与下一个结点的连接
size--; //维护size,自减
return retNode.e;
}
public E removeFirst() { //头部删除
return remove(0);
}
public E removeLast() { //尾部删除
return remove(size - 1);
}
public void removeElement(E e){ //根据指定元素删除
//从虚拟头结点开始遍历，找到待删除元素的前驱系欸点
Node prev = dummyHead;
while(prev.next != null){
if(prev.next.e.equals(e)) //如果成立表明当前结点是前驱结点
break;
prev = prev.next;
}
if(prev.next != null){
Node delNode = prev.next;
prev.next = delNode.next;
delNode.next = null;
size --;
}
}
//重写toString方法，便于观察和打印
@Override
public String toString() {
StringBuilder res = new StringBuilder();
Node cur = dummyHead.next;
while(cur != null) {
res.append(cur + "->");
cur = cur.next;
}
res.append("NULL");
return res.toString();
}
}
下面是测试程序
public class Main {
public static void main(String[] args) {
LinkedList<Integer> linkedList = new LinkedList<>();
for(int i = 0; i < 5; i++) {
linkedList.addFirst(i);
System.out.println(linkedList);
}
linkedList.add(2, 666);
System.out.println(linkedList);
linkedList.remove(2);
System.out.println(linkedList);
linkedList.removeFirst();
System.out.println(linkedList);
linkedList.removeLast();
System.out.println(linkedList);
}
}
结果为
0->NULL
1->0->NULL
2->1->0->NULL
3->2->1->0->NULL
4->3->2->1->0->NULL
4->3->666->2->1->0->NULL
4->3->2->1->0->NULL
3->2->1->0->NULL
3->2->1->NULL
可以用这个链表来实现前面几篇中的栈和队列，实现代码如下
1.实现Stack
public class LinkedListStack<E> implements Stack<E> {
private LinkedList<E> list;
public LinkedListStack() {
list = new LinkedList<>();
}
@Override
public int getSize() {
return list.getSize();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public void push(E e) {
list.addFirst(e);
}
@Override
public E pop() {
return list.removeFirst();
}
@Override
public E peek() {
return list.getFirst();
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append("Stack: Top ");
res.append(list);
return res.toString();
}
}
1.实现Queue
public class LinkedListQueue<E> implements Queue<E> {
private class Node {
public E e;
public Node next;
public Node(E e, Node next) {
this.e = e;
this.next = next;
}
public Node(E e) {
this(e, null);
}
public Node() {
this(null, null);
}
@Override
public String toString() {
return e.toString();
}
}
private Node head, tail;
private int size;
public LinkedListQueue() {
head = null;
tail = null;
size = 0;
}
@Override
public int getSize() {
return size;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public void enqueue(E e) {
if (tail == null) {
tail = new Node(e);
head = tail;
} else {
tail.next = new Node(e);
tail = tail.next;
}
size++;
}
@Override
public E dequeue() {
if (isEmpty())
throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
Node retNode = head;
head = head.next;
retNode.next = null;
if (head == null)
tail = null;
size--;
return retNode.e;
}
@Override
public E getFront() {
if (isEmpty())
throw new IllegalArgumentException("Queue is empty.");
return head.e;
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append("Queue: front ");
Node cur = head;
while (cur != null) {
res.append(cur + "->");
cur = cur.next;
}
res.append("NULL tail");
return res.toString();
}
}
以上整个过程是关于实现LinkedList基本功能，其实链表还有双链表和循环链表，还可以继续开发，一起努力。