epicours/Algo/Courses/Chapter 6 - Lists.md

Linear list

Def

A linear data structure is a list where the elements must be treated sequentially.

\lambda = <e_1, e_2, e_3, ..., e_n>

e_1 is the rank of the value e. In linear list, we start at 0 because we don't use index list.

The linear list is evolutive, you can add or remove elements. Also, the linear list can be empty.

List in CAML

# [1 ; 2 ; 3];;
_: int list = [1, 2, 3]

In CAML, all the element in the list have to be of the same type.

# let l1 = ['H', 'i'];;
val l1 : char list = ['H'; 'i']
# let l2 = ['C'; 'a'; 'm'; 'l'];;
val l2 : char list = ['C' ; 'a' ;'m'; 'l']
# [l1; l2]
_: char list list : [['H'; 'i'] ; ['C' ; 'a' ;'m'; 'l']]

The expression char list is the element type of the evaluation

# ["H" ; 'i'];;
Error: string ≠ char
# [(function x -> x + 10); (function y -> 2*y)];;
_: (int -> int) list = [<fun> ; <fun>]

The empty list

# [];;
-: a list = []

Recursive type

e::t => adds the element e at the head (e) of the list tail (f)

# 1::[2; 3];;
_: int list = [1; 2; 3]

# 1::[];;
_: int list = [1]

The constructor is right associative e1::e2::e3::l => e1::(e2::(e3::l)) Exemple :

# [1 ; 2; 3];;
_: int list = [1; 2; 3]
# 1::[2; 3];;
_: int list = [1; 2; 3]
# 1::2::[3];;
_: int list = [1; 2; 3]
# 1::2::3::[];;
_: int list = [1; 2; 3]

Priority

# 1 + 2::[];;
_: int list = [3]

# 1 < 2 :: [];;
Error: int ≠ int list

The priority is somewhere between the addition. To avoid any doubt in the code, we have to put parenthesis.

Concatenation

# let l1 = [1; 2] and l2 = [3; 4];;
val l1: int list = [1, 2]
val l2: int list = [3, 4]

# l1::l2;;
Error: int list ≠ int

#l1 @ l2;;
_: int list = [1 ; 2 ; 3; 4]

The operator @is not constant

List manipulation

Traverse

Sequential traverse have to solution, first is the list is empty, then you stop. Else if the list is not empty, we treat the head

# let p = (1, 2);;
val p: int*int = (1,2)
# let (a, b) = p;;
val a: int = 1
val b: int = 2

# let l = [1; 2; 3];;
val l : int list = [1; 2; 3]
# let e::t = l;;
Warning: the pattern matching is not exhausitve
val e: int = 1
val t: int list = [2; 3]
# let rec length l = 
	if l = [] then 0
	else
		let e::t = l in
			1 +. length t;;
Warning : pattern matching not exhaustive
val length: 'a list -> int = <fun>

# let rec length = function
	| [] -> 0
	| _::t -> 1 + length t;;
(* with this solution there is no warning *)
val length : 'a list -> int = <fun>