单链表

·链表在插入、删除数据元素时比顺序线性表快的多，但是查找一个节点或者访问特定编号的节点比顺序线性表慢的多；

单链表常用的操作有：

·查找；

·插入；

·删除；

 

package MyJava2;

public class SingleLinkedList {
    private class Node{//定义一个内部类Node
        String data;
        Node next;
        public Node(){

        }
        public Node(String data,Node next){
            this.data=data;
            this.next=next;
        }
    }
    private Node header;//保存该链表的头结点
    private Node tail;//保存该链表的尾节点
    private int size;//保存该链表中已包含的节点数

    public SingleLinkedList(){//创建空链表
        header=null;
        tail=null;
    }
    public SingleLinkedList(String data){//以指定元素创建链表
        header=new Node(data,null);
        tail=header;
        size++;
    }

    public int len(){//返回链表的长度
        return size;
    }

    public String getData(int index){//获取index处的元素
        return getNodeByIndex(index).data;
    }

    private Node getNodeByIndex(int index) {//根据指定索引获取节点
        if(index<0||index>size-1){
            throw new IndexOutOfBoundsException("OutOfIndex");
        }
        Node current=header;
        for(int i=0;i<size&&current!=null;i++,current=current.next){
            if(i==index){
                return current;
            }
        }return null;
    }

    public int getIndex(String data){//根据元素获取索引
        Node current=header;
        for(int i=0;i<size&&current!=null;i++,current=current.next){
            if(data.equals(current.data)){
                return i;
            }
        }return -1;
    }

    public void addAtTail(String data){//尾插
        if(header==null){
            header=new Node(data,null);
            tail=header;
        }else {
            Node newNode=new Node(data,null);
            tail.next=newNode;
            tail=newNode;
        }
        size++;
    }

    public void addAtHeader(String data){//头插
        header=new Node(data,header);
        if(tail==null){
            tail=null;
        }
        size++;
    }

    public void add(String data,int index){//向链表的指定位置插入元素
        if(index<0||index>size){
            throw new IndexOutOfBoundsException("OutOfIndex");
        }
        if(header==null){
            addAtTail(data);
        }else {
            if(index==0){
                addAtHeader(data);
            }else{
                Node prve=getNodeByIndex(index-1);
                prve.next=new Node(data,prve.next);
                size++;
            }
        }
    }

    public String del(int index){//删除指定索引处的元素
        if(index<0||index>size){
            throw new IndexOutOfBoundsException("OutOfIndex");
        }
        Node delNode=null;
        if(index==0){
            delNode=header;
            header=header.next;
        }else{
            Node prve=getNodeByIndex(index-1);
            delNode=prve.next;
            prve.next=delNode.next;
            delNode.next=null;
        }size--;
        return delNode.data;
    }

    public String delTail(){//删除尾节点
       return del(size-1);
    }

    public Boolean empty(){//判断链表是否为空
        return size==0;
    }

    public void clear(){//清空链表
        header=null;
        tail=null;
        size=0;
    }

    public String toString(){
        StringBuffer sb=new StringBuffer();
        Node current=header;
        for(;current!=null;current=current.next){
            sb.append(current.data.toString()+",");
        }
        return sb.toString();
    }

    public static void main(String[] args){
        SingleLinkedList list=new SingleLinkedList();
        list.add("A",0);
        list.addAtHeader("B");
        list.addAtTail("C");
        System.out.println(list.toString());
        System.out.println(list.len());
        System.out.println(list.empty());
        System.out.println(list.del(1));
        System.out.println(list.toString());
    }
}