Art Data Structure Horowitz Pdf


Tuesday, October 15, 2019

Fundamentals of Data Structures - Ellis Horowitz, Sartaj - Ebook download as PDF File .pdf), Text File .txt) or read book online. data structure. It is not a diet book but Healthy Weight Loss – Without Dieting. Following the In this effective Healthiest Way of E Fundamentals of Data Structures – Ellis. Fundamentals: Table of Contents Fundamentals of Data Structures by Ellis Horowitz and Sartaj Sahni PREFACE CHAPTER 1.

Data Structure Horowitz Pdf

Language:English, Spanish, Arabic
Genre:Politics & Laws
Published (Last):28.06.2016
ePub File Size:18.58 MB
PDF File Size:12.46 MB
Distribution:Free* [*Regsitration Required]
Uploaded by: WILTON

PDF | On Jan 1, , Ellis Horowitz and others published Fundamentals of Data Structure in C++. DATA REPRESENTATIONS FOR STRINGS . PATTERN MATCHING IN STRINGS. Fundamentals of Data Structures in C Horowitz PDF Fundamentals Of Data Structures In C Author: Ellis Horowitz, Anderson-Freed, Sahni other link other link .

If possible the designer attempts to partition the solution into logical subtasks. Each subtask is similarly decomposed until all tasks are expressed within a programming language. This method of design is called the top-down approach.

Inversely, the designer might choose to solve different parts of the problem directly in his programming language and then combine these pieces into a complete program. This is referred to as the bottom-up approach.

Experience suggests that the top-down approach should be followed when creating a program. However, in practice it is not necessary to unswervingly follow the method. A look ahead to problems which may arise later is often useful. Underlying all of these strategies is the assumption that a language exists for adequately describing the processing of data at several abstract levels.

Let us examine two examples of top-down program development. Suppose we devise a program for sorting a set of n given by the following 1 distinct integers. One of the simplest solutions is "from those integers which remain unsorted, find the smallest and place it next in the sorted list" This statement is sufficient to construct a sorting program.

However, several issues are not fully specified such as where and how the integers are initially stored and where the result is to be placed.

One solution is to store the values in an array in such a way that the i-th integer is stored in the i-th array position, A i 1 i n. We are now ready to give a second refinement of the solution: for i 1 to n do examine A i to A n and suppose the smallest integer is at A j ; then interchange A i and A j.

There now remain two clearly defined subtasks: i to find the minimum integer and ii to interchange it with A i. Eventually A n is compared to the current minimum and we are done. Also, observe that when i becomes greater than q, A Hence, following the last execution of these lines, i.

We observe at this point that the upper limit of the for-loop in line 1 can be changed to n - 1 without damaging the correctness of the algorithm. From the standpoint of readability we can ask if this program is good. Is there a more concise way of describing this algorithm which will still be as easy to comprehend? Substituting while statements for the for loops doesn't significantly change anything.

Also, extra initialization and increment statements would be required. Let us develop another program. We assume that we have n 1 distinct integers which are already sorted and stored in the array A 1:n. By making use of the fact that the set is sorted we conceive of the following efficient method: "let A mid be the middle element.

There are three possibilities. Continue in this way by keeping two pointers, lower and upper, to indicate the range of elements not yet tested. This method is referred to as binary search. Note how at each stage the number of elements in the remaining set is decreased by about one half. For instance we could replace the while loop by a repeat-until statement with the same English condition. In fact there are at least six different binary search programs that can be produced which are all correct.

There are many more that we might produce which would be incorrect. Part of the freedom comes from the initialization step. Whichever version we choose, we must be sure we understand the relationships between the variables. Below is one complete version. This, combined with the above assertion implies that x is not present. Unfortunately a complete proof takes us beyond our scope but for those who wish to pursue program proving they should consult our references at the end of this chapter.

Recursion We have tried to emphasize the need to structure a program to make it easier to achieve the goals of readability and correctness.

Actually one of the most useful syntactical features for accomplishing this is the procedure. Given a set of instructions which perform a logical operation, perhaps a very complex and long operation, they can be grouped together as a procedure. Given the input-output specifications of a procedure, we don't even have to know how the task is accomplished, only that it is available. This view of the procedure implies that it is invoked, executed and returns control to the appropriate place in the calling procedure.

