Algorithms and Software Engineering for Professionals

Algorithms and Software Engineering for Professionals, available at $19.99, has an average rating of 3.75, with 104 lectures, based on 66 reviews, and has 1136 subscribers.

You will learn about Master the core software engineering algorithms Understand the concepts Iterations, time complexity and optimization Understand key data structures such as stack and queues Learn the Art of Algorithm design Master tree and graph Algorithms Ace in technical interviews with proper grasp of concepts This course is ideal for individuals who are Students who want to master core concepts and algorithms for better software development will find this course very effective It is particularly useful for Students who want to master core concepts and algorithms for better software development will find this course very effective.

Enroll now: Algorithms and Software Engineering for Professionals

Summary

Title: Algorithms and Software Engineering for Professionals

Price: $19.99

Average Rating: 3.75

Number of Lectures: 104

Number of Published Lectures: 104

Number of Curriculum Items: 104

Number of Published Curriculum Objects: 104

Original Price: $29.99

Quality Status: approved

Status: Live

What You Will Learn

Master the core software engineering algorithms
Understand the concepts Iterations, time complexity and optimization
Understand key data structures such as stack and queues
Learn the Art of Algorithm design
Master tree and graph Algorithms
Ace in technical interviews with proper grasp of concepts

Who Should Attend

Students who want to master core concepts and algorithms for better software development will find this course very effective

Target Audiences

Students who want to master core concepts and algorithms for better software development will find this course very effective

In order to build something, you must start from the ground up. It is always important to understand the basics and the core of a concept and this ideology also holds true for software programming. Data structures and algorithms are the basic building blocks for Software Engineering, that determine how the system will operate.

Data structures and algorithms are two common concepts that can be found in Software Engineering and are imperative to mastering any programming language or technology within the software technology landscape. In order to master any programming language, functional or objective, one must first understand the basic concept behind it, which includes algorithms.

Data in software engineering are represented in data structures such as maps, lists, trees, etc. and is in the constant need of being sorted and merged, transformed and matched in some way. For this reason, software engineers devised algorithms as a solution for this task, which is consistent, repeatable and testable with a set of metrics to quantify performance.

However, for data structures to work seamlessly with your system, you need to understand the basics to creating clean, efficient and powerful algorithms that reduces the amount of work required by the engineer. This is where this course can help.

Our comprehensive course has been designed to help you understand algorithms and data structures from scratch. This course covers important concepts related to data structures and algorithms including the five major categories of algorithms: Cryptography, Compiler Theory, Signal Processing, Data Analysis, and Graph Databases. This is a course for the Big Boys.�

It also includes understanding other primary concepts such as recursion and its relationship to concurrency and ADT’s like Trees and Graphs; relationship between trees and rotation operations used in balancing, operations with Primes, Fermat’s theorem, parsing grammars with Stacks and Queues and related tools like AST based parsers the beginning step on the road to Compiler theory.

In addition to covering the theoretical concepts, the course also is packed with examples of practical applications. It is important to not only understand what the concept it, but also how to use it. You will definitely get the best of both worlds in this algorithm and data structure tutorial.�

This course will also help you ace the theoretical intensive tech interviews. So if you plan to apply for a tech job, this course will act as a great refresher.�

With this course, you will not only be able to understand algorithms, but actually write better algorithms to help simplify your programming life. With this much power waiting for you, what are you waiting for? Let’s get started.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Chapter 2: Iterations and Transformations on Sequence’s

Lecture 1: Iterations

Lecture 2: Iterations Lab 1 Count Condition Loops with Java 8 Streams

Lecture 3: Iterations with Java Collections .

Lecture 4: Iterations Lab 2 LinkedList Unsafe iteration on Queues

Lecture 5: Iterations with Java Maps and Streams

Lecture 6: Iterations Lab 3 Matching Pattern Sequences with iterations Part A

Lecture 7: Iterations Lab 3 Matching Pattern Sequences with iterations Part B

Chapter 3: Time Complexity

Lecture 1: Time Complexity

Lecture 2: Big O specific calculation

Lecture 3: Time Complexity Lab 1 Practical Obtain Sequence Introduction

Lecture 4: Time Complexity Lab 1 Practical Task Obtain Sequence Solutions

Lecture 5: Array Operations 1 Equilibrium Index

Lecture 6: Array Operations 2 Optimal Index

Lecture 7: Sorting Arrays

Lecture 8: Time Complexity Lab 2 Array task with Expected Worst case time complexity O(n)

Lecture 9: Space complexity

Lecture 10: Sorting Algorithms Time and Space complexity

Lecture 11: Common Sorting Algorithms best and worst case

