Understanding Algorithm Writing and Analysis
This guide explains how to write algorithms with flexible syntax and how to analyze their efficiency, focusing on time and space criteria. Algorithms are problem-solving procedures that can be expressed in various styles, as long as they are understandable by the project team.
Algorithm Writing: Syntax Flexibility
Unlike programs, algorithms do not require strict syntax or data type declarations. Key points include:
- No fixed syntax: You can use styles like
begin...end, flower brackets{}, or arrows←for assignment. - No explicit declarations: Temporary variables are understood without declaration.
- Language-agnostic: Focus on logic, not language-specific rules (e.g., C data types).
- Clarity over formality: The goal is human readability, any syntax that team members understand is acceptable.
Example comparison:
- In a C program, you must declare data types and temporary variables.
- In an algorithm, you can directly use variables like
swap(a, b)without declaring them. For more context on these foundational concepts, see the Introduction to Data Structures and Algorithms.
Criteria for Algorithm Analysis
Algorithms are analyzed based on their efficiency. The two primary criteria are:
- Time Efficiency: How fast the procedure produces results. The time taken is expressed as a function (not wall clock time).
- Space Efficiency: How much memory the algorithm consumes when converted to a program.
Additional criteria may include:
- Data transfer: Network consumption for internet-based or cloud-based applications.
- Power consumption: Important for handheld devices like tablets or laptops.
- CPU register usage: Relevant for device drivers or system-level programming. The choice of criteria depends on project requirements. For a deeper dive into the complete analysis framework, refer to the Understanding Time and Space Complexity: A Comprehensive Guide to Big O Notation.
Time Analysis Example
Each simple statement in an algorithm is assumed to take one unit of time. For a basic algorithm like swapping two numbers:
- Three simple statements (e.g., assign, assign, assign) give a time function f(n) = 3, a constant value.
- This constant is represented as order of 1 (O(1)), meaning time does not depend on input size
n.
Note: For detailed analysis, you can examine machine-level instructions, but basic analysis treats each statement as one unit. The same principles for constant-time operations are elaborated in the Comprehensive Guide to Core Data Structures and Algorithms.
Space Analysis Example
The space consumed is calculated by counting variables used (each variable takes one word, regardless of data type). For the swap algorithm:
- Two parameters and one local variable = 3 words.
- This is also constant space, represented as O(1).
Summary of Complexity
| Aspect | Example Value | Order Notation | |--------|---------------|----------------| | Time | 3 units | O(1) | | Space | 3 words | O(1) |
Constant order (O(1)) indicates that both time and space remain fixed, regardless of input size. This shallow level of analysis is sufficient for basic understanding, but deeper analysis can be tailored to specific requirements. For more complex examples of how these metrics scale, explore the Comprehensive Guide to Data Structures: Arrays to Graphs Explained.
Key Takeaways
- Algorithms prioritize logic and clarity over strict syntax.
- Time and space are the main efficiency metrics, analyzed as functions.
- Basic analysis assumes one unit per statement and one word per variable, yielding constant order for simple procedures. Advanced analysis of different asymptotic notations is covered in the Comprehensive Overview of Algorithms and Data Structures Course.
next let us see how to write a new program here already have redundant has gotten for strapping two numbers or two
elements see how you see language with syntax only only the thing I've done is here I wrote algorithm we show that okay
I'm writing an algorithm it's not a program yeah if we compare the two C program here I have not written the data
type of parameters yes data types we don't decide at all work on time when we write a program then we decide what data
types are required and here even I don't have our temporary variable declaration declaration is not there directly it is
use is understood unless you declare in the program you cannot use it but algorithm we don't bother about those
minor things that are related to language this is more let's see now if you want to write in different way you
can say this has begin and Desai's and stuff flower brackets we can also say bigger than n next you can use this
symbol also for assignment actually this is the assignment symbol that was used in some more languages like Pascal
language so you can use that one or else you can use the symbol for showing that this value is stored at this one so now
it's up to you how you want to write it I hope whatever I don't you have in the student so same way whatever you write I
should be able to understand at least you should be able to understand are the people who are involved in the project
be able to understand it who are using it should be able to understand right so you can use any syntax there is no fixed
syntax or anything any algorithm to see how do analyze an El Corte what is the criteria on which we analyze an
algorithm so the criterion is the first criteria is an see the algorithms are the procedures for solving problem
whether you do it manually using pen and paper or you make a program and let your machine do it whatever the method may be
how much time it is taking if the procedure is very lengthy and time-consuming other whether the
procedure is very fast and quickly you can get the results so that is one of the important criteria on which we have
to analyze if you are devising a procedure or algorithm then it should be time efficient means it must be faster
so after reading the algorithms we analyze how much time it is taking so that time what we get is in the time in
the form of a function we get a function tying function we not get the boss time already have shown you you will get the
function and function now this is space as the water is going to be comforting to a program and it's going to run on
the machine then we need to move how much memory space it will consume so that is the second criterion which we
will analyze an algorithm so these are the two major criteria on mr. algorithms are analyzed and furthermore if you have
any other criteria criteria and furthermore if you have any other criteria are any other factors you want
to consider you can consider them like no nobody is every application is either internet-based from the based or say
cloud base so data transferred or network consumption is also important criteria how much data is going to be
transferred see if the algorithm or means if a procedure that you are writing if it's unnecessary transferring
to larger size data or it can be reduced or compressed whatever it is so that is one more
important criteria that is hawa data transfer is done and nowadays most of the devices are handheld its top pcs we
are using palm tops and laptops and tablets then power consumption is also a criteria how much power it is consuming
a new criteria is if you are developing an algorithm for device driver or system they were programming if you
are developing something some algorithm if you are writing then you may also need to know how much CP will disturb it
is consuming so CPU will also have some memory called as registers how many resistors it is consuming
that's also one of the worrying factor when you are designing an algorithm or writing a program family so these are
few criterias i have listed and it depends on your requirement it depends on your project right what are the more
criterias you need to analyze now let us see I have taken one example to show you how we analyze an elgato so for an
answer purpose we need to know the time so first we do time analysis then we do space and position the time means how
much time is your date this is not the worst time that hog was you know you see that every statement in
the record of takes one unit of time every symbol statement in an algorithm takes one unit of time if suppose the
algorithm is calling another rhythm it's using another procedure then we have to analyze that also in detail so simple
means just statements direct statements it's not a nested statement right so single statement each statement takes
one unit of time so here I assume it takes one unit of time one bit of time so 2 times 3 so the time function f
often is 3 here we go to constant value because I have taken a very simple algorithm and the answer is 3 that is
some constant valid right 3 or 30 whatever it is response to any one fixed value got so there is a time function
but it's not in terms of n just we got a cross street map now here whatever the complexity in the statement may be how
lengthy the statement will be we say that it is for enough time let us assume Stroeve this is statement I have some
statement saying X assign Phi into a plus 6 into B if this is the statement at elemental water then for this also we
say it takes one unit of time but really if you see when you can put into a program and finally but it gets
converted into machine code then how many statements it will have for each multiplication two statements there for
addition one statement the assignment one statement so total four statements will be there but we don't want to go
into that much detail we don't want to see how it is going to get converted into machine code but simply we analyze
and say each statement takes one unit of time now suppose if you want to go into detail analysis like this you can go
into detail you can imagine up to the level of the machine code that's going to be generated it is just like suppose
you want to travel to your friend's house in a car you don't have to think and you don't have to plan and analyze
simply you can take a car or your bike your vehicle and you can just start and reach this place right and so if you
want to land on Mars then simply cannot take a satellite so they'll simply account they not take a rocket and
launch it and reached it's not easy so you have to analyze and design and make a complete plan so that your mission is
successful so that's it here you need to go into each and every minor detail you have to take effect so it depends on
your requirement so if you want to analyze into greater detail do it so the point of view we will be doing it at
basic level but at a very shallow level this base analysis we will do will not go into much detail but much detail
analysis can to be done next just space analysis what are the variables used here for a space
and rent on the videos it is one parameter P is also parameter and 10 to the local variable used so total how
many variables one two and three so there are three variables use so the space is constant again it is just three
I got answer as 3 so again it is also constant so you should be representing mass order of one constant sort of one
and that's also order of 1 means it is constant one represents constant if it is three also we write 1 if it is 3000
also we write 1 seen that this constant value is constant so this all each statement is taken as 1 unit of time and
each variable is taken as one word so these are three words why we are saying words they're not bytes we don't know
planning it converted to a program it may be a teacher type or float type or double type that we don't know so that's
why we say it is taking words
The main difference is that algorithms prioritize logic and human readability over strict syntax. They do not require fixed syntax, data type declarations, or language-specific rules, unlike programs which must follow precise syntax rules of a programming language like C. The goal of an algorithm is clarity for the project team, not formal correctness for a compiler.
Time efficiency is analyzed by counting each simple statement as one unit of time. For a swap algorithm with three assignment statements (e.g., temp = a, a = b, b = temp), the time function is f(n) = 3. Since this is a constant value that does not depend on input size, it is represented as O(1) or constant order of time.
Space efficiency is analyzed by counting the number of variables used, with each variable occupying one word of memory regardless of its data type. For a swap algorithm, you have two parameters and one local variable, totaling 3 words. Since this memory usage is fixed and does not scale with input size, it is represented as O(1) or constant space.
No, time and space are the primary criteria, but additional criteria may be important depending on the project requirements. These include data transfer (network consumption), power consumption (for handheld devices), and CPU register usage (for system-level or driver software). The choice of criteria depends on the specific application context.
O(1), read as 'order of 1' or constant order, means that the time or space required by the algorithm does not change with the size of the input (n). For example, a swap algorithm always takes 3 time units and 3 words of space, regardless of the values being swapped. This is the most efficient asymptotic notation.
An algorithm can be written in any style that is clear and understandable to the project team. There is no fixed syntax requirement; you can use begin...end blocks, flower brackets {}, assignment arrows (←), or any other notation. The key is that the logic is accurately conveyed without ambiguity.
No, temporary variables in an algorithm are understood without explicit declaration. For example, in a swap algorithm, you can directly use a variable named 'temp' without declaring its type or existence. This contrasts with a program where all variables must be explicitly declared with a data type before use.
Keep this summary
Save it to LunaNotes and it becomes a real note in your library — editable, searchable, and ready to turn into flashcards or a diagram. Free to start.
Save to LunaNotesOr summarise for another video.
32K+ people have turned 65K+ videos into notes
“Very useful tool. I'm using it for the last couple weeks and I'm loving it so far. Makes learning on YouTube a great experience.”
Bhai Chrome Web Store reviewThis summary and transcript were automatically generated using AI with the Free YouTube transcript summary tool by LunaNotes.
Related summaries
Algorithm Complexity: Frequency Count Method for Time Space Analysis
Learn how to analyze algorithm efficiency using the frequency count method. This video demonstrates time and space complexity analysis for sum of array elements, matrix addition, and matrix multiplication algorithms.
Understanding Time and Space Complexity: A Comprehensive Guide to Big O Notation
Explore the concepts of time complexity, space complexity, and Big O notation with practical examples.
Time & Space Complexity Basics: Big O Notation Explained for DSA
This video introduces time complexity and space complexity concepts for coding interviews. The instructor explains why time taken is not time complexity, defines Big O notation, and covers the three key rules for computing complexity: worst-case scenario, avoiding constants, and ignoring lower-order terms. It also covers space complexity, auxiliary vs input space, and the crucial rule of not modifying input data.
Asymptotic Analysis Part 3: Growth Rates & Time Complexity
Learn why we use asymptotic complexity instead of exact running times in algorithm analysis. This tutorial explains how time complexity depends on input size and why higher-order terms dominate for large inputs, using clear examples with array shifts and growth rate calculations.
Basics of Asymptotic Analysis: Comparing Array vs Linked List Efficiency
This introductory presentation explains how to compare data structure efficiency using time complexity, focusing on operations like insertion. Using arrays and linked lists as examples, it demonstrates why linked lists are faster for adding elements at the beginning, highlighting the importance of asymptotic analysis for algorithm selection.
Most viewed summaries
A Comprehensive Guide to Using Stable Diffusion Forge UI
Explore the Stable Diffusion Forge UI, customizable settings, models, and more to enhance your image generation experience.
Kolonyalismo at Imperyalismo: Ang Kasaysayan ng Pagsakop sa Pilipinas
Tuklasin ang kasaysayan ng kolonyalismo at imperyalismo sa Pilipinas sa pamamagitan ni Ferdinand Magellan.
Mastering Inpainting with Stable Diffusion: Fix Mistakes and Enhance Your Images
Learn to fix mistakes and enhance images with Stable Diffusion's inpainting features effectively.
Pamamaraan at Patakarang Kolonyal ng mga Espanyol sa Pilipinas
Tuklasin ang mga pamamaraan at patakaran ng mga Espanyol sa Pilipinas, at ang epekto nito sa mga Pilipino.
How to Install and Configure Forge: A New Stable Diffusion Web UI
Learn to install and configure the new Forge web UI for Stable Diffusion, with tips on models and settings.
Found this summary useful?
Take it with you. One click puts it in your own LunaNotes library.
Save to LunaNotes