java实现单链表

---恢复内容开始---

单链表上的基本运算

2016-06-17

对于单链表，系统建立单链表过程，就是不断添加节点的过程。动态建立单链表有两种方式。

1：头插法建表

2：尾插法建表

常用的操作有：查找，插入，删除

1：查找：按序号查找第index个节点

　　　　在链表中查找指定的element元素

2：插入：首先找到索引为index-1的节点，然后生成一个新节点newNode，另index-1的next引用新节点，新节点的next域执行原来index节点

3：删除：首先找到索引为index-1的节点，让index-1的next引用原来的index+1节点，释放index节点

 

package consume;

import java.io.ObjectInputStream.GetField;

public class LinkList<T> {
    private class Node{
        private T element;//数据域
        private Node next;//执行下一个节点的引用
        public Node(){//无参构造方法
            
        }
        public Node(T element,Node next){//有参数的构造方法
            this.element=element;
            this.next=next;
        }
    }
    private int size;//保存链表一有的节点数
    private Node header;//头结点
    private Node tail;//尾节点
    public LinkList(){//链表的构造方法
        header=null;
        tail=null;
        size=0;
    }
    public LinkList(T element){//构造头结点的构造方法
        header=new Node(element,null);
        tail=header;
        size++;
    }
    //返回链表的长度
    public int length(){
        return size;
    }
    //返回指定位置的节点
    public Node getNode(int index){
        if(index<0||index>size-1){
            throw new IndexOutOfBoundsException("索引越界");
        }
        Node current=header;//新建一个节点为header
        for(int i=0;i<size&&current!=null;i++,current=current.next){
            if(i==index){
                return current;
            }
        }
        return  null;
    }
    //返回指定位置节点的数据
    public T get(int index){
        return getNode(index).element;
    }
    //查找指定元素的索引
    public int locate(T date){
        Node current=header;
        for(int i=0;i<size&&current!=null;i++,current=current.next){
            if(current.element.equals(date)){
                return i;
            }
        }
        return -1;
    }
    //向指定位置插入节点
    public void insert(T data,int index){
        if(index<0||index>size){
            throw new IndexOutOfBoundsException("索引越界");
        }
        if(header==null){//为空链表时，用尾插法插入
            add(data);
        }
        else{
            if(index==0){//当位置为0时，为头插法
                addAtHeaer(data);
            }else{
                Node prev=getNode(index-1);//获取前驱节点
                prev.next=new Node(data,prev.next);//前驱节点的next指向新节点，新节点的next指向原来prev的next
            }
        }
        size++;
        
    }
    //采用尾插法为链表添加新节点
    public void add(T data){
        //如果该链表还是空链表
        if(header==null){
            header=new Node(data,null);
            tail=header;
        }else{
            Node newNode=new Node(data,null);
            tail.next=newNode;//为链表的next指向新节点
            tail=newNode;//更新尾节点
        }
        size++;
    }
    //采用头插法为链表添加新节点
    public void addAtHeaer(T data){
        header=new Node(data,header);
        if(tail==null){
            tail=header;
        }
        size++;
    }
    //删除链表指定位置的元素
    public T delete(int index){
        if(index<0||index>size-1){
            throw new IndexOutOfBoundsException("索引越界");
        }
        Node del=null;
        if(index==0){
            del=header;
            header=header.next;
        }
        else{
            Node prev=getNode(index-1);
            del=prev.next;
            prev.next=del.next;
            del.next=null;
        }
        size--;
        return del.element;
    }
    //删除链表最后一个元素
    public T remove(){
        return delete(size-1);
    }
    //判断链表是否为空
    public boolean empty(){
        return size==0;
    }
    //清空链表
    public void clear(){
        header=null;
        tail=null;
        size=0;
    }
    public static void main(String[] args) {
        LinkList<String> list=new LinkList<String>();
        list.insert("a", 0);
        list.add("b");
        list.add("c");
        System.out.println(list.getNode(1).element);
    }
}

 

---恢复内容结束---