Let's start with the array data structure. You can use it to store many variables of the same type, such as int, string, or a user-defined class. As mentioned in the introduction, while developing applications in the C# language, you can benefit from a few variants of arrays, as presented in the following diagram. You have access not only to single-dimensional arrays (indicated as a), but also multi-dimensional (b), and jagged (c). Examples of all of them are shown in the following diagram:

What is important is that the number of elements in an array cannot be changed after initialization. For this reason, you will not be able to easily add a new item at the end of the array or insert it in a given position within the array. If you need such features, you can use other data structures described in this chapter, such as generic lists.

There are many algorithms that perform various operations on arrays. However, one of the most common tasks is sorting an array to arrange its elements in the correct order, either ascending or descending. The topic of sorting algorithms involves many approaches, including selection sort, insertion sort, bubble sort, and quicksort, which will be explained in detail in this part of the chapter.

Let's start with the selection sort, which is one of the simplest sorting algorithms. The algorithm divides the array into two parts, namely sorted and unsorted. In the following iterations, the algorithm finds the smallest element in the unsorted part and exchanges it with the first element in the...

Arrays are really useful data structures and they are applied in many algorithms. However, in some cases their application could be complicated due to their nature, which does not allow to increase or decrease the length of the already-created array. What should you do if you do not know the total number of elements to store in the collection? Do you need to create a very big array and just not use unnecessary elements? Such a solution does not sound good, does it? A much better approach is to use a data structure that makes it possible to dynamically increase the size of the collection if it is necessary.

The first data structure that meets this requirement is the array list, which is represented by...

In this chapter, you have already learned how to store data using arrays and lists. However, do you know that you can even use a data structure that ensures that the elements are sorted? If not, let's get to know the SortedList generic class (from the System.Collections.Generic namespace), which is a collection of key-value pairs, sorted by keys, without the necessity of sorting them on your own. It is worth mentioning that all keys must be unique and cannot be equal to null.

You can easily add an element to the collection using the Add method, and remove a specified item using the Remove method. Among other methods, it is worth noting ContainsKey and ContainsValue for checking whether the collection contains an item with a given key or value, as well as IndexOfKey and IndexOfValue for returning an index of a given key or value within the collection...

While using the List generic class, you can easily get access to particular elements of the collection using indices. However, when you get a single element, how can you move to the next element of the collection? Is it possible? To do so, you may consider the IndexOf method to get an index of the element. Unfortunately, it returns an index of the first occurrence of a given value in the collection, so it will not always work as expected in this scenario.

It would be great to have some kind of pointer to the next element, as shown in the following diagram:

With this approach, you can easily navigate from one element to the next one using the Next property. Such a structure is named the single-linked list. However, can it be further expanded by adding the Previous property to allow navigating in forward and backward directions? Of course! Such a data structure is...

In the previous section, you have learned about the double-linked list. As you can see, the implementation of such a data structure allows for navigating between the nodes using the Previous and Next properties. However, the Previous property of the first node is set to null, as is the Next property of the last node. Do you know that you can easily expand this approach to create the circular-linked list?

Such a data structure is presented in the following diagram:

Here, the Previous property of the first node navigates to the last one, while the Next property of the last node navigates to the first. This data structure can be useful in some specific cases, as you will see while developing a real-world example.

Arrays and lists are among the most common data structures used while developing various kinds of applications. However, this topic is not as easy as it seems to be, because even arrays can be divided into a few variants, namely single-dimensional, multi-dimensional, and jagged arrays, also referred to as arrays of arrays.

In the case of lists, the differences are even more visible, as you could see in the case of simple, generic, sorted, single-linked, double-linked, and circular-linked lists. Fortunately, the built-in implementation is available for the array list, as well as the generic, sorted, and double-linked lists. Furthermore, you can quite easily extend the double-linked list to behave as the circular-linked list. Therefore, you can benefit from the features of suitable structures without the significant development effort.

The available types of data structures...