Lecture 12: Time Complexity Lab 3 Sorting Algorithm efficiency

Chapter 4: Counting and Optimisation

Lecture 1: Counting Concepts

Lecture 2: Sliding window maxima and minima

Lecture 3: Counting and Optimisation Lab 1 Application of a Sliding window

Lecture 4: Counting and Optimisation Lab 1 Application of a Sliding window Part B

Lecture 5: Counting Patterns

Lecture 6: Count Combinations

Lecture 7: Count Permutations

Lecture 8: "Counting and Optimisation Lab 2 Application of Counting to Permutations "

Lecture 9: Counting Theorem for Algorithms

Lecture 10: Counting Sort

Lecture 11: Pigeonhole Sort

Lecture 12: Counting and Optimisation Lab 3 Application of the Counting Theorem

Chapter 5: Sorting

Lecture 1: Sorting Concepts

Lecture 2: Implement Insertion Sort with comparator

Lecture 3: Sorting Lab 1 Introduction

Lecture 4: Sorting Lab 1 Compute the number of distinct values in array of N integers.

Lecture 5: Breaking the Quadratic time barrier

Lecture 6: Implement Heap Sort

Lecture 7: Recursive Sorting Algorithms

Lecture 8: Implement MergeSort

Lecture 9: Sorting Lab 2 Practical Optimise subsequences

Lecture 10: Implement Radix sort Part A

Lecture 11: Implement Radix sort Part B

Lecture 12: Sorting Lab 3 Practical Radix Sort on String Arrays

Chapter 6: Stacks and Queues

Lecture 1: Stack Concepts

Lecture 2: Implement a basic Stack with a Linked List

Lecture 3: Perform simple stack algorithm with Reverse Polish notation

Lecture 4: Stacks and Queues Lab 1 Application of a Stack

Lecture 5: Queue Concepts

Lecture 6: Implement a basic Queue with a Linked List

Lecture 7: Practical Application of a Queue

Lecture 8: Stacks and Queues Lab 2 Practical Application of a Queue

Lecture 9: Parsing Concepts

Lecture 10: Implement a simple AST parser

Lecture 11: Stacks and Queues Lab 3 Test for Well Formed Expressions

Chapter 7: Divisibility Operations and Primes

Lecture 1: Slice Operations

Lecture 2: Implement Kadane's algorithm

Lecture 3: Implement a double-slice operation

Lecture 4: Slice Operations Lab 1 Application of a slice operation Part A

Lecture 5: Slice Operations Lab 1 Application of a slice operation Part B

Lecture 6: Divisibility Operations

Lecture 7: Implement Euclidean algorithm (common factors)

Lecture 8: Implement a test for a prime number

Lecture 9: Slice Operations Lab 2 Simple Peak detection

Lecture 10: Slice Operations Lab 2 Simple Peak detection Part B

Lecture 11: Divisibility Operations and Primes

Lecture 12: Sieving (finding prime numbers)

Lecture 13: Slice Operations Lab 3 Probabilistic Tests for Large Primes Part A

Lecture 14: Slice Operations Lab 3 Probabilistic Tests for Large Primes Part B

Chapter 8: Tree Based Algorithms

Lecture 1: Search Algorithms

Lecture 2: Implement a Binary search

Lecture 3: Implement a Hash table

Lecture 4: Tree Based Algorithms Lab 1 Binary search algorithm optimisation

Lecture 5: Binary Trees

Lecture 6: Implement a Binary Search Tree

Lecture 7: Binary Tree recursion

Lecture 8: Tree Based Algorithm Lab 2 Extend the Binary Tree API

Lecture 9: Avl Trees

Lecture 10: Implement a Avl Tree

Lecture 11: Sub Trees and Paths

Lecture 12: Tree Based Algorithm Lab 3 Tree Traversal (Paths)

Chapter 9: Graph Algorithms

Lecture 1: Graphs Concepts

Lecture 2: Implement a Graph as a Abstract Data Type (ADT)

Lecture 3: Implement a Depth-first search

Lecture 4: Graph Algorithms Lab 1 Path Search with dfs

Lecture 5: Graphs Search

Lecture 6: Implement a Directed Graph as a Abstract Data Type (ADT)

Lecture 7: Implement a Breadth-first search

Lecture 8: Graph Algorithms Lab 2 Breadth First Search

Lecture 9: Topological Sort

Lecture 10: Implement a Topological sort

Instructors

Eduonix Learning Solutions
1+ Million Students Worldwide | 200+ Courses

Rating Distribution

1 stars: 8 votes
2 stars: 6 votes
3 stars: 7 votes
4 stars: 17 votes
5 stars: 28 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu