Struct ArrayList

pub struct ArrayList<T> { /* private fields */ }

A simple ArrayList implementation

How?

ptr stores the first element of the ArrayList,

cap stores the capacity of the ArrayList grows dynamically if you try to push an element after the allocated memory is already full, it expands by allocating a new chunk of memory double the size of the old one,it copies all the elements in the new ArrayList and deallocates the old one,

len stores the offset in which the top element is stored.

 
STACK
 
   ptr     cap     len
+-------+-------+-------+
| 0x123 |   4   |   2   |   ArrayList
+-------+-------+-------+
 
HEAP
 
+-------+-------+-------+-------+
|   1   |   2   |   ?   |   ?   | ... unallocated memory
+-------+-------+-------+-------+
    ^       ^               ^
   ptr     len             cap
 

Implementations

impl<T> ArrayList<T>

pub fn new(capacity: usize) -> Self

Creates a new ArrayList with the given capacity.

Arguments

• capacity - The initial capacity of the ArrayList.

Examples

use tryingarraylist::ArrayList;
 
let list: ArrayList<i32> = ArrayList::new(10);
 

pub fn push(&mut self, element: T)

Adds an element to the end of the ArrayList.

Arguments

• item - The item to push into the ArrayList.

Examples

use tryingarraylist::ArrayList;
 
let mut list = ArrayList::new(10);
list.push(42);
 

pub fn get(&self, index: usize) -> Option<&T>

Gets the nth element in the ArrayList.

Arguments

• index - index to get in ArrayList.

Returns

Returns Some(&element) if the specified index is within bounds, else returns None.

Examples

use tryingarraylist::ArrayList;
 
let mut list = ArrayList::new(10);
list.push(42);
 
assert!(Some(&42) == list.get(0));
//out of bounds
assert!(None == list.get(1));
 

pub fn len(&self) -> usize

Returns the lenght of the ArrayList.

Examples

use tryingarraylist::ArrayList;
 
let mut list = ArrayList::new(10);
list.push(1);
list.push(2);
list.push(3);
 
assert!(list.len() == 3);
 

pub fn pop(&mut self) -> T

Pops the top most element in the ArrayList.

Returns

Returns element if the ArrayList is not empty, else panics.

Examples

use tryingarraylist::ArrayList;
 
let mut list = ArrayList::new(10);
list.push(1);
list.push(2);
 
assert!(list.pop() == 2));
assert!(list.pop() == 1);
 

pub fn remove(&mut self, index: usize) -> T

Removes the element at the specified index from the ArrayList, shifting all subsequent elements to the left to fill the gap.

Arguments

• index - The index of the element to be removed.

Returns

Returns element if the specified index is within bounds, else panics.

Examples

use tryingarraylist::ArrayList;

let mut list = ArrayList::new(10);
list.push(1);
list.push(2);
list.push(3);

assert_eq!(list.remove(1), 2);
assert_eq!(list.remove(0), 1);
 

pub fn loc(&self) -> *mut T

Returns the memory location (pointer) in which the first element of the ArrayList is stored

pub fn insert(&mut self, index: usize, element: T)

Inserts the element at the specified index from the ArrayList, shifting all subsequent elements to the right to make a gap to insert new element.

Arguments

• index - The index of the element to be inserted in.
• element - The element to be inserted.

Examples

use tryingarraylist::ArrayList;

let mut list = ArrayList::new(10);
list.push(1);
list.push(2);
list.insert(1,3);

assert_eq!(list.pop(), 2);
assert_eq!(list.pop(), 3);
assert_eq!(list.pop(), 1);
 

pub fn reverse(&mut self)

Reverses the order of the elements in the ArrayList

Examples

use tryingarraylist::ArrayList;

let mut list = ArrayList::new(10);
list.push(1);
list.push(2);
list.push(3);
list.reverse();

assert_eq!(list.pop(), 1);
assert_eq!(list.pop(), 2);
assert_eq!(list.pop(), 3);
 

pub fn sort(&mut self)

where T: Ord,

Sorts the elements in the ArrayList using the quicksort algorithm

Examples

use tryingarraylist::ArrayList;

let mut list = ArrayList::new(10);
list.push(6);
list.push(5);
list.push(7);
list.push(4);
list.push(8);
list.push(3);
list.push(9);
list.push(2);
list.push(10);
list.push(1);
list.sort();

assert_eq!(list.pop(), 10);
assert_eq!(list.pop(), 9);
assert_eq!(list.pop(), 8);
assert_eq!(list.pop(), 7);
assert_eq!(list.pop(), 6);
assert_eq!(list.pop(), 5);
assert_eq!(list.pop(), 4);
assert_eq!(list.pop(), 3);
assert_eq!(list.pop(), 2);
assert_eq!(list.pop(), 1);
 

Trait Implementations

impl<T: Clone> Clone for ArrayList<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ArrayList<T>

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

Formats the value using the given formatter.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for ArrayList<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Drop for ArrayList<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Extend<T> for ArrayList<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> FromIterator<T> for ArrayList<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Hash> Hash for ArrayList<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<usize> for ArrayList<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for ArrayList<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T> IntoIterator for ArrayList<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord> Ord for ArrayList<T>

fn cmp(&self, other: &ArrayList<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for ArrayList<T>

fn eq(&self, other: &Self) -> 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<T: PartialOrd> PartialOrd for ArrayList<T>

fn partial_cmp(&self, other: &ArrayList<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Serialize> Serialize for ArrayList<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for ArrayList<T>