数据结构之单链表

/**
 *对单链表操作都是对上一个元素进行操作，索要我们需要一个定位的元素的方法
 * 链表其实就是一种顺序存储的数据结构，让一个节点存在两个属性数据
 * 指向下一个节点的指针
 * 对于链表的操作，其实就是一种标准操作：
 * 1.增加元素
 * 2.删除元素
 * 3.判断链表是否为空
 * 4.返回链表的长度
 * 既然以上的操作定义为标准，则可以抽象为接口 链表类直接是是实现该接口的
 * 标准
 * @author mfr
 *
 */

先创建一个Link接口，把要实现的方法加进去

interface List{
    /**
     * 返回链表的长度
     * return: int
     */
    public int size();

    /**
     * 判断链表是否为空
     * @return： boolean
     */
    
    public boolean isempty();
    
    /**
     * 插入元素
     * @param:index,obj
     * @throws ：Exception
     */
    
    public void add(int index,Object obj)throws Exception;
    
    /**
     * 删除元素
     * @param index
     * @throws Exception
     */
    public void remove(int index)throws Exception;
    
    /**
     * 获得链表中的指定元素
     * @param index 
     * @return 
     * @throws Exception
     */
    public Object get(int index)throws Exception;
}

再创建node属性

/**
 * 定义节点类,两个属性，指向下一个节点的指针
 * @author mfr
 *
 */
class Node{
    
    Object element; //保存数据
    Node  next;
    
    //构造方法
    
    //头节点
    public Node(Node nextval){
        this.next = nextval;
    }
    
    //不是头节点
    public Node(Object obj,Node nextval){
        this.element = obj;
        this.next = nextval;
    }

    public Object getElement() {
        return element;
    }

    public void setElement(Object element) {
        this.element = element;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
    
}

在定义链表类对 Link接口的实现

class Linklist implements List{
    Node head; //头指针
    Node current;//当前节点
    int size;//记录当前链表的元素的个数

    
    //初始化一个空链表
    public Linklist() {
        // TODO Auto-generated constructor stub
        //初始化一个空的表头
        this.head = current = new Node(null);
        this.size = 0;
        
    }
    
    public void index(int index){ //index 是你要定位的元素
        if (index < -1 || index > size-1) {
            System.out.println("参数错吴");
        }
        if(index == -1){ //传进来的是头节点
            return ;
        }
        current = head.next;
        int j = 0;
        while(current != null&&j < index ){  // <index正好是当前元素
            current = current.next;
            j++;
        }
        
    }
    @Override
    public int size() {
        // TODO Auto-generated method stub
        return size;
    }

    @Override
    public boolean isempty() {
        // TODO Auto-generated method stub
        
        return size == 0;
    }

    @Override
    public void add(int index, Object obj) throws Exception {
        // TODO Auto-generated method stub
        
        //增加之前的判断参数
        if(index < 0 || index > size){
            System.out.println("Java太笨重了111");
        }
        //定位节点
        index(index - 1 );
        current.setNext(new Node(obj,current.next)); //将current的下一个节点给了 new node 的下一个
        size++;
        
    }

    @Override
    public void remove(int index) throws Exception {
        
        if(index < 0 || index > size-1){
            System.out.println("Java太笨重了");
        }
            index(index - 1 );
            current.setNext(current.next.next); //此时的当前节点是index的前一个节点
            size--;
        
        
        
    }

    @Override
    public Object get(int index) throws Exception {
        
        // TODO Auto-generated method stub
        if (index < 0 || index > size) {
            System.out.println("Java 太笨重了");
            return -1;
            
        }
        index(index);
        
        return current.element;
    }
    
}

public class TestSignLinkList {

    /**
     * 实现类
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
      Linklist link = new Linklist();
      link.add(0, 7);
      link.add(1, 8);
      link.add(2, 9);
      System.out.println(link.get(1));


    }

}