Understanding Algorithms in Computer Science

 An algorithm is a specific procedure for solving a well-defined computational problem. The development and analysis of algorithms is fundamental to all aspects of computer science: artificial intelligence, databases, graphics, networking, operating systems, security, and so on. Algorithm development is more than just programming. It requires an understanding of the alternatives available for solving a computational problem, including the hardware, networking, programming language, and performance constraints that accompany any particular solution. It also requires understanding what it means for an algorithm to be “correct” in the sense that it fully and efficiently solves the problem at hand.

Algorithms: their meaning in computer science

In Computer Science, an algorithm is a list set of instructions, used to solve problems or perform tasks, based on the understanding of available alternatives. Algorithms are more than just programming, they are specifications for performing calculations, data processing, automated reasoning or decision making for example (non-exhaustive list). To this extent, it is necessary to understand what it means for an algorithm to be correct, and to accurately solve the problem at hand.

Here are 8 critical steps in the development of an efficient algorithm :

• Definition of the problem 
• Development of a model  
• Specification of the algorithm  
• Designing an algorithm  
• Implementation of the algorithm  
• Program testing

Why is it fundamental in Computer Science? 

Well, the answer is simple. Computers would not do anything without programs telling them what to do. Algorithms give computers step-by-step instructions to accomplish specific tasks and make decisions. 

In programming, there are many ways to solve a problem. However, the effectiveness of the available methods varies. Some methods are much better than others at giving accurate answers. 

Algorithms are used to find the best possible way to solve a problem, based on data storage, sorting and processing, and machine learning. In doing so, they improve the efficiency of a program.

Algorithms are used in all areas of computing. Because it is a fantastic way of automating computer decisions. Let's say you have to drive 200 km to your vacation spot. After checking what the shortest route is (data sorting), how to avoid traffic based on previous or current data (data storage), or how the weather forecast may impact your driving (data analysis), the algorithm will give you the best route and your estimated arrival time (data structure and algorithms are good friends in computer science, machine learning, decision making). 

Expressing algorithms 

How many algorithms are there in computer science?  That's a tricky question but of course we have an answer: there's a countless number of algorithms, even though some are indeed more important to know than others in programming. 

Most importantly, algorithms can be expressed in different languages, including natural languages, pseudocodes, flowcharts, drakon-charts, programming languages etc. 

In a world where data is queen, structure is king. 

In computer science, an algorithm is associated with information processing. Data can be read from an input source, written to an output device, and stored for further processing. The stored data is considered part of the internal state of the entity executing the algorithm. In practice, the state is stored in one or more data structures.

A data structure is a format for organizing, managing and storing data that allows access and modification. In other words, it is a collection of data values, relationships between them, functions or operations that can be applied to the data.

Computational complexity 

The (computational) complexity of an algorithm is a measure of the amount of computing resources (time and space) that a particular algorithm consumes when it runs. Computer scientists use mathematical measures of complexity that allow them to predict, before writing the code, how fast an algorithm will run and how much memory it will require. Such predictions are important guides for programmers implementing and selecting algorithms for real-world applications.

Computational complexity is a continuum, in that some algorithms require linear time (that is, the time required increases directly with the number of items or nodes in the list, graph, or network being processed), whereas others require quadratic or even exponential time to complete (that is, the time required increases with the number of items squared or with the exponential of that number). At the far end of this continuum lie the murky seas of intractable problems—those whose solutions cannot be efficiently implemented. For these problems, computer scientists seek to find heuristic algorithms that can almost solve the problem and run in a reasonable amount of time.

Further away still are those algorithmic problems that can be stated but are not solvable; that is, one can prove that no program can be written to solve the problem. A classic example of an unsolvable algorithmic problem is the halting problem, which states that no program can be written that can predict whether or not any other program halts after a finite number of steps. The insolvability of the halting problem has immediate practical bearing on software development. For instance, it would be frivolous to try to develop a software tool that predicts whether another program being developed has an infinite loop in it (although having such a tool would be immensely beneficial).

Hence not only computer science but even in other fields of science and engineering Algorithms poses a very important role.

credits:@International Institute in Geneva