数据结构—单链表

链表属于线性表中的一种，拥有线性表中线性，有限等特点，它的实现与线性表中的顺序表不同，链表的实现特点是类似于自行车的链子一节节相连，所以需要定义节点。

在我用java实现的过程中，我觉得将其比作包菜或者洋葱（假设可以随意抽走任意一层叶子），head是最外层的叶子，每当新增一个数据就是在包菜的最内部生出一片叶子，数据则是记录在一片片叶子上，当要删除某一的时候则将那片叶子扒走。以上是使用debug 观察的感想。

======================================================================================================================================

做了一点小更改，将单链表的类型改为泛型，使能够接受更多的中类型的存储

建立一个节点类（用包菜比喻的话可以叫叶子）Node

package linklist;

/**
 * 
 * @author chenkaixin
 *
 */
public interface MyLinkList {
    /**
     * 往单链表中添加数据
     * 
     * @param data
     *            加入的数据
     */
    public void add(T data);

    /**
     * 根据索引删除数据
     * 
     * @param index
     *            索引
     * @return
     */
    public boolean delete(int index);

    /**
     * 在索引指向的节点后插入数据
     * 
     * @param index
     *            索引
     * @param data
     *            数据
     * @return
     */
    public boolean insert(int index, T data);

    /**
     * 查询链表中的所有数据
     */
    public void selectAll();

    /**
     * 根据索引查询数据
     * 
     * @param index
     */
    public void selectIndex(int index);

    /**
     * 链表的长度
     */
    public void length();

}
package linklist;

/**
 * 
 * @author chenkaixin
 *
 */
public class MyLinkListImpl implements MyLinkList {
    /**
     * 定义头节点
     */
    Node head = null;
    int length = 0;
    boolean b = false;

    @Override
    public void add(T data) {
        Node newNode = new Node(data);
        // 判断头节点是否为空
        if (head == null) {
            head = newNode;
        } else {
            Node tem = head;
            while (tem.next != null) {
                tem = tem.next;
            }
            tem.next = newNode;
        }
        this.length++;
    }

    @Override
    public boolean delete(int index) {
        Node tem = head;
        int i = 0;
        if (index == 0) {
            head = tem.next;
            this.length--;
            return true;
        } else {
            while (tem.next != null) {
                i++;
                if (index == i) {
                    tem.next = tem.next.next;
                    this.length--;
                    return true;
                }
                tem = tem.next;
            }
        }
        return false;
    }

    @Override
    public boolean insert(int index, T data) {
        Node tem = head;
        Node newNode = new Node(data);
        int i = 0;

        while (tem.next != null) {
            if (index == i) {
                newNode.next = tem.next;
                tem.next = newNode;
                this.length++;
                return true;
            }
            tem = tem.next;
            i++;
        }

        return false;
    }

    @Override
    public void selectAll() {
        Node tem = head;
        while (tem != null) {
            System.out.println(tem.data.toString());
            tem = tem.next;
        }
    }

    @Override
    public void selectIndex(int index) {
        int i = 0;
        Node tem = head; 
        if(index>=0&&index my = new MyLinkListImpl();
        my.add('g');
        my.add('3');
        my.add('8');
        my.add('6');
        my.add('1');
        my.add('6');
        my.selectAll();
        my.length();
        System.out.println("=====================================");
        my.insert(3, 'p');
        my.selectAll();
        my.length();
        System.out.println("++++++++++++++++++");
        my.delete(3);
        my.selectAll();
        my.length();
        // my.selectIndex(4);
    }

}
package linklist;
/**
 * 
 * @author chenkaixin
 *
 */
public class Node {
    public Node next;  //叶子里包着下一片叶子或者没有
    public T data;
    
    public Node(T data){   //写在叶子里的数据
        this.data = data;
    }
    
    public void thisData(){
        System.out.println(this.data);
    }
}

想法：链表在C++中是直接用指针直接连接，而java没有指针，所以在实现的时候着重考虑的是，java如何建个指针，如何把指针与数据相连，在多方查找，以及自己的思考就出现了包菜一样的链表。

写完单链表要去膜拜下jdk中的LinkedList，发现是双向链表，所以就先放放。