What this fails to stress is the fact that procedures may call themselves direct recursion before they are done or they may call other procedures which again invoke the calling procedure indirect recursion. These recursive mechanisms are extremely powerful, but even more importantly, many times they can express an otherwise complex process very clearly. For these reasons we introduce recursion here. Most students of computer science view recursion as a somewhat mystical technique which only is useful for some very special class of problems such as computing factorials or Ackermann's function.

This is unfortunate because any program that can be written using assignment, the if-then-else statement and the while statement can also be written using assignment, if-then-else and recursion. Of course, this does not say that the resulting program will necessarily be easier to understand. However, there are many instances when this will be the case. When is recursion an appropriate mechanism for algorithm exposition?

One instance is when the problem itself is recursively defined. Given a set of n 1 elements the problem is to print all possible permutations of this set. It is easy to see that given n elements there are n! A simple algorithm can be achieved by looking at the case of four elements a,b,c,d. The answer is obtained by printing i a followed by all permutations of b,c,d ii b followed by all permutations of a,c,d iii c followed by all permutations of b,a,d iv d followed by all permutations of b,c,a The expression "followed by all permutations" is the clue to recursion.

It implies that we can solve the problem for a set with n elements if we had an algorithm which worked on n - 1 elements. A is a character string e. Then try to do one or more of the exercises at the end of this chapter which ask for recursive procedures. We will see several important examples of such structures, especially lists in section 4. Another instance when recursion is invaluable is when we want to describe a backtracking procedure. But for now we will content ourselves with examining some simple, iterative programs and show how to eliminate the iteration statements and replace them by recursion.

This may sound strange, but the objective is not to show that the result is simpler to understand nor more efficient to execute. The main purpose is to make one more familiar with the execution of a recursive procedure. Suppose we start with the sorting algorithm presented in this section.

To rewrite it recursively the first thing we do is to remove the for loops and express the algorithm using assignment, if-then-else and the go-to statement. Every place where a ''go to label'' appears, we replace that statement by a call of the procedure associated with that label.

This gives us the following set of three procedures. Procedure MAXL2 is also directly reculsive. These two procedures use eleven lines while the original iterative version was expressed in nine lines; not much of a difference. Notice how in MAXL2 the fourth parameter k is being changed. The effect of increasing k by one and restarting the procedure has essentially the same effect as the for loop.

Now let us trace the action of these procedures as they sort a set of five integers When a procedure is invoked an implicit branch to its beginning is made. The parameter mechanism of the procedure is a form of assignment. In section 4. Also in that section are several recursive procedures, followed in some cases by their iterative equivalents.

Rules are also given there for eliminating recursion. There are many criteria upon which we can judge a program, for instance: i Does it do what we want it to do?

The above criteria are all vitally important when it comes to writing software, most especially for large systems. Though we will not be discussing how to reach these goals, we will try to achieve them throughout this book with the programs we write. Hopefully this more subtle approach will gradually infect your own program writing habits so that you will automatically strive to achieve these goals.

There are other criteria for judging programs which have a more direct relationship to performance. These have to do with computing time and storage requirements of the algorithms. Pinson, Lewis J. Implementation of Event Handling in Java. Paul Horowitz 1 Oct The Requirements of the FCM.

Paul Horowitz. Morris, D. Lecture Notes: Paul Horowitz ultimatum. Data Structures B. Forouzan and F. Mosharraf, Foundations of Computer Science, 2nd ed.

Introduction to Computer Science, Fall, Data Structures Aug 31, In this second lecture we introduce some simple data structures such as lists, and Note that all of these notations will be pa. Data Structures The course gives a general introduction to data structures and the algorithms that operate on Supplementary Texts. Michael T. Goodrich and Roberto Tamassia, Data Structures and. Algorithms in JAVA Data Structures Reg. Question Paper Code: Hybrid and Custom Data Structures: Without some form of abstraction, one Sartaj 1.

With more than 15 years of experience in the data center industry, Gustavo Mill, underwent seven editions The eighth and ninth edition are reprints of the seventh edition.

Acrylic on paper Vintage CIA sweatshirt with patches variable. Communication of Complex Data Structures Abstract. Communicating complex data structures, that is Converting dialects is a complicated process, but For many years a data structures course has been taught in computer science Newell, C. Shaw, and H. Simon , LISP 1. Table of Contents www. Often it is regarded as a central course of the curriculum.

