Introduction to Algorithms in Swift
4.4 (7 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
154 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Introduction to Algorithms in Swift to your Wishlist.

Add to Wishlist

Introduction to Algorithms in Swift

Take your software development skills to the next level. Prepare for job interviews. Write faster Swift code.
4.4 (7 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
154 students enrolled
Created by Karoly Nyisztor
Last updated 4/2017
English
English
Curiosity Sale
Current price: $10 Original price: $100 Discount: 90% off
30-Day Money-Back Guarantee
Includes:
  • 1 hour on-demand video
  • 4 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • You will know how to implement better, more efficient code.
  • You will increase your chances to succeed in a developer job interview.
  • You will know what to avoid to create performant software.
  • You’ll have a good understanding of the popular sort algorithms and the way they can be implemented using Swift.
View Curriculum
Requirements
  • This course is beginner-friendly. Prior programming experience may be helpful, but you need not have actually worked with Swift itself.
Description

You are here because you are interested in Swift and algorithms, right?
Maybe you want to learn more about the Swift programming language. You probably want to write more efficient Swift code.

And this is the perfect course for you to learn about algorithms and Swift. 
I created this course to get you started with algorithms. Introduction to Algorithms in Swift will help you understand the importance of algorithms. Soon, you'll be able to solve problems more efficiently.

What makes me qualified to teach you?
My name is Károly, and I’ve been developing software since 1995. I'm the creator of many iOS apps, most of which have been featured by Apple. I published three books on programming. You can find my online courses on Udemy and Pluralsight.

I’m here for You
I'm a full-time online instructor. If you have any questions about the course content or anything related to this topic, you can always post a question in the course or send me a direct message. I always respond promptly.

Contents and Overview
Computer algorithms have been developed and refined over the last couple of decades. The study of algorithms is fundamental to any programmer who plans to develop software system that is scalable and performant.

Once we got past the basic “Hello World” beginner applications, we begin to realize that complex apps require a different approach. Our software that used to work nicely during our tests becomes incredibly slow and crashes frequently in real-world situations. The reason is that we haven’t prepared our app for real-life usage: while it ran without issues with small datasets during our tests, it fails when reality kicks in. Algorithms are indispensable to building software that is capable of managing large amounts of data or to solve complex problems efficiently.

I explain each concept using easy-to-understand examples. You'll not only learn how to implement more efficient code, but you'll also learn Swift, Apple's popular programming language. Beyond iOS and Mac development, Swift is going to become THE programming language for Web-development and systems programming. 

This course is a long-time investment!

With our 30-day 100% money back guarantee, nothing is holding you back from jumping in right now and trying the course out.
Go ahead and click the enroll button. See you in the first lesson!

Cheers,
Károly

Who is the target audience?
  • Who wants to implement better, more performant software applications
  • Who wants to learn how to implement sorting algorithms from basic to advanced
  • Who's interested in clean, modern Swift
  • Who wants to successfully pass technical interviews
Students Who Viewed This Course Also Viewed
Curriculum For This Course
30 Lectures
01:13:13
+
Overview
1 Lecture 04:15

This lecture introduces the main topics presented in this course.

Preview 04:15
+
Big-O Notation
7 Lectures 18:11

In this section we are going to talk about computational complexity. The Big-O notation is a mathematical model used in computer science to describe the efficiency of algorithms as a function of their input size. 

The best way to understand the Big-O thoroughly is via code examples. Therefore, we are going to illustrate each concept using live Swift coding.

Preview 02:20

In this lecture, we are going to talk about the Constant Time complexity. We'll also implement Swift functions that execute in constant time.

Constant Time - O(1)
03:56

This lecture is about the Linear Time complexity. As usual, we'll not only talk about the theory, but we are going to also illustrate O(n) via Swift code examples.

Linear Time - O(n)
03:19

The topic of this lecture is the Quadratic Time complexity. We are going to delve into the world of nested loops and we'll discuss why they should be avoided if possible.

Quadratic Time - O(n2)
03:39

Do your best to avoid polynomial - and worse - time complexity. This lecture explains what to do if you encounter O(n^k).

Hints for O(n^k) Complexity
01:27

Let's take a closer look at the logarithmic time complexity. Logarithmic time represents an extremely efficient algorithm, used by the binary search technique for example.

Logarithmic Time - O(log n)
01:56


Understanding the Big-O notation paves the road to working with algorithms. This lecture is a brief summary of what we've learned during this module.

Summary
01:34

Big-O Quizzes

Big-O Quizzes
3 questions

Xcode playground projects for the Big-O section.

Big-O Playgrounds (Swift Source Code)
+
The Power of Algorithms
5 Lectures 14:30

In this section, we are going to take a closer look at the importance and the benefits of algorithms and algorithmic thinking.

Preview 01:29

In this lecture, we are going to implement a function which calculates the sum of the first N natural numbers. We’ll start with a naive implementation. 
Then, we are going to implement a more efficient way to solve this problem using a formula that is more than 2000 years old.

Calculate Sum(N)
03:04

Our task is to implement a function that, given an array and a target value, returns zero-based indices of any two distinct elements whose sum is equal to the target sum.

Pair Matching Challenge
04:17

In this lecture, we are going to build a function to find the equilibrium indices of an array. The equilibrium index of an array is an index such that the sum of elements at lower indices is equal to the sum of elements at higher indices.

Find the Equilibrium Index
03:51

In this section, we’ve seen some practical examples of solving problems using two different approaches. Let's recap the biggest take-aways.

Summary
01:49

The Power of Algorithms - Xcode playground projects.

The Power of Algorithms Playgrounds (Swift Source Code)
+
Basic Sorting
7 Lectures 23:46

In this section we are going to talk about basic sorting algorithms.
Understanding the inner workings and knowing how to implement the basic sorting algorithms gives you a strong foundation to building other, more sophisticated algorithms.

Preview 02:17

We'll start the study of basic sorting algorithms with the selection sort algorithm. We are going to implement it in Swift. We’ll also visualize how selection sort works and we’ll analyze the time complexity of this algorithm.
Finally,we are going back up the theory with performance tests.


Selection Sort
05:33

Let's quickly recap the pros and cons of the selection sort algorithm.

Selection Sort Summary
00:49

Insertion sort is a basic sorting algorithm, which works by analyzing each element and inserting it into its proper place, while larger elements move one position to the right. 

Insertion sort has quadratic time complexity. However, the performance of the insertion sort is largely affected by the initial order of the elements in the sequence.

Insertion Sort
07:58

In the previous lecture, we took a closer look at the insertion sort algorithm. Did you know that even Apple uses it in their sort() implementation? Check out why!

Insertion Sort - Summary
01:03

The topic of this lecture is Bubble Sort. This algorithm works by repeatedly evaluating adjacent items and swapping their position if they are in the wrong order. While it's easy to grasp and implement, you don't want to use it in production code. Let's see why!

Bubble Sort
05:05

A brief summary of the bubble sort algorithm.

Bubble Sort - Summary
01:01

Test your knowledge on basic sorting algorithms.

Basic Sorting Quizzes
4 questions

Xcode playground projects for the Basic Sorting section.

Basic Sorting Playgrounds (Swift Source)
+
Advanced Sorting
5 Lectures 09:59

A brief overview of what to expect in this section.

Preview 00:53

The merge sort is a fast divide-an-conquer algorithm. Check out this lecture to see what that means.

Merge Sort
03:46

Merge sort in a nutshell.

Merge Sort - Summary
00:55

In this lecture, we'll analyze the famous quicksort - the king of the compare-based sorting algorithms.

Quicksort
03:28

Let's recap what we've learned about the popular - and fast - quicksort algorithm.

Quicksort - Summary
00:57

Quizzes for the Advanced Sorting Algorithms section.

Advanced Sorting Quizzes
3 questions

Xcode playground projects for the Advanced Sorting section.

Advanced Sorting Playgrounds (Swift Source)
+
Where Do You Go From Here?
1 Lecture 02:32

Let me give you some useful online resources which will help you in sharpening your coding and problem solving skills.

Final Thoughts & Useful Resources
02:32
About the Instructor
Karoly Nyisztor
4.5 Average rating
46 Reviews
535 Students
2 Courses
Senior Software Engineer, iOS / Swift Instructor

I am a veteran mobile developer having built several successful iOS apps and games, most of which were featured by Apple.

I am the founder at LEAKKA, a software development and tech consulting company. I have worked with companies such as Apple, Siemens, SAP, Zen Studios, and many more.

I spend most of my days now as a professional software engineer and IT architect. As an instructor, my aim is to share my 20+ years of software development expertise, and change the lives of students throughout the world.

My passion is helping people reveal hidden talents and guide them into the world of startups and programming. I currently am teaching object-oriented software design, iOS, Swift, Objective-C and UML.