数据结构（二）【单链表】

单链表

import org.w3c.dom.Node;
import java.util.*;
public class Mylinked implements List {
    /*
    链表的头节点，第一个元素
    */
    private Node first;
    /*
    元素个数
    */
    private int size;

    //链表的大小

    @Override
    public int size() {
        return size;
    }
    //链表是否为空

    @Override
    public boolean isEmpty() {
        return size == 0;
    }
    /**
     是否包含
     */

    @Override
    public boolean contains(Object o) {
        Node c = first;
        while(c != null){
            if(c.value.equals(o)){
                return true;
            }
            c = c.next;
        }
        return false;
    }

    /**
     * @return 
     */
    @Override
    public Iterator iterator() {
        return null;
    }


    /**
      输出数组
     */

    @Override
    public Object[] toArray() {
        Object[] arr = new Object[size];
        int index =0;
        Node c = first;
        while(c != null){
            arr[index ++] = c.value;
            c = c.next;
        }
        return arr;
    }
    /**
     添加元素，返回boolean
     */

    @Override
    public boolean add(Object obj) {
        /*
        * Object -->Node
        * */
        Node current = new Node(obj,null);
        if(first == null){
            first = current;
        }else {
            Node c = first;
            while (c.next != null){
                c = c.next;
            }
            c.next = current;
        }
        size++;
        return  true;
    }


    @Override
    public boolean remove(Object o) {
        // 判断链表上是否有元素
        if (size <= 0){
            return false;
        }
        Node remove = new Node(o, null);
        // 判断是不是头结点
        if (first.equals(remove)) {
            Node c = first;
            first = c.next;

            c.next = null;
            size --;
            return true;
        } else {
            Node pre = first; // 被删除元素的前一个元素
            Node c = first.next; // 假设 将要被删除的元素


            while (c != null && !c.equals(remove)){
                // 找下一个元素
                pre = c;
                c = c.next;
            }

            if (c != null){ // 删除节点
                pre.next = c.next;
                c.next = null;
                size --;
                return true;
            }

        }
        return false;
    }




    @Override
    public boolean addAll(Collection c) {
        return false;
    }


    @Override
    public boolean addAll(int index, Collection c) {
        return false;
    }

    /**
     * @param c collection containing elements to be retained in this list 
     * @return
     */
    @Override
    public boolean retainAll(Collection c) {
        return false;
    }


    @Override
    public void clear() {
        first = null;
        size = 0;
    }
    /**
     * 返回当前下标的节点
     */

    @Override
    public Object get(int index) {
        checkIndex(index);
        Node c = first;
        for(int i = 0;i <index; i++){
            c = c.next;

        }
        return c.value;
    }


    @Override
    public Object set(int index, Object element) {
        checkIndex(index);
        Node c = first;
        for(int i =0;i < index;i++){
            c = c.next;
        }
        Object old = c.value;
        c.value = element;

        return old;
    }
    private void checkIndex(int index){
        if(index < 0 || index > size-1){

        throw new LinkIndexOutOfBoundsException("下标错误");
        }
    }
    /*
    在指定位置添加元素
    */


    @Override
    public void add(int index, Object element) {
        if(index < 0 || index > size +1) {
            throw new LinkIndexOutOfBoundsException("下标错误");
        }
        if(index == 0){
            first = new Node(element,first);
        }
        Node pre = first;
        Node c = first.next;
        for(int i =1;i < index;i++){
            pre = c;
            c = c.next;
        }
        pre.next = new Node(element,c);
        size ++;
    }

    @Override
    public Object remove(int index) {
        checkIndex(index);
        Node pre = first;
        Node c = first.next;
        if(index == 0){
            first = first.next;
        }
        for(int i = 0;i < index;i++){
            pre =c;
            c = c.next;
        }
        pre.next = c.next;
        return true;
    }


    @Override
    public int indexOf(Object o) {
        Node current = first;
        int index = 0;
        while (current != null) {
            if (current.value.equals(o)) {
                return index;
            }
            current = current.next;
            index++;
        }
        return -1;

    }


    @Override
    public int lastIndexOf(Object o) {
        Node c = first;
        int lastIndex = -1;
        int index = 0;
        while (c != null) {
            if (c.value.equals(o)) {
                lastIndex = index;
            }
            c = c.next;
            index++;
        }
        return lastIndex;
    }

    /**
     * @return 
     */
    @Override
    public ListIterator listIterator() {
        return null;
    }

    /**
     * @param index index of the first element to be returned from the 
     *              list iterator (by a call to {@link ListIterator#next next})
     * @return
     */
    @Override
    public ListIterator listIterator(int index) {
        return null;
    }

    /**
     * @param fromIndex low endpoint (inclusive) of the subList 
     * @param toIndex   high endpoint (exclusive) of the subList
     * @return
     */
    @Override
    public List subList(int fromIndex, int toIndex) {
        return null;
    }


    @Override
    public boolean removeAll(Collection c) {
        return false;
    }


    @Override
    public boolean containsAll(Collection c) {
        return false;
    }


    @Override
    public Object[] toArray(Object[] a) {
        return new Object[0];
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node c = first;
        sb.append("linked[");
        while (c.next != null) {
            sb.append(c.value);
            sb.append(",");
            c = c.next;
        }
        sb.append(c.value).append("]");
        return sb.toString();
    }
    /**
    链表中的节点对象
     */
    private class Node{
        /*
        元素的值
         */
        private Object value;
        /*
        下一个节点
        */
        private Node next;
        public Node(Object value,Node next){
            this.value = value;
            this.next = next;
        }
        /**
         * 判断 node 节点是否一样
         *  node 的值是否一样
         * @param obj
         * @return
         */
        @Override
        public boolean equals(Object obj){
            if (obj == null){
                return false;
            }

            if (obj == this){
                return true;
            }

            if (obj instanceof Node node){
                if (this.value == null){
                    return node.value == null;
                } else {
                    return value.equals(node.value);
                }
            }
            return false;
        }
    }
}

class LinkIndexOutOfBoundsException extends IndexOutOfBoundsException{
    public LinkIndexOutOfBoundsException(String mesage){
        super.getMessage();
    }
}

测试

package com.kfm.structure;/*
@CreatTime：2023-08-30   10:41
*/

import java.util.Arrays;

public class MylinkedTest {
    public static void main(String[] args) {
        Mylinked mylinked = new Mylinked();
        //判断列表是否为空
        System.out.println(mylinked.isEmpty());
        //输出链表长度
        System.out.println(mylinked.size());
        //添加节点
        mylinked.add("null");
        mylinked.add("a");
        mylinked.add("b");
        mylinked.add("c");
        mylinked.add("d");
        System.out.println(mylinked);
        System.out.println(mylinked.size());
        mylinked.remove("b");
        System.out.println(mylinked);
        System.out.println(mylinked.size());
        System.out.println(mylinked.indexOf("c"));
        mylinked.set(3,"3");
        System.out.println(mylinked);
        System.out.println(Arrays.toString(mylinked.toArray()));
        System.out.println(mylinked.get(2));

    }



}