The end result should be obtained after performing a certain non-infinite number of steps.
The algorithm presented in the form of a block diagram has the greatest visibility. Elementary actions are divided into classes. Each class has its own graphic image on the scheme block. Inside the image indicates a specific action.
The basic designations are given in Appendix 1. There are other, reflecting the specifics of elementary actions what is dissertation abstract.
Individual blocks are connected by lines, determining the order of calling elementary operations. From block to block, you can go only by communication line. One and the same communication line can be moved only in one direction, which in the case of ambiguity is specified by an arrow. It is allowed to merge several consecutively standing blocks of one class into one.
There are standard block connection structures. These are sequential structures (Fig.2.1), when blocks are simply called one after another. Branching structures are structures with the possibility of several continuation options (Fig. 2.2). Cyclic structures, when the same actions are repeated several times with slight changes.
The algorithm must have one start operator and one end operator. Having gone through any transition, in the end, we must come to the “end” block. Each transition must be uniquely defined. Attention should be paid so that with all the permissible changes to the variables one could finally get out of the loop (to avoid looping the program). Any variable must be assigned a value before use (it must be defined).
Sometimes the flowchart complements the verbal description required for a clearer picture of the actions performed by the individual unit and group ofunits. Verbal description is easier to make if the blocks are numbered.
Based on the compiled algorithm, a program is written in a specific programming language.
For complex tasks, it is not immediately possible to determine the set and sequence of necessary elementary actions. In this case, the main task is divided into a number of smaller subtasks. In turn, any subtask (software module) can be broken down into even smaller ones. This fragmentation can continue until the implementation algorithm is simplified, once again simplified the task. This method is called decomposition..