数据结构-单链表的代码实现

单链表是比较简单的链表，构成单链表的只有当前节点和下一节点处理，最后需要形成1-2-3-4将所有数据串联在一起。

假如你要存储1，那么当前节点是1，下一个节点是空，因为你不知道下一个节点，然后再存储个2，这时当前节点是2，那么你就需要修改上一个节点1的下一个节点就是2，其实这个是很简单的，通过一个变量每一次存储当前的值，等到下一个值过来，我们取的时候就是上一个值，我们来实现一下。

首先我们定义一个MyLinked类，类里再创建一个内部类Node，Node作为链表定义。

item为当前节点，next为下一节点

public class MyLinked {

    // 定义一个内部节点类
    private static class Node<E>{
        // 当前节点
        E item;
        // 下一节点链表
        Node<E> next;

        public Node(E item,Node<E> next){
            this.item=item;
            this.next=next;
        }
    }

}

1.增加节点

我们需要添加操作将链表上链，调用add方法，第一次会把数据放入头结点first全局变量中，然后把最新的节点也就是最后一个节点放入last中，这样每次调用add，最后的节点都可当上一个节点使用，这样判断完毕直接再l.next赋值最新的数据，就全部串连起来了，最后打印下链表的元素

   // 头结点
    private Node<Object> first;
    // 最后一个节点
    private Node<Object> last;

    // 添加链表元素
    private void add(Object e){
        // 将最后一个节点信息赋值给临时变量l，第一次时为空
        Node<Object> l=last;
        // 创建新的节点，只知道当前节点并不知道下一节点所以设置为空
        Node<Object> newNode=new Node(e,null);
        // 把每一个最新的节点赋值给last全局变量
        last=newNode;
        if (l==null){
            // 将头节点存储节点
            first=newNode;
        }else{
            // 因为是引用类型所以这里l.next则直接会再下一个节点穿连新节点，将节点串起来
            l.next=newNode;
        }
    }

    // 打印链表元素
    private void printLink(){
        Node<Object> f=first;
        while (f!=null){
            System.out.print("-"+f.item);
            f=f.next;
        }
        System.out.println("");
    }

    public static void main(String[] args) {
        System.out.println("往链表添加元素：");
        MyLinked myLinked=new MyLinked();
        myLinked.add(1);
        myLinked.add(2);
        myLinked.add(3);

        myLinked.printLink();
    }

打印完毕，数据已经排排座，手牵手存储好

 2.获取节点

通过小标获取对应的节点信息，这个比较简单，其实就是根据小标进行循环，查找到下一个节点直到找到完毕

     /***
     * 根据索引获取单链表元素
     * @Param index 索引
     */
    private Object get(int index){
        Node node= getCommon(index);
        return node.item;
    }

    // 由于需要查询到元素的地方较多，做一个公共方法
    private Node getCommon(int index){
        if(index<0){
            return null;
        }
        Node get=first;
        for (int i=0;i<index;i++) {
            get = get.next;
        }
        return get;
    }

3.更改节点

通过小标获取对应节点（调用公共方法），然后直接进行当前节点更新即可，怎么样简单把

 /**
    * 更新链表元素
    * @Param index 索引
      @Param e 待更改的元素
    */
    private void update(int index,Object e){
        Node node= getCommon(index);
        node.item=e;
    }

 

4.删除节点

1-2-3-4 假如我要删除2，我剩下1-3-4，也就是说要删除2，则要把1的next元素由2改为3即可，要删除3也是如此则需要知道3的节点并把3的next改为null。

所以我们要定义上一个节点，每次循环把当前节点赋值，等到找到节点时则可使用prev.next将下一个节点处理即可。

    // 删除元素
    private void remove(Object obj) {
        // 前一个元素
        // 没有找到当前元素则把当前元素存起来等到下一个元素找到是要删除的则把此的.
        Node prev = null;
        // 要删除的元素为第一个元素则把第一个元素的下一个元素赋值为当前元素
        if(first.item.equals(obj)){
            first=first.next;
        }else {
            // 循环元素
            for (Node x = first; x != null; x = x.next) {
                if (obj.equals(x.item)) {
                    if (x.next != null) {
                        prev.next = x.next;
                        break;
                    }else{
                        prev.next=null;
                    }
                }
                prev = x;
            }
        }
    }

 main测试方法

public static void main(String[] args) {
        System.out.println("往链表添加元素：");
        MyLinked myLinked = new MyLinked();
        myLinked.add(1);
        myLinked.add(2);
        myLinked.add(3);


        myLinked.printLink();

        System.out.println("获取链表里第二个元素元素：" + myLinked.get(1));

        System.out.print("更新链表元素：");
        myLinked.update(1, 4);
        myLinked.printLink();
        System.out.print("删除链表元素：");
        myLinked.remove(3);
        myLinked.printLink();
    }

其实链表还是蛮简单的，多自己想想给你一个这样链表你怎么实现增删改查，然后和源码对照，这样熟悉此结构后对他的所有处理就会更简单熟练。