It is fascinating and instructive to trace the history of how the subject matter for this course has changed. Back in the middle's the course was not entitled Data Structures but perhaps List Processing Languages. Farber, R. Griswold, and I. Knuth appeared. His thesis was that list processing was not a magical thing that could only be accomplished within a specially designed system. Instead, he argued that the same techniques could be carried out in almost any language and he shifted the emphasis to efficient algorithm design.

The new strategy was to explicitly construct a representation such as linked lists within a set of consecutive storage locations and to describe the algorithms by using English plus assembly language. Progress in the study of data structures and algorithm design has continued.

Out of this recent work has come many good ideas which we believe should be presented to students of computer science. It is our purpose in writing this book to emphasize those trends which we see as especially valuable and long lasting. The most important of these new concepts is the need to distinguish between the specification of a data structure and its realization within an available programming language. This distinction has been mostly blurred in previous books where the primary emphasis has either been on a programming language or on representational techniques.

Our attempt here has been to separate out the specification of the data structure from its realization and to show how both of these processes can be successfully accomplished. The specification stage requires one to concentrate on describing the functioning of the data structure without concern for its implementation.

This can be done using English and mathematical notation, but here we introduce a programming notation called axioms. The resulting implementation independent specifications valuable in two ways: To describe a data structure in a representation independent way one needs a syntax.

This can be seen at the end of section 1. This book also seeks to teach the art of analyzing algorithms but not at the cost of undue mathematical sophistication. The value of an implementation ultimately relies on its resource utilization: This implies that the student needs to be capable of analyzing these factors.

A great many analyses have appeared in the literature, yet from our perspective most students don't attempt to rigorously analyze their programs. The data structures course comes at an opportune time in their training to advance and promote these ideas.

For every algorithm that is given here we supply a simple, yet rigorous worst case analysis of its behavior. In some cases the average computing time is also file: The growth of data base systems has put a new requirement on data structures courses, namely to cover the organization of large files. Also, many instructors like to treat sorting and searching because of the richness of its examples of data structures and its practical application.

The choice of our later chapters reflects this growing interest. One especially important consideration is the choice of an algorithm description language.

Such a choice is often complicated by the practical matters of student background and language availability.

Our decision was to use a syntax which is particularly close to ALGOL, but not to restrict ourselves to a specific language. This gives us the ability to write very readable programs but at the same time we are not tied to the idiosyncracies of a fixed language.

Wherever it seemed advisable we interspersed English descriptions so as not to obscure the main pointof an algorithm. For those who have only FORTRAN available, the algorithms are directly translatable by the rules given in the appendix and a translator can be obtained see appendix A. On the other hand, we have resisted the temptation to use language features which automatically provide sophisticated data structuring facilities. We have done so on several grounds.

One reason is the need to commit oneself to a syntax which makes the book especially hard to read by those as yet uninitiated. Even more importantly, these automatic featules cover up the implementation detail whose mastery remains a cornerstone of the course. The basic audience for this book is either the computer science major with at least one year of courses or a beginning graduate student with prior training in a field other than computer science.

This book contains more than one semester's worth of material and several of its chapters may be skipped without harm. The following are two scenarios which may help in deciding what chapters should be covered. He would cover chapters one through five skipping sections 2. Then, in whatever time was left chapter seven on sorting was covered. In the first quarter's data structure course, chapters one through three are lightly covered and chapters four through six are completely covered.

The second quarter starts with chapter seven which provides an excellent survey of the techniques which were covered in the previous quarter. Then the material on external sorting, symbol tables and files is sufficient for the remaining time. Note that the material in chapter 2 is largely mathematical and can be skipped without harm.

The paradigm of class presentation that we have used is to begin each new topic with a problem, usually chosen from the computer science arena.

Once defined, a high level design of its solution is made and each data structure is axiomatically specified. A tentative analysis is done to determine which operations are critical. Implementations of the data structures are then given followed by an attempt at verifying file: The finishedalgorithm in the book is examined followed by an argument concerning its correctness.

Then an analysis is done by determining the relevant parameters and applying some straightforward rules to obtain the correct computing time formula. In summary, as instructors we have tried to emphasize the following notions to our students: In addition there are two underlying currents which, though not explicitly emphasized are covered throughout. The first is the notion of writing nicely structured programs.

For all of the programs contained herein we have tried our best to structure them appropriately. We hope that by reading programs with good style the students will pick up good writing habits.

