链表用java实现简单单链表linkedlist

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

每个结点包括两个部分：

1是存储数据元素的数据域data

2是存储下一个结点地址的指针域p。

相比于线性表的优点：插入和删除结点方便。（插入删除的图都不画了，办公软件不好用）

这里是对单链表的理解，并用java的泛型实现，当然与java集合提供的API  LinkedList<E>还是有些不同的，在此只作为理解。

project






首先构造一个Node结点泛型类，结点里的数据类型是泛型E

public class Node<E> {
E element;//元素
Node<E> next; //指针
public Node(E e){
element=e;
}
}
MyAbstractList.java抽象类实现MyList.java,对接口部分实现，MyLinkedList.java继承MyAbstractList.java抽象类
MyList.java
public interface MyList<E> {
//添加一个元素
public void add(E e);
//在index处添加一个元素
public void add(int index,E e);
//清楚一个list列表
public void clear();
//删除一个元素
public boolean remove(E e);
//删除并返回index处的元素
public E remove(int index);
//index处的元素设置为元素e
public Object set(int index,E e);
//判断是否包含元素e
public boolean contains(E e);
//返回index处的元素
public E get(int index);
//返回列表中第一个与元素e匹配的下标index
public int indexOf(E e);
//返回列表中最后一个与元素e匹配的元素下标index
public int lastIndeOf(E e);
//判断列表是否为空
public boolean isEmpty();
//返回列表的大小
public int size();
}
MyAbstractList.java

public abstract class MyAbstractList<E> implements MyList<E> {//部分实现MyList接口
protected int size=0;
protected MyAbstractList(){

}
protected MyAbstractList(E[] objects){
for(int i=1;i<objects.length;i++)
add(objects[i]);
}
@Override
public void add(E e){
add(size,e);
}
@Override
public void add(int index,E e){

}
@Override
public boolean isEmpty(){
return size==0;
}
@Override
public int size(){
return size;
}
@Override
public boolean remove(E e){
if(indexOf(e)>=0){
remove(indexOf(e));
return true;
}
else return false;
}
@Override
public E remove(int index){
return null;
}
@Override
public void clear() {
// TODO Auto-generated method stub

}
@Override
public Object set(int index, E e) {
// TODO Auto-generated method stub
return null;
}
@Override
public boolean contains(E e) {
// TODO Auto-generated method stub
return false;
}
@Override
public E get(int index) {
// TODO Auto-generated method stub
return null;
}
@Override
public int indexOf(E e) {
// TODO Auto-generated method stub
return 0;
}
@Override
public int lastIndeOf(E e) {
// TODO Auto-generated method stub
return 0;
}
}



MyLinkedList.java

public class MyLinkedList<E> extends MyAbstractList<E>{
private Node<E> head,tail;
public MyLinkedList(){
}
public MyLinkedList(E[] objects){
super(objects);
}
//返回头元素
public E getFirst(){
if(size==0){
return null;
}
else{
return head.element;
}
}
//返回尾元素
public E getLast(){
if(size==0){
return null;
}
else{
return tail.element;
}
}
//添加首元素
public void addFirst(E e){
Node<E> newNode=new Node<E>(e);
newNode.next=head;
head=newNode;
size++;
if(tail==null)
tail=head;
}
//添加尾元素
public void addLast(E e){
Node<E> newNode=new Node<E>(e);
if(tail==null){
head=tail=newNode;
}
else{
tail.next=newNode;
tail=tail.next;
}
size++;
}
//在index处添加元素
public void add(int index,E e){
if(index==0) addFirst(e);
else if(index>=size) addLast(e);
else{
Node<E> current=head;
for(int i=1;i<index;i++)
current=current.next;
Node<E> temp=current.next;
current.next=new Node<E>(e);
(current.next).next=temp;
size++;
}
}
//删除并返回首元素
public E removeFirst(){
if(size==0)return null;
else if(size==1){
Node<E> temp=head;
head=tail=null;
size=0;
return temp.element;
}
else{
Node<E> temp=head;
head=head.next;
size--;
return temp.element;
}
}
//删除并返回尾元素
public E removeLast(){
if(size==0)return null;
else if(size==1){
Node<E> temp=head;
head=tail=null;
size=0;
return temp.element;
}
else{
Node<E> current=head;
for(int i=0;i<size-2;i++){
current=current.next;
}
Node<E> temp=tail;
tail=current;
tail.next=null;
size--;
return temp.element;
}
}
//删除并返回index处的元素
public E remove(int index){
if(index<0||index>=size) return null;
else if(index==0) return removeFirst();
else if(index==size-1) return removeLast();
else{
Node<E> previous=head;
for(int i=1;i<index;i++){
previous=previous.next;
}
Node<E> current=previous.next;
previous.next=current.next;
size--;
return current.element;
}
}
public String toString(){
StringBuilder result=new StringBuilder("[");
Node<E> current=head;
for(int i=0;i<size;i++){
result.append(current.element);
current=current.next;
if(current!=null){
result.append(",");
}
else{
result.append("]");
}
}
return result.toString();
}
public void clear(){
head=tail=null;
}
//是否包含元素e
public boolean contains(E e){
Node<E> current=head;
for(int i=0;i<size;i++){
if(current.element.equals(e)){
return true;
}
else{
current=current.next;
}
}
return false;
}
//返回index处的元素
public E get(int index){//index都是从0 算起的，size是从1算起的
if(index<0||index>=size) return null;
else if(index==0) return head.element;
else if(index==size-1) return tail.element;
else{
Node<E> current=head;
for(int i=1;i<index;i++)
current=current.next;
Node<E> temp=current.next;
return temp.element;
}
}
public int indexOf(E e){
if(size==0) return -1;
else {
Node<E> current=head;
for(int i=0;i<size;i++){
if(current.element.equals(e))
return i;
else current=current.next;
}
}
return -1;
}
public int lastIndexOf(E e){
if(size==0) return -1;
else {
Node<E> current=tail;
for(int i=size-1;i>=0;i--){
if(current.element.equals(e))
return i;
else current=current.next;
}
}
return -1;
}
//在index处的元素设置为e
public E set(int index,E e){
if(index<0||index>=size) return null;
else{
Node<E> current=head;
for(int i=1;i<index;i++)
current=current.next;
Node<E> old=current.next;
E oldE=old.element;
old.element=e;
return oldE;
}
}
}

TestMyLinkedList.java
public class TestMyLinkedList {
public static void main(String[] args) {

MyList<String> list=new MyLinkedList<>();
list.add("America");
System.out.println("(1)"+list);

list.add(0,"Canada");
System.out.println("(2)"+list);

list.add("Russia");
System.out.println("(3)"+list);

list.add("France");
System.out.println("(4)"+list);

list.add(2,"Gemany");//在索引2的位置插入
System.out.println("(5)"+list);

list.add(5,"Norway");//在索引5的位置插入
System.out.println("(6)"+list);

list.remove("Canada");//移出
System.out.println("(7)"+list);

list.remove("2");//移出索引2的元素
System.out.println("(8)"+list);

list.remove(list.size()-1);
System.out.println("(9)"+list);
}

}

测试结果：
(1)[America]

(2)[Canada,America]

(3)[Canada,America,Russia]

(4)[Canada,America,Russia,France]

(5)[Canada,America,Gemany,Russia,France]

(6)[Canada,America,Gemany,Russia,France,Norway]

(7)[America,Gemany,Russia,France,Norway]

(8)[America,Gemany,Russia,France,Norway]

(9)[America,Gemany,Russia,France]