线性链表的操作

 package dataStruct.test;

public class Line {
    //最大的长度
    public static final int M = 100;

    private String[] strs = new String[M];

    //当前最后一位的索引
    private int strSize = 0;
    
    
    public Line(){
        
    }
    /**
     * 线性表的插入
     * @param index  插入的索引号
     * @param value  插入的值
     * @return  返回值，是否能插入
     */
    public boolean insertLine(int index,String value) {
        if(index < 0 || index > strSize || strSize == M) {
            return false;
        }
        int i =  strSize;
        for(;i > index;i--) {
            strs[i] = strs[i - 1];
        }
        strs[i] = value;
        strSize ++;
        return true;
        
    }
    
    /**
     * 如果没有指定索引值，则默认插入在最后
     * @param value
     * @return
     */
    public boolean insertLine(String value){
        return insertLine(strSize,value);
    }
    
    
    /**
     * 按索引值删除
     * @param index
     * @return
     */
    public boolean deleteLine(int index){
        if(index < 0||index >= strSize) {
            return false;
        }

        for(int i = index;i < strSize - 1;i ++) {
            strs[i] = strs[i+1];
        }
        strSize--;
        return true;
        
    }
    
    /**
     * 不加索引值默认删除最后一个
     * @return
     */
    public boolean deleteLine(){
        if(strSize == 0) {
            return false;
        }
        strSize--;
        return true;
    }
    
    
    public int getStrSize(){
        return strSize;
    }
    
    /**
     * 打印的方法
     */
    public void print(){
        System.out.print("[");
        for(int i = 0; i < strSize -1;i++) {
            System.out.print(strs[i] + ",");
        }
        System.out.print(strs[strSize-1]);
        System.out.println("]");
    }
    
    
    
    public static void main(String[] args) {
        Line test = new Line();
        //为其赋值
        for (int i = 0; i < 10 ; i++) {
            test.insertLine(String.valueOf(i));
        }
        test.print();
        System.out.println("strSize = "+test.getStrSize());
        test.deleteLine(2);
        test.print();
        test.deleteLine();
        test.print();
        
    }

}

 

//节点

package dataStruct.test;

/**
 * 节点，链式存储结构
 * @author spirit
 *
 */
public class NodeOne {
    private String value;
    private NodeOne next;
   
    public NodeOne(){
       
    }
   
    public NodeOne(String value,NodeOne node){
        this.value = value;
        this.next = node;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public NodeOne getNext() {
        return next;
    }

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

}

package dataStruct.test;

/**
 * 线性链表
 * @author spirit
 *
 */
public class LinkList {
   
    //头节点，尾节点，长度
    private NodeOne header;
    private NodeOne ender;
    private int size = 0;
   
    /**
     * 构造函数完成初始化过程
     */
    public LinkList(){
        header = new NodeOne();
        ender = header;
        header.setNext(ender);
        size = 0;
    }
    public int getSize(){
        return size;
    }
   
    /**
     * 线性链表的插入
     * @param index 索引值
     * @param value 插入的值
     * @return 插入与否
     */
    public boolean insertValue(int index,String value){
        if(index < 0 || index > size) {
            return false;
        }
        if(index == size){
            NodeOne temp = new NodeOne(value,ender.getNext());
            ender.setNext(temp);
            ender = temp;
            size ++;
            return true;
        }
        NodeOne p = header;
       
        for(int i = 0; i < index;i++) {
            p = p.getNext();
        }
       
        NodeOne n = new NodeOne(value,p.getNext());
        p.setNext(n);
        size ++;
       
        return true;
    }
   
    /**
     * 插入至最后
     * @param value
     * @return
     */
    public boolean insertValue(String value){
        return insertValue(size,value);
    }
   
   
    /**
     * 按索引值来删除
     */
    public void deleteValue(int index){
        if(index < 0||index > size) {
            return;
        }
        NodeOne p = header;
        for(int i = 0; i < index;i++) {
            p = p.getNext();
        }
        NodeOne n = p.getNext();
        p.setNext(n.getNext());
        n.setNext(null);
        if(index == size--) {
            ender = p;
        }
       
    }
    /**
     * 默认只删除第一个
     */
    public void deleteValue(){
        deleteValue(0);
    }
   
   
    //打印
    public void print(){
        NodeOne p = header.getNext();
        for(int i = 0; i < size;i++) {
            System.out.print(p.getValue()+" ");
            p = p.getNext();
        }
        System.out.println();
    }
   
   
   
   
    public static void main(String[] args) {
        LinkList link = new LinkList();
        for(int i = 0; i < 10; i ++) {
            link.insertValue(String.valueOf(i));
        }
//        link.insertValue("hello");
        System.out.println("header.getValue:"+link.header.getValue());
        System.out.println("ender.getValue:"+link.ender.getValue());
       
        System.out.println(link.getSize());
        link.print();
        link.deleteValue(2);
        link.print();
       
    }
   
}