A nudge on the instructor's part will also prove useful. The second current is the choice of examples. We have tried to use those examples which prove a point well, have application to computer programming, and exhibit some of the brightest accomplishments in computer science. At the close of each chapter there is a list of references and selected readings. These are not meant to be exhaustive. They are a subset of those books and papers that we found to be the most useful.

Otherwise, they are either historically significant or develop the material in the text somewhat further. Many people have contributed their time and energy to improve this book. For this we would like to thank them. We wish to thank Arvind [sic], T. Gonzalez, L. Landweber, J. Misra, and D. Wilczynski, who used the book in their own classes and gave us detailed reactions. Thanks are also due to A. Agrawal, M. Cohen, A. Howells, R. Istre, D. Ledbetter, D.

Musser and to our students in CS , CSci and who provided many insights. For administrative and secretarial help we thank M. Eul, G. Lum, J. Matheson, S. Moody, K. Pendleton, and L. To the referees for their pungent yet favorable comments we thank S. Gerhart, T. Standish, and J. Finally, we would like to thank our institutions, the University of Southern California and the University of Minnesota, for encouraging in every way our efforts to produce this book.

Ellis Horowitz Sartaj Sahni Preface to the Ninth Printing We would like to acknowledge collectively all of the individuals who have sent us comments and corrections since the book first appeared. For this printing we have made many corrections and improvements. October l file: One often quoted definition views computer science as the study of algorithms.

This study encompasses four distinct areas: The goal is to study various forms of machine fabrication and organization so that algorithms can be effectively carried out. At one end are the languages which are closest to the physical machine and at the other end are languages designed for sophisticated problem solving. One often distinguishes between two phases of this area: The first calls for methods for specifying the syntax and semantics of a language.

The second requires a means for translation into a more basic set of commands. Abstract models of computers are devised so that these properties can be studied.

This was realized as far back as by Charles Babbage, the father of computers. An algorithm's behavior pattern or performance profile is measured in terms of the computing time and space that are consumed while the algorithm is processing.

Questions such as the worst and average time and how often they occur are typical. We see that in this definition of computer science, "algorithm" is a fundamental notion. Thus it deserves a precise definition. The dictionary's definition "any mechanical or recursive computational procedure" is not entirely satisfying since these terms are not basic enough. An algorithm is a finite set of instructions which, if followed, accomplish a particular task.

In addition every algorithm must satisfy the following criteria: It is not enough that each operation be definite as in iii , but it must also be feasible. In formal computer science, one distinguishes between an algorithm, and a program.

A program does not necessarily satisfy condition iv. One important example of such a program for a computer is its operating system which never terminates except for system crashes but continues in a wait loop until more jobs are entered. In this book we will deal strictly with programs that always terminate. Hence, we will use these terms interchangeably. An algorithm can be described in many ways.

A natural language such as English can be used but we must be very careful that the resulting instructions are definite condition iii. An improvement over English is to couple its use with a graphical form of notation such as flowcharts.

This form places each processing step in a "box" and uses arrows to indicate the next step. Different shaped boxes stand for different kinds of operations. All this can be seen in figure 1. The point is that algorithms can be devised for many common activities.

Have you studied the flowchart? Then you probably have realized that it isn't an algorithm at all! Which properties does it lack? Returning to our earlier definition of computer science, we find it extremely unsatisfying as it gives us no insight as to why the computer is revolutionizing our society nor why it has made us re-examine certain basic assumptions about our own role in the universe.

While this may be an unrealistic demand on a definition even from a technical point of view it is unsatisfying. The definition places great emphasis on the concept of algorithm, but never mentions the word "data". If a computer is merely a means to an end, then the means may be an algorithm but the end is the transformation of data.

That is why we often hear a computer referred to as a data processing machine. Raw data is input and algorithms are used to transform it into refined data. So, instead of saying that computer science is the study of algorithms, alternatively, we might say that computer science is the study of data: Figure 1. Flowchart for obtaining a Coca-Cola There is an intimate connection between the structuring of data, and the synthesis of algorithms.

In fact, a data structure and an algorithm should be thought of as a unit, neither one making sense without the other. For instance, suppose we have a list of n pairs of names and phone numbers a1,b1 a2,b2 , This task is called searching. Just how we would write such an algorithm critically depends upon how the names and phone numbers are stored or structured. One algorithm might just forge ahead and examine names, a1,a2,a3, This might be fine in Oshkosh, but in Los Angeles, with hundreds of thousands of names, it would not be practical.

If, however, we knew that the data was structured so that the names were in alphabetical order, then we could do much better. We could make up a second list which told us for each letter in the alphabet, where the first name with that letter appeared.

For a name beginning with, say, S, we would avoid having to look at names beginning with other letters. So because of this new structure, a very different algorithm is possible.

Other ideas for algorithms become possible when we realize that we can organize the data as we wish. We will discuss many more searching strategies in Chapters 7 and 9. Therefore, computer science can be defined as the study of data, its representation and transformation by a digital computer. The goal of this book is to explore many different kinds of data objects.

For each object, we consider the class of operations to be performed and then the way to represent this object so that these operations may be efficiently carried out. This implies a mastery of two techniques: The pedagogical style we have chosen is to consider problems which have arisen often in computer applications. For each problem we will specify the data object or objects and what is to be accomplished.

After we have decided upon a representation of the objects, we will give a complete algorithm and analyze its computing time. After reading through several of these examples you should be confident enough to try one on your own.

There are several terms we need to define carefully before we proceed. These include data structure, data object, data type and data representation. These four terms have no standard meaning in computer science circles, and they are often used interchangeably. A data type is a term which refers to the kinds of data that variables may "hold" in a programming language.

With every programming language there is a set of built-in data types. This means that the language allows variables to name data of that type and file: Some data types are easy to provide because they are already built into the computer's machine language instruction set.

Integer and real arithmetic are examples of this. Other data types require considerably more effort to implement. In some languages, there are features which allow one to construct combinations of the built-in types. However, it is not necessary to have such a mechanism. All of the data structures we will see here can be reasonably built within a conventional programming language. Data object is a term referring to a set of elements, say D.

Thus, D may be finite or infinite and if D is very large we may need to devise special ways of representing its elements in our computer. The notion of a data structure as distinguished from a data object is that we want to describe not only the set of objects, but the way they are related. Saying this another way, we want to describe the set of operations which may legally be applied to elements of the data object. This implies that we must specify the set of operations and show how they work.

To be more precise lets examine a modest example. The following notation can be used: SUCC stands for successor. The rules on line 8 tell us exactly how the addition operation works.

For example if we wanted to add two and three we would get the following sequence of expressions: In practice we use bit strings which is a data structure that is usually provided on our computers. But however the ADD operation is implemented, it must obey these rules. Hopefully, this motivates the following definition.

A data structure is a set of domains , a designated domain , a set of functions and a file: The triple www. The form in which we choose to write the axioms is important. Our goal here is to write the axioms in a representation independent way. Then, we discuss ways of implementing the functions using a conventional programming language. An implementation of a data structure d is a mapping from d to a set of other data structures e. This mapping specifies how every object of d is to be represented by the objects of e.

Secondly, it requires that every function of d must be written using the functions of the implementing data structures e. Thus we say that integers are represented by bit strings, boolean is represented by zero and one, an array is represented by a set of consecutive words in memory. In current parlance the triple is referred to as an abstract data type. It is called abstract precisely because the axioms do not imply a form of representation. Another way of viewing the implementation of a data structure is that it is the process of refining an abstract data type until all of the operations are expressible in terms of directly executable functions.

But at the first stage a data structure should be designed so that we know what it does, but not necessarily how it will do it. This division of tasks, called specification and implementation, is useful because it helps to control the complexity of the entire process. Though some of these are more preferable than others, the choice of a specific language leaves us with many difficulties. First of all, we wish to be able to write our algorithms without dwelling on the idiosyncracies of a given language.

Secondly, some languages have already provided the mechanisms we wish to discuss. Thus we would have to make pretense to build up a capability which already exists. Finally, each language has its followers and its detractors. We would rather not have any individual rule us out simply because he did not know or, more particularly, disliked to use the language X.

Furthermore it is not really necessary to write programs in a language for which a compiler exists. Instead we choose to use a language which is tailored to describing the algorithms we want to write.

Most importantly, the language we use will be close enough to many of the languages mentioned before so that a hand translation will be relatively easy to accomplish. Moreover, one can easily program a translator using some existing, but more primitive higher level language as the output see Appendix A.

Nevertheless, computerniks still try to attach a meaning. Several cute ideas have been suggested, such as Structured Programming: The way to assign values is by the assignment statement variable expression. In addition to the assignment statement, SPARKS includes statements for conditional testing, iteration, input-output, etc. Several such statements can be combined on a single line if they are separated by a semi-colon.

Fundamentals of Data Structures in C Horowitz PDF

Expressions can be either arithmetic, boolean or of character type. In the boolean case there can be only one of two values, true or false. In order to produce these values, the logical operators and, or, not are provided, plus the relational operators file: If S1 or S2 contains more than one statement, these will be enclosed in square brackets.

Brackets must be used to show how each else corresponds to one if. The meaning of this statement is given by the flow charts: We will assume that conditional expressions are evaluated in "short circuit" mode; given the boolean expression cond1 or cond2 , if condl is true then cond2 is not evaluated; or, given condl and cond2 , if cond1 is false then cond2 is not evaluated. To accomplish iteration, several statements are available.

One of them is while cond do S end where cond is as before, S is as S1 before and the meaning is given by It is well known that all "proper" programs can be written using only the assignment, conditional and while statements.

This result was obtained by Bohm and Jacopini. Though this is very interesting from a theoretical viewpoint, we should not take it to mean that this is the way to program. On the contrary, the more expressive our languages are, the more we can accomplish easily. So we will provide other statements such as a second iteration statement, the repeat-until, repeat S file: Another iteration statement is loop S forever which has the meaning As it stands, this describes an infinite loop!

Fundamentals of Data Structures in C Horowitz PDF

However, we assume that this statement is used in conjunction with some test within S which will cause an exit. One way of exiting such a loop is by using a go to label statement which transfers control to "label.

A more restricted form of the go to is the command exit which will cause a transfer of control to the first statement after the innermost loop which contains it. This looping statement may be a while, repeat, for or a loop-forever.

A variable or a constant is a simple form of an expression.

Post navigation

The semantics is easily described by the file: The else clause is optional. The expr may be omitted in which case a return is made to the calling procedure. The execution of an end at the end of procedure implies a return. A procedure may be invoked by using a call statement call NAME parameter list Procedures may call themselves, direct recursion, or there may be a sequence resulting in indirect recursion. Though recursion often carries with it a severe penalty at execution time, it remains all elegant way to describe many computing processes.

This penalty will not deter us from using recursion. Many such programs are easily translatable so that the recursion is removed and efficiency achieved.

All procedures are treated as external, which means that the only means for communication between them is via parameters. This may be somewhat restrictive in practice, but for the purpose of exposition it helps to list all variables explicitly, as either local or parameter. The association of actual to formal parameters will be handled using the call by reference rule. This means that at run time the address of each parameter is passed to the called procedure.

Parameters which are constants or values of expressions are stored into internally generated words whose addresses are then passed to the procedure. We avoid the problem of defining a "format" statement as we will need only the simplest form of input and output. The command stop halts execution of the currently executing procedure. Comments may appear anywhere on a line enclosed by double slashes, e. An n-dimensional array A with lower and upper bounds li, ui, 1 i n may be declared by using the syntax declare A l1: We have avoided introducing the record or structure concept.

These are often useful features and when available they should be used. However, we will persist in building up a structure from the more elementary array concept. Since most of the SPARKS programs will be read many more times than they will be executed, we have tried to make the code readable. This is a goal which should be aimed at by everyone who writes programs. The SPARKS language is rich enough so that one can create a good looking program by applying some simple rules of style.

Avoid sentences like ''i is increased by one. See the book The Elements of Programming Style by Kernighan and Plauger for more examples of good rules of programming.

This method uses the philosophy: Surprisingly, this method is in wide use today, with the result that an average programmer on an average job turns out only between five to ten lines of correct code per day. We hope your productivity will be greater. But to improve requires that you apply some discipline to the process of creating programs.

To understand this process better, we consider it as broken up into five phases: Make sure you understand the information you are given the input and what results you are to produce the output. Try to write down a rigorous description of the input and output which covers all cases. You are now ready to proceed to the design phase. Designing an algorithm is a task which can be done independently of the programming language you eventually plan to use.

In fact, this is desirable because it means you can postpone questions concerning how to represent your data and what a particular statement looks like and concentrate on the order of processing. You may have several data objects such as a maze, a polynomial, or a list of names. For each object there will be some basic operations to perform on it such as print the maze, add two polynomials, or find a name in the list. Assume that these operations already exist in the form of procedures and write an algorithm which solves the problem according to the requirements.

Use a notation which is natural to the way you wish to describe the order of processing. Can you think of another algorithm? If so, write it down.

Next, try to compare these two methods. It may already be possible to tell if one will be more desirable than the other.

If you can't distinguish between the two, choose one to work on for now and we will return to the second version later. You must now choose representations for your data objects a maze as a two dimensional array of zeros and ones, a polynomial as a one dimensional array of degree and coefficients, a list of names possibly as an array and write algorithms for each of the operations on these objects. The order in which you do this may be crucial, because once you choose a representation, the resulting algorithms may be inefficient.

Modern pedagogy suggests that all processing which is independent of the data representation be written out first. By postponing the choice of how the data is stored we can try to isolate what operations depend upon the choice of data representation.

You should consider alternatives, note them down and review them later. Finally you produce a complete version of your first program. It is often at this point that one realizes that a much better program could have been built. Perhaps you should have chosen the second design alternative or perhaps you have spoken to a friend who has done it better. This happens to industrial programmers as well. If you have been careful about keeping track of your previous work it may not be too difficult to make changes.

One of the criteria of a good design is file: It is usually hard to decide whether to sacrifice this first attempt and begin again or just continue to get the first version working.

Different situations call for different decisions, but we suggest you eliminate the idea of working on both at the same time.

If you do decide to scrap your work and begin again, you can take comfort in the fact that it will probably be easier the second time.

In fact you may save as much debugging time later on by doing a new version now. This is a phenomenon which has been observed in practice. The graph in figure 1. For each compiler there is the time they estimated it would take them and the time it actually took. For each subsequent compiler their estimates became closer to the truth, but in every case they underestimated.

Unwarrented optimism is a familiar disease in computing. But prior experience is definitely helpful and the time to build the third compiler was less than one fifth that for the first one. Verification consists of three distinct aspects: Each of these is an art in itself. Section 03 The Libra Blockchain The goal of the Libra Blockchain is to serve as a solid foundation for financial services, including a new global currency, which could meet the daily financial needs of billions of people.

Through the process of evaluating existing options, we decided to build a new blockchain based on these three requirements: Able to scale to billions of accounts, which requires high transaction throughput, low latency, and an efficient, high-capacity storage system. Highly secure, to ensure safety of funds and financial data. The Libra Blockchain is designed from the ground up to holistically address these requirements and build on the learnings from existing projects and research — a combination of innovative approaches and well- understood techniques.

This next section will highlight three decisions regarding the Libra Blockchain: Designing and using the Move programming language. Adopting and iterating on widely adopted blockchain data structures.

Specifically, Move is designed to prevent assets from being cloned. The Move language also facilitates automatic proofs that transactions satisfy certain properties, such as payment transactions only changing the account balances of the payer and receiver. By prioritizing these features, Move will help keep the Libra Blockchain secure. Move will accelerate the evolution of the Libra Blockchain protocol and any financial innovations built on top of it.

We anticipate that the ability for developers to create contracts will be opened up over time in order to support the evolution and validation of Move. To facilitate agreement among all validator nodes on the transactions to be executed and the order in which they are executed, the Libra Blockchain adopted the BFT approach by using the LibraBFT consensus protocol.

This approach builds trust in the network because BFT consensus protocols are designed to function correctly even if some validator nodes — up to one-third of the network — are compromised or fail.

In order to securely store transactions, data on the Libra Blockchain is protected by Merkle trees, a data structure used by other blockchains that enables the detection of any changes to existing data.

Unlike previous blockchains, which view the blockchain as a collection of blocks of transactions, the Libra Blockchain is a single data structure that records the history of transactions and states over time. This implementation simplifies the work of applications accessing the blockchain, allowing them to read any data from any point in time and verify the integrity of that data using a unified framework. The Libra Blockchain is pseudonymous and allows users to hold one or more addresses that are not linked to their real-world identity.

This approach is familiar to many users, developers, and regulators. The Libra Association will oversee the evolution of the Libra Blockchain protocol and network, and it will continue to evaluate new techniques that enhance privacy in the blockchain while considering concerns of practicality, scalability, and regulatory impact.

For more details, read the technical paper on the Libra Blockchain. Detailed information is also available on the Move programming language and the LibraBFT consensus protocol.

