java-实现单链表的增删操作

在数据结构中，除了数组，链表是我们最常见的数据结构，它的主要特点就是不用使用连续的内存单元，也不用一开始就预留出连续的内存单元，每次新加入元素的时候只要去找那些空余的内存单元即可。
链表分为很多种，有单链表、双链表和环链表等。
我们现在以单链表为例介绍：
在java中，基本的链表节点定义如下：

public class Node {
    public Node next;
    public int val;
    public Node(int val){
        this.val = val;
    }
}

链表常用的操作就是往链表中插入元素和从链表中删除元素。
从链表中插入一个数x到链表中第i个结点的位置的思想是：

1、new一个新的节点存放新的元素x(new Node(x))
2、从头遍历链表，找到第i-1个元素
3、将第i-1个节点的next指针指向新元素的结点
4、将新元素的结点的next指向第i个节点

从链表中删除第i个结点的思想是：

1、从头遍历到第i-1个结点
2、将第i-1个结点的next指针指向第i个结点的next指针

下面主要来用java代码实现一下链表的基本操作：

public class MyLinkedList {
    Node head =null;

    /**
     * 向链表尾部插入新元素
     * @param data 要插入的元素
     */
    public void addNode(int data){
        Node newNode = new Node(data);
        //如果头结点为空
        if(head==null){
            head = newNode;
            return;
        }
        Node tmp = head;
        while(tmp.next!=null){
            tmp = tmp.next;
        }
        //将新节点插到链表的末尾
        tmp.next = newNode;
    }

    /**
     * 计算链表的长度
     * @return 链表长度
     */
    public int length(){
        int length =0;
        Node tmp =head;
        while(tmp.next!=null){
            length++;
            tmp = tmp.next;
        }
        return length;
    }

    /**
     * 向链表中的第index个位置插入元素data
     * @param data 要插入的元素
     * @param index 第一个结点index=1
     * @return 插入成功返回true,失败返回false
     */
    public boolean addNode(int data,int index){
        if(index<1||index>length()){
            return false;
        }
        Node newNode = new Node(data);
        if(index==1){
            //将新元素节点的next指针指向链表的头指针
            newNode.next = head;
            //新元素节点成为链表新的头指针
            head = newNode;
            return true;
        }
        //找到第index-1个节点
        Node tmp = head;
        int i= 1;
        while(tmp.next!=null){
            if(i==index-1){
                break;
            }
            tmp = tmp.next;
            i++;
        }
        //保留tmp的next指针
        Node oldNext = tmp.next;
        //将tmp的next指针指向新元素节点
        tmp.next = newNode;
        //将新元素的next指针指向原来tmp的next指向的结点
        newNode.next = oldNext;
        return true;
    }

    /**
     * 删除第index个节点
     * @param index
     * @return 删除成功返回true,失败返回false
     */
    public boolean deleteNode(int index){
        if(index<1||index>length()){
            return false;
        }
        //删除链表的第一个元素
        if(index==1){
            head = head.next;
            return true;
        }
        //找到第index-1个节点
        Node tmp = head;
        int i= 1;
        while(tmp.next!=null){
            if(i==index-1){
                break;
            }
            tmp = tmp.next;
            i++;
        }
        tmp.next = tmp.next.next;
        return true;
    }

    /**
     * 从头到尾打印链表
     */
    public void print(){
        Node tmp = head;
        while(tmp!=null){
            System.out.print(" "+tmp.val);
            tmp = tmp.next;
        }
        System.out.println();
    }
}

我们简单测试一下：

@Test
    public void test1(){
        MyLinkedList linkedList = new MyLinkedList();
        for (int i = 0; i < 10; i++) {
            linkedList.addNode(i);
        }
        linkedList.print();

        linkedList.addNode(10,1);
        linkedList.print();
        linkedList.addNode(11,5);
        linkedList.print();
        linkedList.deleteNode(1);
        linkedList.print();
        linkedList.deleteNode(5);
        linkedList.print();
    }

实验结果如下：

 0 1 2 3 4 5 6 7 8 9
 10 0 1 2 3 4 5 6 7 8 9
 10 0 1 2 11 3 4 5 6 7 8 9
 0 1 2 11 3 4 5 6 7 8 9
 0 1 2 11 4 5 6 7 8 9

参考：java程序员面试笔试宝典

---