Struct ListNode

pub struct ListNode {
    pub val: i32,
    pub next: Option<Box<ListNode>>,
}

Description

The struct works by having a value and an optional pointer to a next ListNode. When writing the nodes you need to start from the last one and make your way down to the first one.

The struct signature is entirely 1:1 with LeetCode with additional optional features like serde.

Example

use leetcode_trees_rs::utils::ListNode;
use std::boxed::Box;
use std::option::Option;

// Last node
let node_3 = ListNode::new(7);

// Second node
let node_2 = ListNode{
    val: 6,
    next: Some(Box::new(node_3)),
};

// First node
let node_1 = ListNode {
    val: 5,
    next: Some(Box::new(node_2)),
};

Result: 5 -> 6 -> 7 -> None

Big O

Peeking/modifying the first element -> O(1)

Peeking/modifying the last element -> O(n)

Removing the first element -> O(1)

Removing any next element -> O(n)

Adding a new element at the end -> O(n)

Adding a new element at the start -> O(1)

Searching -> O(n)

Fields

val: i32

This uses normal i32 values that can be serialized and deserialized using serde if wanted.

next: Option<Box<ListNode>>

An optional box for a next ListNode.

Implementations

impl ListNode

pub fn new(val: i32) -> Self

Used to make a new ListNode with next as None.

Trait Implementations

impl Clone for ListNode

fn clone(&self) -> ListNode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ListNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for ListNode

fn eq(&self, other: &ListNode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ListNode

impl StructuralPartialEq for ListNode