单项链表的介绍与其基本操作

链表

• 单向链表

  每个节点只保存了下一个节点的地址，只能从头开始向后遍历，这种链表结构成为单向链表，简称单链表。

  节点类如何定义？

  类比火车车厢 当前车厢号和链接下一个车厢的挂钩

  class Node{

  int val;//当前节点的保存值。

  Node next;//下一个节点的地址。

  }

  给定一个火车头Node head 就可以便利当前链表中所有的节点从head后开始遍历。

  一个链表对象又一下部分组成：

  class SingleLinedList{

  Node head;//头节点（1号车厢）

  int size;//当前链表中的节点个数，保存元素个数（一个node节点只保存一个值）

  }

/**
 * 基于int的单链表 - 火车类
 *真正被用户去使用的是火车类-单链表对象
 *
 */
public class SingleLinedList {
    //链表的头节点
    private  Node head = null;
    //当前链表中的节点个数= 有效值的个数
    private  int size = 0 ;
    /**
     *向链表中添加一个新节点，默认在链表头部添加
     * add1:每次新增一个节点就要创建一个Node类的对象
     */
    public  void  addFirst(int val) {
        Node newNode = new Node();
        //保存值
        newNode.val = val;
        if (head != null) {
            newNode.next = head;
        }
            //newNode就是第一个节点
            head = newNode;
            //当前火车不为空
            size++;
        }
        //中插
    public void add(int index ,int val){
        //若index是非法的！
        if (index < 0 || index > size){
            System.err.println("add index illegal!");
            return;
        }
        if (index == 0){
            addFirst(val);
        }else{
            Node newNode = new Node();
            newNode.val = val;
            Node prev = head;
            for (int i = 0; i < index -1; i++) {
                prev = prev.next;
            }
            newNode.next = prev.next;
            prev.next = newNode;
            size++;
        }
    }
    //尾插
    public  void  addLast(int val){
        add(size,val);
    }
    //修改
    public  int getByValue(int val){
        int index = 0;
        for (Node x = head; x != null ; x=x.next) {
                if (x.val == val){
                    return index;
                }
                index ++;
        }
        return  -1;
    }
    //查找
    public  boolean contains(int val){
        int index = getByValue(val);
        return  index != -1;
    }
    public  int get(int index){
        //判断index的合法性
        //IDEA的快速修正键ALT+ENTER
        if (rangeCheck(index)){
            Node x = head;
            for (int i = 0; i < index; i++) {
                x = x.next;
            }
            return  x.val;
        }
        System.err.println("index illegal! get error");
        return  -1;
    }

    /**
     * //修改索引为index 的索引值为new val,返回修改前节点值
     * @param index
     * @return
     */
    public  int set(int index, int newVal){
        if (rangeCheck(index)){
                Node x = head;
            for (int i = 0; i < index; i++) {
                x = x.next;
            }
            int oldVal = x.val;
            x.val = newVal;
            return oldVal;
        }
        System.err.println("index illegal! get error");
        return  -1;
    }
    public  int remove (int index){
        if (rangeCheck(index)){
            if (index == 0) {
                //删除头节点
                Node x = head ;
                head = head.next ;
                size --;
                x.next = null;
                return x.val;
            }else {
                //删除中间节点找前驱
                Node prev = head;
                for (int i = 0; i <index ; i++) {
                    prev = prev.next;
                }
                Node node = prev.next;
                prev.next = node.next;
                node.next = null;
                size --;
                return node.val;
            }
        }
        System.err.println("remove index illeagl!");
        return -1;
    }
    private boolean rangeCheck(int index) {
        if (index < 0 || index >=size){
            return  false;
        }
        return  true;
    }

    public  String tostring(){
        String ret = "";
        Node x = head;
        while (x != null){
            ret += x.val;
            ret += "->";
            x = x.next;
        }
        ret += "NULL";
        return  ret;
    }
}

/**
 *单链表具体的每个节点 - 车厢类
 */
class  Node{

    int val;//每个节点保存的值。
    Node next;//当前节点的下一个节点地址
}

测试