单链表的操作API

/**
 * 1.1 根据值查询返回节点 findByValue
 * 1.2 根据角标查询返回指定的角标的值的节点 findByIndex
 * 2.1 链表头部插入 insertToHead
 * 2.2 链表尾部插入 insertTail
 * 3.1 在指定节点的之前插入 insertBefore
 * 3.2 在指定节点的之后插入 insertAfter
 * 4.1 根据对应的节点上的值删除节点 deleteByNode
 * 4.2 根据对应的节点删除节点  deleteByValue
 */
public class SinglyLinkedList {
    private Node head = null;
    public static class Node{
        public int data;
        public Node next;
        public Node() {
        }
    public Node(int data, Node node) {
            this.data = data;
            this.next = node;
        }
        public int getData() {
            return data;
        }
        public void setData(int data) {
            this.data = data;
        }
        public Node getNode() {
            return next;
        }
        public void setNode(Node node) {
            this.next = node;
        }
    }

    /**
     * 根据值查询返回节点
     * @param data
     * @return
     */
    public Node findByValue(int data){
        Node p = head;
        while (p!=null && p.data != data){
              p = p.next;
        }
        return p;
    }

    /**
     * 根据角标查询返回指定的角标的值的节点
     * @param raduis
     * @return
     */
    public Node findByIndex(int raduis){
        Node p = head;
        int pos = 0;
        while (p!=null && pos != raduis){
             p = p.next;
             pos++;
        }
        return p;
    }

    /**
     * 插入新的节点数据
     * @param data
     */
    public void  insertToHead(int data){
      Node newNode = new Node(data,null);
      insertToHead(newNode);
    }

    /**
     * 新节点
     * @param newNode
     */
    public void insertToHead(Node  newNode){
        if(head == null){
            head = newNode;
        }else {
           newNode.next = head;
           head = newNode;
        }
    }

    /**
     * 尾部插入
     * @param data
     */
    public void insertTail(int data){
     Node newNode = new Node(data,null);
     insertTail(newNode);
    }


    public void insertTail(Node newNode){
        if(head == null){
           head = newNode;
        }else {
          Node p = head;
          while (p != null){
             p = p.next;
          }
          p.next =newNode;
        }
    }


    /**
     * 在指定的节点之前插入节点数据
     * @param node 指定的节点
     * @param newNode 要插入的新的数据
     */
    public void insertBefore(Node node,Node newNode){
        if(node == null ){
            return;
        }
        if(head == null){
           insertToHead(newNode);
        }
        Node p = head;
        while (p!= null && p.next!= node){
            p = p.next;
        }
        if(p == null){
            return;
        }
        newNode.next = node;
        p.next = newNode;
    }

    /**
     * 在指定的节点之后插入数据
     * @param node 指定的节点
     * @param newNode 要插入数据
     */
    public void insertAfter(Node node,Node newNode){
       if(node == null){
           return;
       }
        if(head == null){
            insertToHead(newNode);
        }
        newNode.next = node.next;
        node.next = newNode;
    }


    /**
     * 删除指定的节点
     * @param node 指定的节点数据
     */
    public void deleteByNode(Node node){
      if(head == null || node == null ){
          return;
      }
      if(node == head){
          head = head.next;
      }
      Node  p = head;
      while (p!= null && p.next != node){
         p = p.next;
      }
      if(p == null){
          return;
      }
      p = p.next.next;
      node.next = null;
    }

    /**
     * 根据指定的值删除对应的链表节点
     * @param value 对应的值
     */
    public void deleteByValue(int value){
        if(head == null){
            return;
        }

        Node p = head;
        Node prev = null;
        while (p!=null && p.data != value){
            prev = p;
            p = p.next;
        }

        if(p == null){
           return;
        }

        if(prev == null){
           head = head.next;
        }else {
            prev.next = p.next;
            p.next = null;
        }

    }

}