2021-02-04 java实现链表

java实现链表

一、单向链表

1. 单指针，指针指向下一个元素
2. 指定位置新增元素，如果是在头部位置，先初始化节点，将头部节点赋值给这个节点的下一位指针，如果不是头部位置，循环遍历链表找到要插入的位置，将当前节点的下一位指针指向新增节点的下一位指针，然后将新增节点赋值给当前节点的下一位指针。
3. 删除节点，循环遍历链表，找到要删除位置的元素，然后设置头部节点和头部节点的下一位，循环遍历，每一次遍历不仅要找到当前节点的下一位指针，还要找到当前节点下一位指针指向的节点指向的下一位节点，当找到要删除的位置时，将当前指针指向的一位节点的下一位节点赋值给当前节点的下一位指针

public class SingleLinkedList {

    Node head;//定义头节点
     int size;//链表的长度

    static class Node{
        int data;//实际值
        Node next;//指针--指向下一个

        public Node() {
        }

        public Node(int data, Node next) {
            this.data = data;
            this.next = next;
        }
    }

    public SingleLinkedList() {
    }

    public SingleLinkedList(Node head, int size) {
        this.head = head;
        this.size = size;
    }

    //在单向链表的末尾新增节点
    public void addLast(int data){
        Node node = new Node(data,null);
        //判断当前链表是否为空
        if(head==null){
            head=node;
            size++;
            return;
        }
        Node head = this.head;
        //循环遍历找到链表的末尾
        while (head.next!=null){
            head=head.next;
        }
        head.next=node;
        size++;
    }
    //在单向列表的头部新增节点
    public void addHead(int data){
        Node node = new Node(data,null);
        //判断当前链表是否为空
        if(head==null){
            head=node;
            return;
        }
        node.next=head;
        head=node;
        size++;
    }
    //在单向链表的指定位置新增元素
    public void addIndex(int index,int data){
        //判断插入位置是否下标越界
        if(index<0||index>size){
            System.out.println("下标越界");
            return;
        }
        //循环遍历下标的位置
        Node node1 = new Node(data,null);
        if(index==0){
            node1.next=head;
            head=node1;
            return;
        }else {
            index--;
        }
        Node node = head;
        int i = 0;
        while (node.next!=null){
            if(index==i) {
                node1.next=node.next;
                node.next = node1;
                size++;
                break;
            }
            node=node.next;
            i++;
        }
    }
    //查找指定位置的元素
    public int getIndexByData(int index){
        //判断插入位置是否下标越界
        if(index<0||index>size){
            System.out.println("下标越界");
        }
        //循环遍历
        Node node = head;
        int a=0;
        while (node.next!=null){
            if(index==a){
                return node.data;
            }
            node=node.next;
            a++;
        }
        return 0;
    }
    //删除指定位置的元素  remove
    public void remove(int index){
        //判断插入位置是否下标越界
        if(index<0||index>size){
            System.out.println("下标越界");
        }
        index--;
        //循环遍历
        Node node = head;
        Node next = node.next;//下一个节点
        int a=0;
        while (node.next!=null){
            if(index==a){
                node.next=next.next;
                return;
            }
            node=node.next;
            next=next.next;
            a++;
        }

    }
    @Override
    public String toString() {
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append('[');
        Node node = head;
        while (node!=null){
            stringBuffer.append(node.data);
            if(node.next!=null){
                stringBuffer.append(',');
            }
            node=node.next;
        }
        stringBuffer.append(']');
        return stringBuffer.toString();
    }

    public static void main(String[] args) {
        SingleLinkedList linkedList = new SingleLinkedList();
        linkedList.addLast(1);
        linkedList.addLast(2);
        linkedList.addLast(3);
        linkedList.addLast(4);
        linkedList.addLast(5);
        linkedList.addHead(6);
        linkedList.addIndex(2,9);
        linkedList.remove(2);
//        System.out.println(linkedList.getIndexByData(2));
        System.out.println(linkedList.toString());
    }
}