If you have ever wondered whether or not you need to master a red-black tree or a max heap to become a proficient iOS developer, the answer is, probably not. In fact, you may never use either of them throughout your career!
Now I don’t mean to say you shouldn’t learn any data structures outside of the ones I will list in this post, you should definitely be aware of them because you never know when they may come in handy. However, our time is limited, so if you want to know which ones you should focus on the most for mobile development, keep reading!
Arrays
Usually one of the first data structures (DS) learned by developers, arrays are probably the most common DS found in mobile apps. The reason is simple: most apps work with collections of data.
See a real world example of using Arrays to manage large amounts of data using pagination: Infinite Scrolling using SwiftUI
Naturally, arrays are the simplest way to store a collection of data. They are simple to work with and there are a plethora of algorithms that make use of them. A simple example is sorting. Usually it is best to present data to users sorted by a specific property, for example, by name or date. This task is simplest if using an array.
Swift has built in methods for sorting, so you don’t need to implement any algorithms yourself. Below is an example demonstrating how the built in array functions can be used to sort items in a shopping cart.
Additionally, if you have data stored in an array, not only is it easy to sort, it is also easy to manipulate for other common tasks such as filtering. When presenting users with a list of data, it is common to allow them to select and apply filters to narrow down their results. One simple way of applying filters on an array of data is to simply iterate the entire array and build a new one containing only items that match the filter criteria.
Just like for sorting, the arrays in Swift have built in methods for filtering:
Dictionaries
The next most common DS I've seen in iOS apps is the Dictionary, AKA a map, depending on what language you are using (we will use “dictionary” moving forward). Dictionaries contain a collection of key-value pairs which makes them very efficient at accessing a value quickly by using its corresponding key.
There is no need to iterate a dictionary looking for a value, you can simply use the corresponding key for the desired value. This is obviously very useful when you need to quickly check if a value exists in a collection or need quick access to it. This does however, come with a trade-off, which is it requires more memory.
It would be a great idea to familiarize yourself with how dictionaries are implemented so that you understand the trade-offs and know when it is appropriate to use one. Modern mobile devices usually come with sufficient amount of memory so it isn't usually a big issue, but still good to be aware of.
Below is an example of how a dictionary can be used to quickly look up the price of an item.
As you can see from the above example, using a dictionary makes it simple and fast to look up a value. The examples above could also be accomplished with an array, but then we would need to iterate the entire array to find the appropriate value.
Enums
Oftentimes, apps contain predefined, finite data sets that they use in their business logic. Take for example, the different states that an object can be in:
On, Off, Charging
Low, Medium, High
Pending, Approved, Declined
All of these sets of data are usually best represented by an Enumeration (enum). If you are familiar with C, you will know that C enumerations assign related names to a set of integer values. Enumerations in Swift are much more flexible, and don’t have to provide a value for each case of the enumeration.
To see an example of how Enums can be used to manage navigation between screens in iOS apps, see: Router Pattern for SwiftUI Navigation
Using an enum ensures that only values from the set are used. This is checked during compile time. Further, enums in Swift have additional useful features that make enums even more powerful.
In the below example, I demonstrate how the status of a transaction can be represented using an enum. Additionally, I demonstrate how language features in Swift can be used to make enums even more useful.
Sets
Oftentimes there is a need for collections containing unique values only. For example, take a favorite songs playlist, you normally don’t want to allow a song to appear in the playlist more than once. Using a set guarantees each value contained within it is unique.
The set DS can be implemented using an array, or a Dictionary, or other data structures. However, Swift has built in implementations with very useful features.
In both Swift, the set DS makes it easy to perform set operations such as union, intersection, and subtraction.
Conclusion
This was merely a scratch on the surface. All of these data structures support multiple advance operations that we will explore in future posts. Subscribe to our newsletter to learn about upcoming posts or join our membership program to unlock additional resources aimed at helping you advance in your iOS development journey.
Comments