1.链式存储
2.分析
每个节点为一个对象，该对象包含数据域和指针域
整条单链表为一个对象，他和节点对象进行组合。
3.java代码实现：
首先抽象出一个接口，这个接好包含集合的基本操作
package com.wx.datastructure.base;
public interface LinkList <T>{
/*
实现线性表的链式存储
*/
public int size();//返回线性表长度的大小
public boolean isEmpty();//判断线性表是否为空
public void add(int index,T element);//指定位置插入元素in
public void add(T element);//线性表的添加元素，默认尾部添加
public void addFirst(T element); //在线性表的头部添加元素
public void addLast(T element); //在线性表的尾部添加元素
public void remove(T elementm);//移除指定位置的元素
public void clear();//清空链表
public Object get(int index); //根据链表下标返回元素
}
然后定义一个节点类，包含数据域和指针域：
package com.wx.datastructure.base;
public class Node {
/*
定义一个节点类，包含数据域和指针域
*/
private Object nodevalue; //数据域
public Node next; //指针域
public Node ()
{
}
public Node(Object nodevalue,Node next)
{
this.nodevalue=nodevalue;
this.next=next;
}
public Object getNodevalue() {
return nodevalue;
}
public void setNodevalue(Object nodevalue) {
this.nodevalue = nodevalue;
}
}
实现集合的接口：
package com.wx.datastructure.imp;
import com.wx.datastructure.base.LinkList;
import com.wx.datastructure.base.Node;
public class WxLinkList<T> implements LinkList<T> {
private Node header; // 保存头结点
private Node tail; // 保存尾节点
private int size; // 保存已含有的节点数
// 创建空链表
public WxLinkList() {
header = null;
tail = null;
}
// 已指定数据元素创建链表，只有一个元素
public WxLinkList(T element) {
header = new Node(element, null);
// 只有一个节点，header,tail都指向该节点
tail = header;
size++;
}
/*
返回链表的大小，其实就是包含节点的数量
*/
@Override
public int size() {
return this.size;
}
/*
判断链表是否为空,
*/
@Override
public boolean isEmpty() {
return this.size==0;
}
/*
在指定位置插入元素
*/
@Override
public void add(int index, T element) {
//先是要历遍到指定位置，然后创建新节点，前节点指向他，他指向后节点。
if (index>=0&&index<size)
{
Node current=header;
for(int i=0;i<=index&¤t!=null;i++,current=current.next)
{
if(i==index-1)
{
Node node=new Node(element,null);
Node next = current.next;
current.next=node;
node.next=next;
size++;
}
}
}
}
/*
链表新增一个元素。默认是尾部添加
*/
@Override
public void add(T element) {
addLast(element);
}
/*
链表头部添加元素
*/
@Override
public void addFirst(T element) {
//在链表的头部添加元素就是要创建一个新节点，然后让新节点的指针域指向header
//并以新节点作为新的header
Node node=new Node(element,null);
node.next=header;
header=node;
//若插入前是空表
if(tail == null){
tail = header;
}
size++;
}
/*
链表尾部添加元素，这里一定要先判断是否为空链表
*/
@Override
public void addLast(T element) {
//如果链表是空的链表，那么头指针还是null，所以处理一下头指针
if(header==null)
{
header=new Node(element,null);
tail=header; //这样处理过后，头指针和尾指针指向同一个节点，此时链表有一个节点
}
else {
//新建一个节点,原来尾指针的指针域指向他，他变成尾指针
Node node=new Node(element,null);
tail.next=node;
tail=node;
}
//链表的长度++
size++;
}
/*
指定删除一个元素
*/
@Override
public void remove(T elementm) {
Node node=new Node(elementm,null);
//历遍，判断是否相等
Node current=header;
Node prenode=null; //要删除节点的上一个
for (int i=0;i<size&¤t!=null;i++,prenode=current,current=current.next)
{
if (node.getNodevalue().equals(current.getNodevalue()))
{
Node nextnode=current.next; //要删除节点的下一个节点
prenode.next=nextnode; //当前节点的指针域指向下一个节点就删除了当前的节点
}
}
}
/*
清空线性表
*/
@Override
public void clear() {
this.header=null;
this.tail=null;
this.size=0;
}
/*
获得索引处的节点
*/
private Node getNode(int index) {
if(index<0||index>size)
{
throw new IndexOutOfBoundsException("index"+index);
}
//历遍链表,从头节点开始 header是头节点的引用
Node current=header;
for(int i=0;i<size&¤t!=null;i++,current=current.next)
{
if (i==index)
{
return current;
}
}
return null;
}
/*
通过返回的节点来获得他的值
*/
@Override
public Object get(int index) {
Node node = getNode(index);
return node.getNodevalue();
}
}
测试：
package com.wx.datastructure.test;
import com.wx.datastructure.base.Node;
import com.wx.datastructure.imp.WxLinkList;
import java.util.LinkedList;
public class TestLinkList {
public static void main(String []args)
{
WxLinkList<String> list=new WxLinkList<String>();
list.add("1");
list.add("2");
list.addFirst("3");
list.add(1,"4");
System.out.print("链表的长度"+list.size()+" ");
System.out.print(list.get(0));
System.out.print(list.get(1));
System.out.print(list.get(2));
System.out.print(list.get(3)); //3412
list.remove("1");
System.out.print(" ");
System.out.print(list.get(0));
System.out.print(list.get(1));
System.out.print(list.get(2));
/* Node node1=new Node("1",null);
Node node2=new Node("2",null);
Node node3=new Node("3",null);
Node header=null;
node1.next=node2;
node2.next=node3;
header=node1;
Object nodevalue = header.getNodevalue();
Node node4=node1.next;
Node node5=node2.next;
Node node6=node3.next;*/
}
}
结果：
