数据结构-Java实现链表

概念

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间。

本文讲述使用Java实现单向链表、以及如何使用数据来实现单向链表

单向链表的Java实现

链表节点结构

package com.billJiang.stack;

/**
* Created by billJiang on 2016/11/30.
* 单向链表节点
*/
public class Node<T> {
private T item;

private Node<T> next;

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

public Node(T item, Node<T> next) {
this.item = item;
this.next = next;
}

public T getItem() {
return item;
}

public void setItem(T item) {
this.item = item;
}

public Node<T> getNext() {
return next;
}

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

链表实现

package com.billJiang.link;

import com.billJiang.stack.Node;

/**
* Created by billJiang on 2016/12/2.
* 单项链表
*/
public class Link<T> {

private int size = 0;
private Node<T> first;
private Node<T> last;

public void add(int index, T element) {
//TODO 书本60 61页有问题
if (index <= size && index >= 0) {
if (index == 0) {
addFirst(element);
} else if (index == size) {
addLast(element);
} else {
Node node = this.get(index - 1);
Node next = node.getNext();
Node cur = new Node(element, next);
node.setNext(cur);
size++;
}
} else {
throw new IndexOutOfBoundsException("索引越界");
}
}

//获取链表中的数据
public Node get(int index) {
Node node = first;
int i = 0;
while (node != null) {
if (index == i) {
return node;
}
i++;
node = node.getNext();
}
return null;
}

public T getValue(int index) {
return this.get(index) == null ? null : (T) this.get(index).getItem();
}

public void addFirst(T element) {
if (size == 0)
fillStart(element);
else {
Node<T> node = new Node(element, first);
first = node;
size++;
}
}

public void addLast(T element) {
Node<T> node = new Node(element, null);
last.setNext(node);
last = node;
size++;
}

public boolean isEmpty() {
return first == null && last == null;
}

public void fillStart(T element) {
Node<T> node = new Node(element, null);
first = node;
last = first;
size++;
}

public void remove(int index) {
if (index < size && index >= 0) {
if (index == 0) {
removeFirst();
} else if (index == size - 1) {
removeLast();
} else {
Node temp = this.get(index);
Node pre = this.get(index - 1);
pre.setNext(temp.getNext());
temp = null;
size--;
}
} else {
throw new IndexOutOfBoundsException("索引越界");
}
}

public void removeFirst() {
Node temp = first;
first = temp.getNext();
temp = null;
//如果只有一个元素，则first为null,将last也置为null
if (first == null) {
last = null;
}
size--;
}

public void removeLast() {
//找到倒数第二个
Node node = this.get(size - 2);
node.setNext(null);
last = node;
size--;
}

//链表反转
public void reverse(){
if(isEmpty()||size==1){
return;
}
Node pre=first;
last=pre;
for(Node node=first.getNext();node!=null;){
Node temp=node.getNext();
node.setNext(pre);
pre=node;
node=temp;
}
last.setNext(null);
first=pre;
}

public void printAll(){
for(Node<T> node=first;node!=null;node=node.getNext()){
System.out.print("-->"+node.getItem().toString());
}
}

}

测试

package com.billJiang.link;

/**
* Created by billJiang on 2016/12/2.
*/
public class LinkTest {
public static void main(String[] args) {
Link<Integer> link=new Link<Integer>();
link.add(0,1);
link.add(1,2);
link.add(2,3);
link.add(3,4);
link.add(4,5);
link.printAll();
link.remove(3);
System.out.println();
System.out.println("------after romeve--------");
link.printAll();
link.reverse();
System.out.println();
System.out.println("----after reverse-------");
link.printAll();
System.out.println();
System.out.println("hello world");
}
}

使用数组实现链表

节点结构定义

package com.billJiang.link;

/**
* Created by billJiang on 2016/12/2.
* 使用数组实现链表
*/
public class Element<T> {
T data;
int nextIndex;

public Element(T data,int nextIndex) {
this.data=data;
this.nextIndex=nextIndex;
}
}

具体实现

package com.billJiang.link;

/**
* Created by billJiang on 2016/12/2.
* 使用数据模拟链表
*/
public class LinkArray<T> {
private Element[] items;
private int size = 0;//元素个数
private int unused_head = 0;

//存储内容链表的头尾位置
private int first;
private int last;

public LinkArray(int capacity) {
items = new Element[capacity];
for (int i = 0; i < capacity - 1; i++) {
items[i] = new Element<>(null, i + 1);
}
items[capacity - 1] = new Element<>(null, -1);
}

public void add(int index, T data) {
if (index < 0 || index > size) {
throw new IndexOutOfBoundsException("索引越界");
}
if (checkFull()) {
return;//满了
}
if (index == 0) {
addFirst(data);
} else if (index == size) {
addLast(data);
} else {
//获取要插入位置的前一个元素
Element e = this.get(index - 1);
items[unused_head].data = data;
int unused = items[unused_head].nextIndex;
items[unused_head].nextIndex = e.nextIndex;
e.nextIndex = unused_head;
unused_head = unused;
size++;
}
}

public void addFirst(T data) {
if (this.isEmpty()) {
fillStart(data);
size++;
} else {
//空链表的下一个索引下标
int index = items[unused_head].nextIndex;
items[unused_head].data = data;
items[unused_head].nextIndex = first;
first = unused_head;
unused_head = index;
size++;
}
}

public void addLast(T data) {
int index = items[unused_head].nextIndex;
items[unused_head].data = data;
items[unused_head].nextIndex = -1;
items[last].nextIndex = unused_head;
last = unused_head;
unused_head = index;
size++;
}

public void remove(int index) {
if (index < 0 || index > size - 1) {
throw new IndexOutOfBoundsException("索引越界");
}
if (index == 0) {
removeFirst();
} else {
if (isEmpty())
return;
Element pre = get(index - 1);
int del = pre.nextIndex;
Element delElement = items[del];
pre.nextIndex = delElement.nextIndex;
if (index == size - 1) {
if (index >= 2)
last = get(index - 2).nextIndex;
else if (index == 1) {
last = first;
}
}
delElement.nextIndex = unused_head;
unused_head = del;
size--;
}

}

public void removeFirst() {
Element e = items[first];
if (size == 1) {
last = first;
}
items[first].data = null;
items[first].nextIndex = unused_head;
unused_head=first;
first = e.nextIndex;
size--;
}

public Element get(int index) {
Element e = items[first];
for (int i = 0; i < index; i++) {
e = items[e.nextIndex];
}
return e;
}

public boolean isEmpty() {
return size == 0;
}

public void fillStart(T data) {
Element element = items[unused_head];
element.data = data;
first = unused_head;
last = unused_head;
unused_head = element.nextIndex;
element.nextIndex = -1;
}

public boolean checkFull() {
if (size == items.length) {
return true;
}
return false;
}

}

测试

package com.billJiang.link;

/**
* Created by billJiang on 2016/12/2.
*/
public class LinkArrayTest {
public static void main(String[] args) {
LinkArray<Integer> la=new LinkArray<>(3);
la.add(0,1);
la.add(1,2);
la.add(0,3);
la.remove(0);
la.add(1,4);

}
}

链表特点

1、物理空间不连续，空间开销大

2、在运行时可以动态添加

3、查找元素需要顺序查找

4、操作略微复杂