From cf53b5834bc17a74a7945d55167f303c954b3d4b Mon Sep 17 00:00:00 2001 From: Liu Xinyu Date: Mon, 26 Feb 2024 17:05:59 +0800 Subject: [PATCH] Updated list - definition (EN) --- others/appendix/list/list-en.tex | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/others/appendix/list/list-en.tex b/others/appendix/list/list-en.tex index ad4aa8720..44413bf96 100644 --- a/others/appendix/list/list-en.tex +++ b/others/appendix/list/list-en.tex @@ -35,12 +35,12 @@ \chapter{List} \section{Introduction} \label{introduction} -List and array are build blocks for other complex data structure. Both hold multiple elements as a container. Array is a range of consecutive cells indexed by a number (address). It is typically bounded with fixed size. While list increases on-demand. One can traverse a list one by one from head to tail. Particularly in functional settings, list plays critical role to control the computation and logic flow\footnote{In low level, lambda calculus plays the most critical role as one of the computation model equivalent to Turing machine\cite{mittype}, \cite{unplugged}.}. Readers already be familiar with map, filter, fold are safe to skip this chapter, and directly start from chapter 2. +List and array are build blocks for other complex data structure. They both hold multiple elements as containers. Array has a range of consecutive cells indexed by a number (address). It is typically bounded with fixed size when declared; while list increases on-demand. One traverses a list of elements one by one from head to tail. list plays critical role to control the computation and logic flow particularly in functional settings\footnote{Modeled by lambda calculus at low level, which is equivalent to Turing machine\cite{mittype}, \cite{unplugged}.}. Readers who have already been familiar with map, filter, fold, and etc., are safe to skip this chapter, and directly start from chapter 2. \section{Definition} \index{List!definition} -List, or singly linked-list is a data structure recursively defined as: A {\em list} is either empty, denoted as $[\ ]$ or NIL; or contains an element (also called key) and liked with a sub-{\em list} (called next). \Cref{fig:list-example} shows a list of nodes. Every node links to the next or NIL (the last). We often define list with the compound structure\footnote{In most cases, the data stored in list have the same type. However, there is also heterogeneous list, like the list in Lisp for example.}, for example: +List, or singly linked-list, is a data structure recursively defined as: A {\em list} is either empty, denoted by $[\ ]$ or NIL; or contains an element (also called key) and is linked with a sub-{\em list} (called next). \Cref{fig:list-example} shows a list of nodes; every node links to the next or NIL (the last). We often define list with some compound structure\footnote{We assume the data stored in list have the same type. However, there is also heterogeneous list, e.g., the list in Lisp.}, for example: \begin{figure}[htbp] @@ -65,11 +65,11 @@ \section{Definition} \end{lstlisting} \index{List!empty} \index{List!empty testing} -Many programming environments support the NIL concept. There are two ways to represent the empty list: use NIL (or null, or $\nil$) directly, or create a list, but put nothing as $[\ ]$. From implementation perspective, NIL need not allocate any memories, while $[\ ]$ does. +Many programming environments support the NIL concept. There are two ways to represent the empty list: use NIL (or null, or $\nil$) directly, or create a list, but put nothing as $[\ ]$. From implementation perspective, NIL doesn't need any allocated memories, while $[\ ]$ does. \subsection{Access} \index{List!head} \index{List!tail} \index{List!Construction} \index{List!cons} -Given a none empty list $X$, define two functions\footnote{We often write function $f(x)$ as $f\ x$, and $f(x, y, ..., z)$ as $f\ x\ y\ ...\ z$.} to access the first element, and the rest sub-list. They are often called as \textit{first}\ $X$ and \textit{rest}\ $X$, or $head\ X$ and $tail\ X$\footnote{They are named as \texttt{car} and \texttt{cdr} in Lisp due to the design of machine registers\cite{SICP}.}. Conversely, we can construct a list from an element $x$ and another list $xs$ (can be empty), as $x \cons xs$. It is called the \texttt{cons} operation. We have the following equations: +Given a none empty list $X$, define two functions\footnote{We often write function $f(x)$ as $f\ x$, and $f(x, y, ..., z)$ as $f\ x\ y\ ...\ z$.} to access the first element and the rest sub-list. They are often named as \textit{first}\ $X$ and \textit{rest}\ $X$, or $head\ X$ and $tail\ X$\footnote{They are named as \texttt{car} and \texttt{cdr} in Lisp due to the design of machine registers\cite{SICP}.}. Conversely, we construct a list from an element $x$ and another list $xs$ (can be empty), as $x \cons xs$. It is called the \texttt{cons} operation. \be \begin{cases} @@ -79,16 +79,17 @@ \subsection{Access} \label{eq:list-head-tail} \ee -For a none empty list $X$, we also denote the first element as $x_1$, and the rest sub-list as $X'$. For example, when $X = [x_1, x_2, x_3, ...]$, then $X' = [x_2, x_3, ...]$. +For a none empty list $X$, we often denote the first element as $x_1$, and the rest sub-list as $X'$. For example, when $X = [x_1, x_2, x_3, \dotsc]$, then $X' = [x_2, x_3, \dotsc]$. \begin{Exercise}[label={ex:list-eq}] -\Question{For list of type $A$, suppose we can test if any two elements $x, y \in A$ are equal, define the algorithm to test if two lists are equal.} +\Question{For list of type $A$, suppose we can test if any two elements $x, y \in A$ are equal; define the algorithm to test if two lists are equal.} \end{Exercise} \begin{Answer}[ref={ex:list-eq}] -\Question{For list of type $A$, suppose we can test if any two elements $x, y \in A$ are equal, define the algorithm to test if two lists are equal. +\Question{For list of type $A$, suppose we can test if any two elements $x, y \in A$ are equal; define the algorithm to test if two lists are equal. -We use type constraint to ensure compare lists of the same type. +\vspace{3mm} +We use type constraint to assert comparing lists of the same type. \begin{Haskell} (==) :: [a] -> [a] -> Bool [] == [] = True