数据结构-自定义单链表

复制代码
package cn.dragon.arithmetic.model;

import java.util.NoSuchElementException;

//单向链表
public class MySingleTrackLInkedList<T> {

    private static class Node<T> {
        T val;

        Node<T> next;

        public Node(T val) {
            this.val = val;
            this.next = null;
        }
    }

    private Node<T> head;
    private Node<T> tail;
    private int size;

    public MySingleTrackLInkedList() {
        this.head = new Node<>(null);
        this.tail = head;
        this.size = 0;
    }

    public void addFirst(T d) {
        Node<T> newNode = new Node<>(d);
        newNode.next = head.next;
        head.next = newNode;
        if (size == 0) {
            tail = newNode;
        }
        size++;
    }

    public void addLast(T d) {
        Node<T> newNode = new Node<>(d);
        tail.next = newNode;
        tail = newNode;
        size++;
    }

    public void add(int index, T element) {
        checkPositionIndex(index);

        if (index == size) {
            addLast(element);
            return;
        }

        Node<T> prev = head;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        Node<T> newNode = new Node<>(element);
        newNode.next = prev.next;
        prev.next = newNode;
        size++;
    }

    public T removeFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }
        Node<T> first = head.next;
        head.next = first.next;
        if (size == 1) {
            tail = head;
        }
        size--;
        return first.val;
    }

    public T removeLast() {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }
        Node<T> prev = head;
        while (prev.next != tail) {
            prev = prev.next;
        }
        T val = tail.val;
        prev.next = null;
        tail = prev;
        size--;
        return val;
    }

    public T remove(int index) {
        checkElementIndex(index);
        Node<T> prev = head;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }

        Node<T> nodeToRemove = prev.next;
        prev.next = nodeToRemove.next;
        if (index == size - 1) {
            tail = prev;
        }
        size--;
        return nodeToRemove.val;
    }

    public T getFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }
        return head.next.val;
    }

    public T getLast() {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }
        return getNode(size - 1).val;
    }

    public T get(int index) {
        checkElementIndex(index);
        Node<T> p = getNode(index);
        return p.val;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    private void checkElementIndex(int index) {
        if (!isElementIndex(index)){
            throw new IndexOutOfBoundsException();
        }
    }

    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index)) {
            throw new IndexOutOfBoundsException();
        }
    }

    private Node<T> getNode(int index) {
        Node<T> p = head.next;
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        return p;
    }

    public static void main(String[] args) {
        MySingleTrackLInkedList<Integer> list = new MySingleTrackLInkedList<>();
        list.addFirst(1);
        list.addFirst(2);
        list.addLast(3);
        list.addLast(4);
        list.add(2, 5);

        System.out.println(list.removeFirst()); // 2
        System.out.println(list.removeLast()); // 4
        System.out.println(list.remove(1)); // 5

        System.out.println(list.getFirst()); // 1
        System.out.println(list.getLast()); // 3
        System.out.println(list.get(1)); // 3
    }

}
相关推荐
dragoooon3426 分钟前
[优选算法专题二滑动窗口——串联所有单词的子串]
数据结构·c++·学习·算法·leetcode·学习方法
阿让啊8 小时前
C语言strtol 函数使用方法
c语言·数据结构·c++·单片机·嵌入式硬件
superlls11 小时前
(算法 哈希表)【LeetCode 349】两个数组的交集 思路笔记自留
java·数据结构·算法
Ripple1231213 小时前
数据结构:顺序表与链表
数据结构·链表
一个响当当的名号13 小时前
B树,B+树,B*树(无代码)
数据结构·b树
古译汉书15 小时前
嵌入式铁头山羊stm32-ADC实现定时器触发的注入序列的单通道转换-Day26
开发语言·数据结构·stm32·单片机·嵌入式硬件·算法
野犬寒鸦15 小时前
力扣hot100:相交链表与反转链表详细思路讲解(160,206)
java·数据结构·后端·算法·leetcode
GalaxyPokemon16 小时前
LeetCode - 1089. 复写零
数据结构
失散1316 小时前
分布式专题——1.2 Redis7核心数据结构
java·数据结构·redis·分布式·架构
zzzsde17 小时前
【数据结构】强化训练:从基础到入门到进阶(1)
数据结构