package demo;
import java.util.Collection;
public class MyLinkedList<E> {
// 属性
// 构造方法
public MyLinkedList() {
}
public MyLinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
// 构建双向链表,首先要构建节点
// 建立成员内部类节点,
private static class Node<E> {
E item; // 存储数据
Node<E> next;// 下一个节点
Node<E> prev; // 前一个节点
public Node(Node<E> next, E item, Node<E> prev) {
this.item = item;
this.next = next;
this.prev = prev;
}
}
// 一个数组域存放数组,一个prev指向前一个节点的next 一个next指向下一个节点的prev.
// 第一个节点
private Node<E> first;
// 最后一个节点
private Node<E> last;
// 数组个数
private int size;
// 将指定元素追加到此列表的末尾
public boolean add(E e) {
addLast(e);
return true;
}
// 将节点连接到此列表的末尾
void addLast(E e) {
Node<E> l = last; // 首先找到最后一个元素
Node<E> node = new Node<E>(null, e, l);// 根据传入的e创建一个新的节点next指向null
// item存传入的e prev指向l;
last = node; // 将刚刚新创建的节点node变为最后一个节点
if (l == null) { // 如果最后一个节点null
first = node; // 第一个节点就为node
} else {
l.next = node; // 将前一个节点的next指向下一个节点
}
size++; // size+1
}
public void addfirst(E e) {
linkfirst(e);
}
// 在此列表中的指定位置插入指定的元素
public void add(int index, E e) {
checkRange(index);// 首先判断范围
if (index == size) { // 如果插入的在最后一个就调用插入最后一个的方法
addLast(e);
} else { // 否则取到index位置对应的node元素,然后替换
Node<E> l = index(index);
addBeforeNode(e, l);
}
}
// 在指定元素前插入元素
private void addBeforeNode(E e, Node<E> l) {
Node<E> preNode = l.prev;
Node<E> newnode = new Node<>(l, e, preNode);
if (preNode == null) {
first = newnode;
} else {
preNode.next = newnode;
}
l.prev = newnode;
size++;
}
// 查找index出的元素
private Node<E> index(int index) {// 采用二分法查找
if (index < (size / 2)) { // 首先判断index在前一半还是后一半的范围,然后找到index出的元素
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
void linkfirst(E e) {
Node<E> l = first; // 首先找到第一个一个元素
Node<E> node = new Node<E>(l, e, null);// 根据传入的e创建一个新的节点next指向null
// item存传入的e prev指向l;
first = node; // 将刚刚新创建的节点node变为最后一个节点
if (l == null) { // 如果第一个节点null
first = node; // 第一个节点就为node
} else {
l.prev = node; // 将前一个节点的next指向下一个节点
}
size++; // size+1
}
// 删除所有的元素
public void clear() {
for (Node<E> x = first; x != null;) {
Node<E> next = x.next;
x.item = null;
x.prev = null;
x.next = null;
x = next;
}
first = last = null;
size = 0;
}
// 判断是否越界
private void checkRange(int index) {
if (index < 0 && index > size)
throw new IndexOutOfBoundsException("越界了");
}
// 返回列表中指定位置的元素
public E get(int index) {
checkRange(index);
return index(index).item;
}
//
private void addAll(Collection<? extends E> c) {
// TODO Auto-generated method stub
}
// 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
public int indexOf(Object o) {
Node<E> n = first;
int c = 0;
while (n != null) {
if (o != null) {
if (o.equals(n.item))
return c;
} else {
if (n.item == null) {
return c;
}
}
c++;
n = n.next;
}
return -1;
}
//删除指定节点
public E remove (int index){
checkRange(index);
return unlink(index);
}
//删除指定对象
public boolean remove(Object o){
int index = indexOf(o);
if(index<0){
return false;
}
unlink(index);
return true;
}
//删除index对应的节点的连接
private E unlink(int index){
Node<E> l = index(index);
E item = l.item;
Node<E> preNode = l.prev;
Node<E> nextNode = l.next;
if(preNode==null){
first = nextNode;
}else{
preNode.next=nextNode;
l.next=null;
}
if(nextNode==null){
last = preNode;
}else{
nextNode.prev = preNode;
l.prev=null;
}
size--;
l.item=null;
return item;
}
}
LinkedList是基于双向链表实现的， LinkedList和ArrayList的区别： ArrayList基于数组实现，因此具有数组的特点:有序.元素可重复.插入慢.查找快 LinkedList 基于双向链表实现， 因此具有链表特带你 插入快、 查找慢的特性；
