Data Structure: A system for managing, organizing, and storing data that makes it easy to obtain and edit. A data structure is a grouping of data values, the connections between them, and the functions or actions that can be performed on the data. 

Algorithm: An algorithm is a series of steps designed to carry out a computation or answer a group of problems. Algorithms are precise guidelines for carrying out computations and data processing. (e.g., taking a series of books from a stack of books until we find the book we are looking for).

An algorithm is a method of processing information to accomplish a task, whereas a data structure organizes information. Head to Learnbay’s DSA course if you want to start learning DSA from the scratch. 

Object Oriented Programming (OOP)

A programming paradigm known as object-oriented programming (OOP) is founded on objects, which are data structures that contain code in the form of procedures and data in the form of fields (or attributes). (or methods). The ability of an object's procedures to grant access to and change its fields is one of its distinguishing characteristics.

Computer programs are created in object-oriented programming by constructing them from things that communicate with one another. Although there is a wide range of object-oriented programming languages, most are class-based, meaning that objects are instances of classes, which usually also define their type.

In procedural computing, object orientation is a development. Programming paradigms like procedural programming, which are founded on the idea of the procedure call, and structured programming, are different. The computation stages that must be performed are specified by procedures, also called routines, subroutines, or methods.

Any particular procedure could be called by another procedure or the calling procedure itself at any time while a program is being executed. The term "procedural programming" refers to a list or collection of instructions that inform a computer what to do sequentially and how to carry out from one code to the next. These include C, Fortran, Pascal, and BASIC for procedural computing.

A programming task is broken down into a set of variables, data structures, and subroutines in procedural programming, whereas in object-oriented programming, the goal is to create objects that reveal behavior (methods) and data (fields) through interfaces. The most significant difference between procedural programming and object-oriented programming is that the former uses procedures to operate on data structures, while the latter combines the two so that an object, which is an instance of a class, works on its "own" data structure.

Analysis of Algorithms

Algorithms play a big role in a lot of computer science jobs. The next step is to set up an objective standard by which to compare algorithms to determine which is superior to which for a given job. Utilizing primitive procedures requires time, so when creating an algorithm, we should try to reduce how often we use them. 

How the quantity of primitive operations relates to the size of our input is the crucial query we should ask to create effective algorithms.

Big O notation: is used to describe how a function behaves when it is limited. (worst case scenario). The number of operations required to solve the issue can be plotted against the number of input elements if our algorithm is run numerous times with different input sizes. When the input size increases, the resulting curve will show our algorithm's pattern. Minimizing the area under the parabola is our goal in this instance. (Figure 1). To measure the effectiveness of the various methods, use the Big O Notation. The algorithm's behavior for very large input values is usually considered when discussing the Big O Notation. (because of that, we generally ignore constants).

Dynamic Arrays

A basic data structure is a dynamic array. The main benefit of dynamic arrays is that they enable effective (quick) insertion, access, and removal actions. This is a remarkable trait because computers operate by using fixed-length arrays. An insertion or removal action in a programming language like Python or Java can take as long as O(N) (worst case, otherwise typically O(1)).

Recursion

Recursion starts with a large issue and then breaks it down into ever-smaller parts until we reach a base case. (e.g., factorial computation).

As a result, a recursive function keeps returning to itself until it reaches a base instance. (this generates a recursive trace, in which information is stored at each call about the computed result waiting to be used once the base condition is reached). Each function call is recorded on the stack trail, which is a drawback of using recursion. 

5 steps to solve any recursive problem

• What input can you possibly make simpler? 
• Play around by coming up with various instances and attempting to picture them.
• Link challenging instances to straightforward ones.
• Any underlying trend we were able to find should be generalized.
• Recursive patterns and the basic case should be combined when writing code.

Dynamic Programming

Dynamic programming is one of the most potent algorithmic programming methods in computer science. Dynamic programming's central concept is that problems are best solved by finding and resolving their related subproblems. The main issue can be resolved when all the smaller issues are addressed. Five essential stages can typically be carried out to attempt to solve dynamic programming problems:

• Provide instances to help you visualize the issue (for instance, what data structure can be used to resolve it?
• Select the relevant sub-issue
• Identify connections between the various issues
• Generalize the relationship
• Apply by addressing subproblems in sequence.

If you want to keep updated with the latest trends or upgrade your skills, refer to the data structures and algorithms course, available online.