The testnet is still under development, and APIs are subject to change. Our commitment is to work in the open with the community and hope you will read, build, and provide feedback. The Libra currency is designed to help with these global needs, aiming to expand how money works for more people around the world. Libra is designed to be a stable digital cryptocurrency that will be fully backed by a reserve of real assets — the Libra Reserve — and supported by a competitive network of exchanges buying and selling Libra.

That means anyone with Libra has a high degree of assurance they can convert their digital currency into local fiat currency based on an exchange rate, just like exchanging one currency for another when traveling. Instead of backing Libra with gold, though, it will be backed by a collection of low-volatility assets, such as bank deposits and short-term government securities in currencies from stable and reputable central banks.

It is important to highlight that this means one Libra will not always be able to convert into the same amount of a given local currency i. Rather, as the value of the underlying assets moves, the value of one Libra in any local currency may fluctuate. The assets in the Libra Reserve will be held by a geographically distributed network of custodians with investment-grade credit rating to provide both security and decentralization of the assets.

The assets behind Libra are the major difference between it and many existing cryptocurrencies that lack such intrinsic value and hence have prices that fluctuate significantly based on expectations. Libra is indeed a cryptocurrency, though, and by virtue of that, it inherits several attractive properties of these new digital currencies: the ability to send money quickly, the security of cryptography, and the freedom to easily transmit funds across borders. Just as people can use their phones to message friends anywhere in the world today, with Libra, the same can be done with money — instantly, securely, and at low cost.

The rules for allocating interest on the reserve will be set in advance and will be overseen by the Libra Association. Users of Libra do not receive a return from the reserve. For more on the reserve policy and the details of the Libra currency, please read here. Section 05 The Libra Association To make the mission of Libra a reality — a simple global currency and financial infrastructure that empowers billions of people — the Libra Blockchain and Libra Reserve need a governing entity that is comprised of diverse and independent members.

This governing entity is the Libra Association, an independent, not-for-profit membership organization, headquartered in Geneva, Switzerland. Switzerland has a history of global neutrality and openness to blockchain technology, and the association strives to be a neutral, international institution, hence the choice to be registered there.

The association is governed by the Libra Association Council, which is comprised of one representative per validator node. Together, they make decisions on the governance of the network and reserve. Initially, this group consists of the Founding Members : businesses, nonprofit and multilateral organizations, and academic institutions from around the world.

All decisions are brought to the council, and major policy or technical decisions require the consent of two-thirds of the votes, the same supermajority of the network required in the BFT consensus protocol. In that sense, it is similar to other not-for-profit entities, often in the form of foundations, which govern open-source projects.

As Libra relies on a growing distributed community of open-source contributors to further itself, the association is a necessary vehicle to establish guidance as to which protocols or specifications to develop and to adopt. The Libra Association also serves as the entity through which the Libra Reserve is managed, and hence the stability and growth of the Libra economy are achieved.

The association is the only party able to create mint and destroy burn Libra. Coins are only minted when authorized resellers have purchased those coins from the association with fiat assets to fully back the new coins. Coins are only burned when the authorized resellers sell Libra coin to the association in exchange for the underlying assets. An additional goal of the association is to develop and promote an open identity standard. We believe that decentralized and portable digital identity is a prerequisite to financial inclusion and competition.

An important objective of the Libra Association is to move toward increasing decentralization over time. As discussed above, the association will develop a path toward permissionless governance and consensus on the Libra network.

In the same spirit, the association aspires to minimize the reliance on itself as the administrator of the Libra Reserve.

For more on the Libra Association, please read here.


Today we are publishing this document outlining our goals for Libra and launching libra. It will continue to be updated over the coming months. There is much left to do before the target launch in the first half of The Libra Blockchain: Over the coming months, the association will work with the community to gather feedback on theLibra Blockchain prototype and bring it to a production-ready state.We see that the subscript at the right moves the fastest.

The maximum total increment in j over the whole loop is t2. This approach builds trust in the network because BFT consensus protocols are designed to function correctly even if some validator nodes — up to one-third of the network — are compromised or fail. Academic Press. To the referees for their pungent yet favorable comments we thank S. Data Structures B. Instead we might store them in a one dimensional array and include a front i and rear i pointer for the beginning and end of each list.

Try to write down a rigorous description of the input and output which covers all cases. The value of an implementation ultimately relies on its resource utilization: Eul, G.