Improved previous notes on lists.

Author: Clément

source/code/projects/CList/CList/CList.cs

@@ -2,94 +2,86 @@
 
 public class CList<T>
 {
-  // A CList is … a Cell.
-  private Cell first;
+    // A CList is … a Cell.
+    private Cell first;
 
-  // By default, a CList contains only an empty cell.
-  public CList()
-  {
-    first = null;
-  }
-
-  // A Cell is itself two things:
-  // - An element of data (of type T),
-  // - Another cell, containing the next element of data.
-  // We implement this using automatic properties:
-  private class Cell
-  {
-    public T Data { get; set; }
-    public Cell Next { get; set; }
-
-    public Cell(T dataP, Cell nextP)
+    // By default, a CList contains only an empty cell.
+    public CList()
     {
-      Data = dataP;
-      Next = nextP;
+        first = null;
     }
-  }
 
-  // A method to add a cell at the beginning
-  // of the CList (to the left).
-  // We call it AddF for "Add First".
+    // A Cell is itself two things:
+    // - An element of data (of type T),
+    // - Another cell, containing the next element of data.
+    // We implement this using automatic properties:
+    private class Cell
+    {
+        public T Data { get; set; }
+        public Cell Next { get; set; }
 
-  public void AddF(T dataP)
-  {
-    first = new Cell(dataP, first);
-  }
+        public Cell(T dataP, Cell nextP)
+        {
+            Data = dataP;
+            Next = nextP;
+        }
+    }
 
-  // We will frequently test if
-  // a CList is empty, so we introduce
-  // a method for that:
-  public bool IsEmpty()
-  {
-    return (first == null);
-  }
+    // A method to add a cell at the beginning
+    // of the CList (to the left).
+    // We call it AddF for "Add First".
 
-  // A method to add a cell at the end
-  // of the CList (to the right).
-  // We call it AddL for 'Add Last'.
-  public void AddL(T dataP)
-  {
-    if (IsEmpty())
-      AddF(dataP);
-    else
+    public void AddF(T dataP)
     {
-      Cell cCell = first;
-      while (cCell.Next != null)
-      // As long as the cCell Cell has a neighbour…
-      {
-        cCell = cCell.Next;
-        // We move the cCell cell to this neighbour.
-      }
-      // When we are done, we can insert the cell.
-      cCell.Next = new Cell(dataP, null);
+        first = new Cell(dataP, first);
     }
-  }
 
-  // Property for the size of the CList.
-  public int Size
-  {
-    get
+    // We will frequently test if
+    // a CList is empty, so we introduce
+    // a method for that:
+    public bool IsEmpty()
     {
-      int size;
-      if (IsEmpty())
-      {
-        size = 0;
-      }
-      else
-      {
-        size = 1;
-        Cell cCell = first;
-        while (cCell.Next != null)
-        // As long as the cCell Cell has a neighbour…
+        return (first == null);
+    }
+
+    // A method to add a cell at the end
+    // of the CList (to the right).
+    // We call it AddL for 'Add Last'.
+    public void AddL(T dataP)
+    {
+        if (IsEmpty())
+            AddF(dataP);
+        else
         {
-          cCell = cCell.Next;
-          // We move the cCell cell to this neighbour.
-          size++;
+            Cell cCell = first;
+            while (cCell.Next != null)
+            // As long as the cCell Cell has a neighbour…
+            {
+                cCell = cCell.Next;
+                // We move the cCell cell to this neighbour.
+            }
+            // When we are done, we can insert the cell.
+            cCell.Next = new Cell(dataP, null);
         }
-      }
-      return size;
     }
-  }
+
+    // Property for the size of the CList.
+    public int Size
+    {
+        get
+        {
+            int size = 0;
+            Cell cCell = first;
+            while (cCell != null)
+            // As long as the cCell Cell has a neighbour…
+            {
+                cCell = cCell.Next;
+                // We move the cCell cell to this neighbour.
+                size++;
+            }
+            return size;
+        }
+    }  
 
   // We can implement a ToString method
   // "the usual way", using a loop

source/lectures/data/lists.md

@@ -7,6 +7,29 @@ tags:
 
 ## Introduction
 
+### Abstract Data Type
+
+Described [abstractly](./lectures/data/intro#abstract-data-types), [a list](https://en.wikipedia.org/wiki/List_(abstract_data_type)) is 
+
+- a finite collection of elements,
+- in a particular order,
+- that may contain the same element multiple times.
+
+The fact that it may contain the same element multiple times makes it different from a set, the fact that it is ordered makes it different from a [multiset](https://en.wikipedia.org/wiki/Multiset).
+
+Generally, it has operations to…
+
+- … create an empty list,
+- … test for emptiness, 
+- … add an element at "the beginning" of the list,
+- … add an element at "the end" of the list,
+- … remove an element at "the beginning" of the list,
+- … remove an element at "the end" of the list,
+- … access an element at index $i$.
+
+
+### Difference with array 
+
 The `List` class serves a similar purpose than arrays, but with a few notable differences:
 
 - Lists do not need to have a number of elements fixed ahead of time,
@@ -19,6 +42,8 @@ The [complete description of the `List` class](https://learn.microsoft.com/en-us
 
 ## Syntax
 
+We discuss here the "built-in" implementation of lists in C#.
+
 ### Creation
 
 The syntax to create an empty list of `string` named `nameList` and a list of `int` named `valueList` containing 1, 2 and 3 is:

source/solutions/misc/complexity.md

@@ -48,14 +48,11 @@
 
 #. Write a code snippet (no need to include `using` statements or `Main` header) that displays the sum of all the values in a `score` `int` array that you can suppose declared and initialized.  What is the worst case time complexity of the algorithm you wrote, relative to the size $n$ of the array `score`?
 
-    <details><summary>Solution</summary>
-    ```
+    <details><summary>Solution</summary>```
     int sum = 0;
     for(int i = 0; i < score.Length; i++){sum += score[i];}
     Console.WriteLine($"The sum is {sum}.");
     ```
 
     This algorithm is linear: it goes through the array once.
     </detail>
-    
-