Java实现单链表详细代码

用Java写的单链表。具备增删改查功能。有注释。

增：头增、尾增、按照下标（0表示第一个位置）增、按照数值升序排列增

删：按值删除

查：查找给定下标是否存在，查找给定元素是否存在

改：用新值改旧值

Node类：单链表的节点

public class Node {
    public String name;
    public int number;
    public Node next;

    public Node(String name, int number) {
        this.name = name;
        this.number = number;
    }

    @Override
    public String toString() {
        return "Node{" +
                "name='" + name + '\'' +
                ", number=" + number +
                '}';
    }
}

SingleLinkedList类：单链表类

public class SingleLinkedList {
    private Node head;
    private int size;
    public int getSize(){
        return size;
    }

    //判断列表是否为空
    public boolean isEmpty(){
        return head == null;
    }
    //头插法
    public void addFirst(Node node){
        node.next = head;
        head = node;
        size++;
    }
    //尾插法
    public void addLast(Node node){
        if(isEmpty()){
            addFirst(node);
            return;
        }
        Node tmp = head;
        while(tmp.next != null){
            tmp = tmp.next;
        }
        tmp.next = node;
        size++;
    }
    //按值插入，想让链表链表是有序的时可以使用
    public void add(Node node){
        if(isEmpty()){
            addFirst(node);
            return;
        }
        //先与第一个节点比较
        if(node.number > head.number){
            addFirst(node);
            return;
        }
        Node tmp = head;
        boolean flag = false;//用来判断是否插入成功
        while(tmp.next != null){
            if(node.number > tmp.next.number){
                flag = true;
                break;
            }
            tmp = tmp.next;
        }
        if(flag){
            node.next = tmp.next;
            tmp.next = node;
            size++;
            return;
        }
        addLast(node);
    }
    //按下标插入
    public void addByIndex(Node node, int index){
        if(index < 0 || index > size - 1){
            throw new IllegalArgumentException("索引值超出范围！");//越界，抛出异常
        }
        if(index == 0){
            addFirst(node);
            return;
        }
        Node tmp = head;
        int tmpIndex = 0;
        while(tmpIndex != index - 1){
            tmpIndex++;
            tmp = tmp.next;
        }
        node.next = tmp.next;
        tmp.next = node;
        size++;
    }
    //删除元素
    public boolean remove(Node node){
        if(isEmpty()){
            throw new IllegalArgumentException("链表是空的！");
        }
        if(node.number == head.number){
            head = head.next;
            size--;
            return true;
        }
        Node tmp = head;
        while(tmp.next != null){
            if(node.number == tmp.next.number){
                tmp.next = tmp.next.next;
                size--;
                return true;
            }
        }
        return false;
    }
    //查找并返回元素，这里按索引查找
    public Node findByIndex(int index){
        if(index < 0 || index > size - 1){
            throw new IllegalArgumentException("索引值超出范围");//越界，抛出异常
        }
        int tmpIndex = 0;
        Node tmp = head;
        while(tmpIndex != index){
            tmpIndex++;
            tmp = tmp.next;
        }
        return tmp;
    }
    //按值查找元素是否存在，如果存在，返回索引值，不存在返回-1
    public int containsByValue(Node node){
        if(isEmpty()){
            throw new IllegalArgumentException("链表是空的!");
        }
        Node tmp = head;
        int index = -1;
        while(tmp != null){
            index++;
            if(node.number == tmp.number && node.name == tmp.name){
                return index;
            }
            tmp = tmp.next;
        }
        return -1;
    }
    //把旧值改成新值
    public  boolean replaceValue(Node oldNode, Node newNode){
        if(isEmpty()){
            throw new IllegalArgumentException("链表是空的!");
        }
        int index = containsByValue(oldNode);
        if(index == -1){
            return false;
        }
        Node old = findByIndex(index);
        old.number = newNode.number;
        old.name = newNode.name;
        return true;
    }
    //打印链表
    public void printLinkedList(){
        if(isEmpty()){
            throw new IllegalArgumentException("链表是空的!");
        }
        Node tmp = head;
        while(tmp != null){
            System.out.println(tmp);
            tmp = tmp.next;
        }
    }
}

UseSingleLinkedList类：测试单链表的类

public class UseSingleLinkedList {
    public static void main(String[] args) {
        Node n1 = new Node("aaa", 24);
        Node n2 = new Node("bbb", 25);
        Node n3 = new Node("ccc", 49);
        Node n4 = new Node("ddd", 50);
        Node n5 = new Node("eee",24);


        SingleLinkedList sll = new SingleLinkedList();
        System.out.println("============头增测试");
        sll.addFirst(n1);
        sll.addFirst(n2);
        sll.addFirst(n3);
        sll.printLinkedList();
        System.out.println("============尾增测试");
        sll.addLast(n4);
        sll.printLinkedList();
        SingleLinkedList sll2 = new SingleLinkedList();
        System.out.println("============有序链表测试");
        sll2.add(n1);
        sll2.add(n3);
        sll2.add(n2);
//        sll.printLinkedList();
        sll2.add(n4);
        sll2.printLinkedList();
//        sll.remove(n4);
//        sll.printLinkedList();
        System.out.println("============按下标插入测试");
        sll2.addByIndex(n5,1);
        sll2.printLinkedList();
        System.out.println("============删除测试");
        sll2.remove(n5);
        sll2.printLinkedList();
        System.out.println(sll2.getSize());
        System.out.println("============按值查询是否存在");
        System.out.println(sll2.containsByValue(n5));
        System.out.println("============按下标查找");
        System.out.println(sll2.findByIndex(1));
        System.out.println("============旧值换新");
        Node n6 = new Node("zzz",24);
        System.out.println(sll2.replaceValue(n3, n6));
        sll2.printLinkedList();
        System.out.println(sll2.getSize());




    }
}

 欢迎讨论，Java学习路上与大家共勉。