1.1 High risk problems are address in the prototype program to make sure that the program is feasible. <STOP> A prototype may also be used to show a company that the software can be possibly programmed. <STOP>
1.1 To simulate portions of the desired final product with a quick and easy program that does a small specific job. <STOP> It is a way to help see what the problem is and how you may solve it in the final project. <STOP>
1.1 A prototype program simulates the behaviors of portions of the desired software product to allow for error checking. <STOP>
1.1 Defined in the Specification phase a prototype stimulates the behavior of portions of the desired software product. <STOP> Meaning, the role of a prototype is a temporary solution until the program itself is refined to be used extensively in problem solving. <STOP>
1.1 It is used to let the users have a first idea of the completed program and allow the clients to evaluate the program. <STOP> This can generate much feedback including software specifications and project estimations of the total project. <STOP>
1.1 To find problem and errors in a program before it is finalized <STOP>
1.1 To address major issues in the creation of the program. <STOP> There is no way to account for all possible bugs in the program, but it is possible to prove the program is tangible. <STOP>
1.1 you can break the whole program into prototype programs to simulate parts of the final program <STOP>
1.1 To provide an example or model of how the finished program should perfom. <STOP> Provides forsight of some of the challanges that would be encountered. <STOP> Provides opportunity To introduce changes To the finished program. <STOP>
1.1 Simulating the behavior of only a portion of the desired software product. <STOP>
1.1 A program that stimulates the behavior of portions of the desired software product. <STOP>
1.1 A program that simulates the behavior of portions of the desired software product. <STOP>
1.1 To lay out the basics and give you a starting point in the actual problem solving. <STOP>
1.1 To simulate problem solving for parts of the problem <STOP>
1.1 A prototype program provides a basic groundwork from which to further enhance and improve a solution to a problem. <STOP>
1.1 A prototype program is a part of the Specification phase of Software Problem Solvin. <STOP> It is employed to illustrate how the key problem or problems will be solved in a program, and sometimes serves as a base program to expand upon. <STOP>
1.1 Program that simulates the behavior of portions of the desired software product <STOP>
1.1 it provides a limited proof of concept to verify with the client before actually programming the whole application. <STOP>
1.1 It tests the main function of the program while leaving out the finer details. <STOP>
1.1 To get early feedback from users in early stages of development. <STOP> To show users a first idea of what the program will do or look like. <STOP> To make sure the program will meet requirements before intense programming begins. <STOP>
1.1 it simulates the behavior of portions of the desired software product <STOP>
1.1 It simulates the behavior of portions of the desired software product. <STOP>
1.1 A prototype program is used in problem solving to collect data for the problem. <STOP>
1.1 To ease the understanding of problem under discussion and to ease the understanding of the program itself <STOP>
1.1 it simulates the behavior of portions of the desired software product <STOP>
1.1 The role of a prototype program is to help spot key problems that may arise during the actual programing. <STOP>
1.1 the prototype program gives a general idea of what the end product will do, without the time and effort to write out the entire program. <STOP>
1.1 to show that a certain part of the program works as it is supposed to <STOP>
1.1 Prototype programming is an approach to programming that enables one to take an organized approach to developing an effective program with minimal errors and a strategic pattern when solving a problem. i. e. book gave an example of a costumer withdrawing money from a bank, the approach that was taking on a pseudo code level during the OOA or Design lvl before proceeding into creating a solution. <STOP>
1.2 Refining and possibly the design if the testing phase reveals problems in the design. <STOP> Production can be affected if the program is unworkable in its current form which will lead to a later production time than originally estimated. <STOP> Also affects coding because after testing you may need to rewrite the code for the program to remove errors. <STOP>
1.2 The implementation phase and the maintenance phase are effected <STOP>
1.2 Verification, coding, refining the solution and maintenance are all influenced by the testing stage. <STOP>
1.2 In RUP the stages in the software life cycle are influenced by the testing stage is: Elaboration phase-refined progject vision, iterative devilopment of core system, development of system requirements, more accurate time and cost estimates. <STOP> Construction phase-iterative development of remaining system. <STOP> Transition phase-testing and deployment of the system. <STOP>
1.2 Refining the solution, Production and Maintenance are all influenced by the Testing stage. <STOP>
1.2 Elaboration, Construction, and Transition are all affected by testing <STOP>
1.2 Refining, Production, Maintenance <STOP>
1.2 Refining the solution <STOP>
1.2 Verification <STOP> Debugging <STOP>
1.2 Refining and Coding <STOP>
1.2 The second half of the Elaboration phase, Construction phase, and the Transition phase. <STOP>
1.2 The refining step, the production step, and the maintenance stage. <STOP>
1.2 Elaboration, Construction, Transition <STOP>
1.2 Refining. <STOP>
1.2 The testing stage has a direct influence on the final version of a program, being as it is the debugging and finalization of a software revision. <STOP>
1.2 Directly: Refining, coding. <STOP> Because Refining is right before the Testing Phase and Coding is right after the Testing Phase. <STOP> Indirectly: Production, Maintenance. <STOP> Because Refining occurs before these last two stages in the Software Life Cycle. <STOP>
1.2 Testing, refining, production, and maintenance. <STOP>
1.2 Depending on how the work is done, Testing is spread throughout the process as to prevent errors from showing up later on due to lack of foresight. <STOP>
1.2 Elaboration, construction, and transition. <STOP>
1.2 All stages are influenced except setting the program requirements. <STOP> If a test fails, it can change the whole design, implementation, etc of a program as well as the final outcome. <STOP>
1.2 Refining, production, and maintenance <STOP>
1.2 coding and refining <STOP>
1.2 refining, production, maintenance. <STOP>
1.2 Removing logical errors, testing for valid data, random data and actual data. <STOP>
1.2 1-specification <STOP> 2-design <STOP> 3-risk analysis <STOP> 4-verification <STOP> 5-coding <STOP> 6-testing <STOP> 7-refining <STOP> 8-production <STOP> 9-maintenance <STOP>
1.2 Refining stage, Production stage, and Maintenance stage. <STOP>
1.2 Testing could affect all parts of the life cycle; it could make you go back to specification if it does not test well. <STOP>
1.2 coding <STOP>
1.2 The Individual components and steps such as analysis, design, and implementing code as well as the entire system are tested for execution of the requirements identified during the analysis stage. i. e. Main output <STOP>
1.3 Modularability, the ability to reuse parts of the program later in another program sometimes with completely different goals for the program. <STOP> Also it makes it easier to debug code by dividing up the code into classes that each do a specific job and when the program fails at one job you only have one class to debug. <STOP> Good for security purposes because it allows you to let someone use a program which sorts lists without having to give them access to the source code. <STOP> ALso allows you to use inheritance and polymorphism. <STOP>
1.3 This type of programming is more flexible, making it easier to add and modify the program. <STOP> It is also a type of a fail safe program, you check each individual module. <STOP> This eliminates redundant code and makes the program easier to read for other programmers. <STOP> When debugging the program it is easier to track down the source of a problem within a module rather than a 2 million line program. <STOP>
1.3 The main advantages to object-oriented programming are that existing classes can be reused and program maintenance and verification are easier. <STOP>
1.3 The advantages is that OOP allows us to build classes of objects. <STOP> Three principles that make up OOP are: Encapsulation-Objects combine data and operations. <STOP> Inheritance-Classes can inherit properties from other classes. <STOP> Polymorphism-Objects can determine appropriate operations at execution time. <STOP>
1.3 Some advantages are existing classes can be reused and program maintenance and verification are easier to accomplish. <STOP>
1.3 Object oriented programming allows programmers to use an object with classes that can be changed and manipulated while not affecting the entire object at once. <STOP> The classes all hold attrubutes that affect the object. <STOP>
1.3 Reusable components, Extensibility, Maintainability, it reduces large problems into smaller more manageable problems. <STOP>
1.3 Encapsulation-objects combine data and operations <STOP> Inheritance-classes can inherit properties from other classes <STOP> Polymorphism-Objects can determine appropriate operations at execution time <STOP>
1.3 Easier to debugg <STOP> Reusability <STOP>
1.3 Re-usability and ease of maintenance <STOP>
1.3 One of the main advantages is you can hide inner details a technique known by encapsulation. <STOP> Objects combine the data and operations but you cannot see how it works. <STOP> Another advantage is you can reuse classes that have been defined earlier in the program, a method known as inheritance. <STOP> Finally another advantage is objects can determine appropriate operations at execution time a technique known as polymorphism. <STOP>
1.3 Existing classes can be reused, and program maintenance and verification are easier. <STOP>
1.3 Using different modules allows for easier debugging <STOP>
1.3 Data encapsulation concept, the use of functions or methods to manipulate data. <STOP>
1.3 Modular, reusable code, allowing faster deployment of solutions, and a more general view of a solution. <STOP>
1.3 Coding and Debugging programs are usually easier, as either the compiler will specify the object that is working incorrectly, or the function an object was assigned to will be easier to identify. <STOP> The code itself also looks more organized and is easier to read and will help to avoid redundant coding. <STOP> Post-programming maintenance is also easier. <STOP> Also, modules can be reused several times in other programs without too much hassle. <STOP> Abstraction is the art of breaking down one big problem into smaller, simpler problems and solving them. <STOP> Many of the smaller problems are shared between unique complex problems, and creating modules to these solve these smaller repeated problems can save time when you encounter them again. <STOP>
1.3 Variables can remain private. <STOP> The code is easily modified and reusable, as well as easily implemented. <STOP> Not to mention easier to read and follow along as an observer. <STOP>
1.3 Data Abstraction and control ... it is possible to isolate elements from other elements a lot easier and prevent tampering of data. <STOP>
1.3 Encapsulation Objects use operations without knowing how the operation works. <STOP> Inheritance cuts redundancy by reusing earlier classes. <STOP> Polymorphism objects select the correct operation to use in the situation. <STOP>
1.3 They make it easier to reuse and adapt previously written code and they separate complex programs into smaller, easier to understand classes. <STOP>
1.3 Existing classes can be reused, Program maintenance and verification are easier <STOP>
1.3 Existing classes can be feused, Program maintenance and verification are easier <STOP>
1.3 the main advantages to object-oriented programming is data abstraction, easier maintenance, and re-usability. <STOP>
1.3 Existing classes can be reused <STOP> Program maintenance and verifications are easy <STOP>
1.3 1-Existing classes can be reused <STOP> 2-Program maintenance and verification are easier <STOP>
1.3 Information can be hidden. <STOP> It is easier to debug. <STOP> Programming is easier and more manageable. <STOP>
1.3 Existing classes can be reused, program maintenance and verification are easier. <STOP>
1.3 existing classes can be reused program maintenance and verification are easier <STOP>
1.3 Well for one encapsulation the values of the variables inside an object are private, unless methods are written to pass info outside of the object. <STOP> As well as Inheritance where each subclass inherits all variables and methods of its super class. <STOP> Example in the book included obj clock and how obj alarm would still use clock from the first class. <STOP>
1.4 At function int main -LRB- -RRB- <STOP>
1.4 the Function main -LRB- -RRB- . <STOP>
1.4 c plus plus programs begin to execute in the main method. <STOP>
1.4 A C plus plus program will begin to execute at the main -LRB- -RRB- function. <STOP>
1.4 They begin in the main -LRB- -RRB- function. <STOP>
1.4 Int main -LRB- -RRB- <STOP>
1.4 main method <STOP>
1.4 in the testing phase <STOP>
1.4 At the MAIN function <STOP>
1.4 main <STOP>
1.4 They begin to execute at the funcion main -LRB- -RRB- . <STOP>
1.4 The main method. <STOP>
1.4 At the root <STOP>
1.4 In the main -LRB- -RRB- function. <STOP>
1.4 C plus plus programs begin execution at main. <STOP>
1.4 In the Main function ..? <STOP>
1.4 At the "main -LRB- -RRB- " function <STOP>
1.4 The main function. <STOP>
1.4 The function main <STOP>
1.4 After loading the required include statements and libraries, the main method begins the execution. <STOP>
1.4 main function <STOP>
1.4 main <STOP>
1.4 C plus plus programs begin execution at the main function. <STOP>
1.4 At main <STOP>
1.4 they beging to excute at main <STOP>
1.4 at the main function int main -LRB- -RRB- <STOP>
1.4 C plus plus programs begin execution at the main function. <STOP>
1.4 in the "main" function <STOP>
1.4 Within the main function <STOP>
1.5 Variable can be a integer or a string in a program. <STOP>
1.5 In programming, a structure that holds data and is uniquely named by the programmer. <STOP> It holds the data assigned to it until a new value is assigned or the program is finished. <STOP>
1.5 A variable is a location in memory where a value can be stored. <STOP>
1.5 Variable is a location in the computer 's memory, in which a value can be stored and later can retrieve that value. <STOP>
1.5 A variable is a location in the computer 's memory where a value can be stored for use by a program. <STOP> Each variable has a name, a value, a type and a size. <STOP>
1.5 A named object that can hold a numerical or letter value <STOP>
1.5 It is a sybol or name for a value or number. <STOP> Example: "a used number" can stand for any given number, and the programmer can refer to that number by using the variable name. <STOP>
1.5 A variable is a location in the computers memory where a value can be stored for use by a program <STOP>
1.5 An identifier that holds a location in memory. <STOP>
1.5 a block of memory that holds a specific type of data <STOP>
1.5 It is a location in the computer 's memory where it can be stored for use by a program. <STOP>
1.5 A location in memory where value can be stored. <STOP>
1.5 a value or word that can assume any of a set of values <STOP>
1.5 A pointer to a location in memory. <STOP>
1.5 A variable is the memory address for a specific type of stored data, or from a mathematical perspective, a symbol representing a fixed definition with changing values. <STOP>
1.5 A variable is a value that is subject to change in a computer 's memory that can be used by programs. <STOP> Programs can change the value of the variable and recall it later or act on it directly. <STOP>
1.5 a symbol that stands in for a value that may or may not change depending on the program. <STOP>
1.5 a placeholder to hold information used in the program ... for example: int can hold: 1, 2, 3, 4, 68, 72, 256, etc. float can hold: 1.54, 55.55, 1.24, 5.657, 8.8123, et. char can hold: A, B, C, D, E, F,!, 4, 5, 6, P, etc. <STOP>
1.5 a stored value used by the program <STOP>
1.5 A way to store different values into the program, such as numbers, words, letters, etc. <STOP>
1.5 An object with a location in memory where value can be stored <STOP>
1.5 location in memory where a value can be stored <STOP>
1.5 a variable is an object where data is stored. <STOP>
1.5 Location in memory where a value can be stored. <STOP>
1.5 it is a location in memory where value can be stored <STOP>
1.5 A variable is the location in a computer 's memory where a value can be stored for use by a program. <STOP>
1.5 A variable is a location in a computers memory where a value can be stored for use by a program. <STOP>
1.5 a location in memory where data can be stored and retrieved <STOP>
1.5 Is a method or identifier I would say, we use to bind a data object to memory location; which is then stored in a location that can be accessed when and manipulated later when the variable name is called. <STOP>
1.6 They can be declared right before they are used, but it is a good practice to declare them at the beginning of the program and label what they are food. <STOP>
1.6 In the Function main -LRB- -RRB- before using the variable. <STOP>
1.6 Local variables are declared inside the method or function they will be used in at the beginning of the method. <STOP> Global variables are declared outside of any function or method, generally before functions are defined. <STOP>
1.6 Variables are declared where ever it is defined either inside a block locally or outside a block globally. <STOP>
1.6 Variables are declared before they are actually used. <STOP> They can be declared before main -LRB- -RRB- to use globally <STOP>
1.6 For good programing practice they should be declared before main -LRB- -RRB- , but should at least be declared before they are used. <STOP>
1.6 They can be declared globally just before the main method -LRB- but also outside of it -RRB- ... or variables can be subject to only the method they are scoped within, but would still be declared at the beginning of that method -LRB- but inside of it -RRB- . <STOP>
1.6 local variables are declared inside the method while global variables are declared in the body. <STOP>
1.6 Any where in the main function. <STOP>
1.6 Globally for an entire program, and locally for individual functions -LRB- including FOR statements -RRB- <STOP>
1.6 They are usually declared at the beginning before they can be used in the program. <STOP> They always contain a name and a data type. <STOP>
1.6 Inside the method. <STOP>
1.6 at the top <STOP>
1.6 Global variables are declared in the body of the code. <STOP> Local variables are declared in the function they are to be used -LRB- unless the function is being passed a variable -RRB- . <STOP> Variables should always be declared before use. <STOP>
1.6 Variables are usually declared at the beginning of a module of C plus plus code. <STOP>
1.6 In the main function, usually at the top of code. <STOP> They can be declared almost anywhere, but must be declared before the code can use or act upon them. <STOP>
1.6 in the very beginning of the program. <STOP> Before the main -LRB- -RRB- starts. <STOP>
1.6 In the declaration of Functions, for statements, and while statements. in the body of If, For, while, do while, statements, in namespaces, headers, etc -LRB- almost anywhere. <STOP> -RRB- anywhere in the program, as long as it is on it is own line. <STOP>
1.6 After declaration of the variable 's data type. <STOP>
1.6 anywhere in the code, can be at the top, or in the middle of the code, or anywhere. <STOP>
1.6 Before they are used. <STOP>
1.6 Anywhere in the same scope before they are used <STOP>
1.6 variables can be declared in classes and methods. <STOP>
1.6 inside the function scope and outside of the function scope in case of global variables <STOP>
1.6 global variables are declared in the main function local variables are declared in any other function <STOP>
1.6 Variables are usually declared at the very beginning of a C plus plus program, but can be declared any in the program as long as they appear before they are called upon. <STOP>
1.6 Variables are declared in the main function, before any operation is attempted with the variables. <STOP>
1.6 anywhere, but where you declare them depends on where you want them to be accessible -LRB- their scope -RRB- <STOP>
1.6 It depends if it s a global then they have to be declared out side the source code to be used in every scope however a local variable is one declared in a local function etc. which obviously doesn t need to be declared outside the variable seeing how it is used for the function or block its being called for. <STOP>
1.7 "The do statement first evaluates the condition and then executes the lines of code in the statement 0 or more times. <STOP> The do while statement executes the lines of code and then it evaluates the condition. <STOP> " <STOP>
1.7 do ... while statements evaluate whether or not to loop after running the block contained within it at least once. <STOP> So the main differance is that while statements have a possibility of never being used. <STOP> Do ... while statements on the other hand are always run at least once before evaluating whether to run again. <STOP>
1.7 The main difference between a while and a do ... while loop is that the do ... while loop always cycles through the loop at least once, but the while loop does not always do so. <STOP>
1.7 While loop used to execute a block of code as long as some condition is true. <STOP> A do ... while loop used to execute a block of code as long as some condition is satisfied. <STOP> The difference between while and do ... while is while loop tests its condition before the execution of its contents and the do ... while loop tests its condition after the execution of its contents at least once. <STOP>
1.7 The termination condition of a do ... while statement is usually at the end of the loop so it will run at least once. <STOP> As for the while statement, if the condition is false to begin with, then the loop will never run. <STOP>
1.7 A while loop will check the statement to make sure it is true before executing. <STOP> A do while loop will execute before checking the statement to see if it should run again. <STOP>
1.7 A while statement will test the condition of the while loop FIRST there is a chance the loop will never run. <STOP> A do ... while loop will ALWAYS run once, and then the while test will determine if it will run again. <STOP>
1.7 a do while loop always executes once. <STOP> A while loop 's conditional statement has to be true for it to run. <STOP>
1.7 WHILE statement-The condition is checked for validity, then is repeated until the conditon is false. <STOP> Do ... WHILE statement --The code is performed at least once then checked for valid condition. <STOP> Will continue to <STOP>
1.7 while statements will evaluate the statement BEFORE executing a cycle of the loop, including the first cycle, meaning that a while loop will not always execute. <STOP> A do ... while will run evaluate the statement AFTER running through a cycle of the loop, ensuring that the loop always executes at least one time. <STOP>
1.7 The main difference between a do and a do ... while statement is in a do ... while statement is the statements in a do block are always executed atleast once. <STOP> The while statement will only execute if its condition is true. <STOP>
1.7 The loop of a do ... while statement always executes once. <STOP>
1.7 a while statement will only process if the statement is met, while a do ... while will always process once, then only continue if the statement is met. <STOP>
1.7 Do ... while runs the embedded code at least once, the do command does not necessarily <STOP>
1.7 While tests for true first before running, do ... while runs once first before checking. <STOP>
1.7 A do ... while statement 's body always executes at least once. <STOP> Where as a while statement will not execute at all unless the condition for the while is true. <STOP>
1.7 The statements within the block of the do while loop will always be executed at least once regardless of the conditions. <STOP> Whereas the while loops may never be executed if the conditions are not met. <STOP>
1.7 a do ... while loop will always run through once, while an while loop performs a test before running through the loop. <STOP>
1.7 A while statement tests the condition before it can start. <STOP> A do ... while statement loops through once before the condition is tested. <STOP>
1.7 A while loop terminates at the beginning of the loop, a do or while terminates at the end of the loop. <STOP>
1.7 the loop body always executes at least once <STOP>
1.7 While loop evaluates its expression at the top of its loop and decides if it needs to execute, and the do-while always executes at least once and then evaluates its expression at the bottom of its loop. <STOP>
1.7 A do ... while statement will always execute the "do" piece of code at least once before checking the condition. <STOP> A while statement will always check the condition first. <STOP>
1.7 A do-while passes atleast 1 time before checking the condition, however, a while would fail to enter the loop if the condition fails in its first place. <STOP>
1.7 a while loop checks if the condition is true or not first, if it was true, it excutes the statement. a do .. while loop executes the statement before it checks the condition. if the condition was true it would excute the statement again. so a do ... while loop would excute the statement atleast once. <STOP>
1.7 NO ANSWER <STOP>
1.7 A do ... while loop will always execute atleast once, a while loop may never execute depending on teh conditions. <STOP>
1.7 a while loop is pre-check -LRB- it checks the condition statement before it executes the code within the while block -RRB- a do while loop is post-check -LRB- it checks the condition AFTER the block executes, it runs at least once no matter what the condition statement is -RRB- <STOP>
1.7 -RRB- -RRB- What is the main difference between a while and a do ... while statement? <STOP> The do while construct consists of a block of code and a condition. <STOP> First, the code within the block is executed, and then the condition is evaluated, this is done until it is proven false. <STOP> The difference between the While loop is it tests the condition before the code within the block is executed. <STOP>
2.1 For us it is usually a set, get, and displayMessge or other messages that tell you what properties a class has but does not reveal its implementations. <STOP> You could have anything you want in your own class definition. <STOP>
2.1 The attributes of said class. <STOP> Also whether or not it is a subclass. <STOP> Also whether it is public private or protected. <STOP>
2.1 Information telling the compiler what data members and member functions belong to the class. <STOP>
2.1 Since class is user defined, the body of the declaration can contain members, that can be either data or function declarations, and optionally access specifiers. <STOP> Example for specifiers would be public, private, and protected. <STOP> There is the keyword Class and the Class body is enclosed with brackets -LRB- -RRB- . <STOP>
2.1 An object and data. <STOP>
2.1 It is specific class name, includes only information defined by that class ... implementation details ... etc. <STOP>
2.1 data members and member functions. <STOP>
2.1 A class definition usually contains the function and its data members <STOP>
2.1 Data members and member functions <STOP>
2.1 member functions <STOP>
2.1 Member functions and data members belonging to the class. <STOP>
2.1 a public and private area that includes the functions and variables that are used in the class <STOP>
2.1 the keyword class followed by they class name, on the inside you declare public and private declarations of your class <STOP>
2.1 A class definition typically includes function definitions. <STOP>
2.1 It begins with Class, followed by the class name, then usually a constructor, data members and member functions that delineates the class is included in any class 's definition. <STOP>
2.1 the data and methods <STOP>
2.1 A constructor, functions, and variables that are accessible to by that class, and possibly other classes depending on how they are done. <STOP>
2.1 Member functions and data members. <STOP>
2.1 public section and private section, and there must be a semicolon to set the end <STOP>
2.1 member funtions and data members <STOP>
2.1 Data members and Member functions <STOP>
2.1 data members and member functions <STOP>
2.1 the class name and its public data types such as constructors, methods, functions. <STOP>
2.1 a constructor and several data members, and at least one public data member or method <STOP>
2.1 class name, two curly prenthesis, public and private <STOP>
2.1 data members and member functions <STOP>
2.1 Data and functions <STOP>
2.1 functions and data members that belong to the class <STOP>
2.1 class variables, function definitions for the class <STOP>
2.1 A class is an expanded concept of a data structure, it holds both the data and the functions being executed <STOP>
2.2 Data members are the data components of a particular class. <STOP> A member function are the functioning components of the class. <STOP>
2.2 A field variable is a variable that is declared as a member of a class. <STOP> A local variable is avariable that isdeclared local to a method. <STOP>
2.2 Data members are declared inside the class, but outside of any member functions. <STOP> Unlike with local variables, each object of the class keeps its own copy of the data members stored in memory. <STOP>
2.2 Data member are variables that represent an attribute in a class definition. <STOP> Local variables declared in a function body cannot be used outside of that function body. <STOP> When a function terminates the values of its local variables are lost. <STOP>
2.2 A local variable cannot be accessed outside the function in which it is declared. <STOP> Data members normally are private. <STOP> Variables of functions declared private are accessible only to member functions of the class in which they are declared. <STOP>
2.2 A data member is part of a C plus plus class or structure that stores data of a certain type ... A local variable inside a member function is only available inside that function, and can be used to derive a desired outcome. <STOP>
2.2 A local variable can only be accessed within the scope of its declaration. <STOP>
2.2 Data members are the atributes of the function and can be used outside the function. <STOP> Local variable can not be used outside the function and the value is lost after the function terminates. <STOP>
2.2 data members are permanent attributes of the class, local variables inside a member function are lost when the scope of the member function ends. <STOP>
2.2 data members are declared in a class definition but outside the bodies of a class 's member-function definitions. <STOP> Local variables are declared in a function definition 's body <STOP>
2.2 A data member is globally accessible, while a local variable is only accessible inside the member function. <STOP>
2.2 A variable inside a member function can only be accessed inside that member and a data member can be accessed throughought the program. <STOP>
2.2 Local variables are used only within the scope of its declaration <STOP>
2.2 A data member is a more general term describing all objects instantiated within a member function. <STOP> "Local" in local variables refers more to the scope of a variable, which may be located in anything from a control structure to a class. <STOP> Local variables whose scope are in a member function are the same as data members of member functions. <STOP>
2.2 A data member exists permanently in that program 's memory as long as it is run. <STOP> A local variable inside a member function is temporal and only used to operate in the function and exists as long as the function is run. <STOP>
2.2 local variables can only be used within the function, where as data members can be set to public access and can be used throughout <STOP>
2.2 The local variable is lost once it exits the block of code, while the data member is not. <STOP>
2.2 Every member function can access and modify a data member. <STOP> A local variable can only be used from the line of declaration to the next closing before it is lost from memory. <STOP>
2.2 data member is accessible to all functions in the class, where local variable is only available to the member function and value is lost when function closes <STOP>
2.2 Data members are variables that are declared inside the class definition but outside of the bodies of the class member functions. <STOP> Local variables can only be used within the function declaration. <STOP>
2.2 The data member can be accessed outside of the class, whereas the local variable cannot. <STOP>
2.2 Local variables cannot be used outside of that function body. <STOP> When a function terminates the values of its local variables are lost. <STOP> Where as data members are variables in a class definition, and they exist throughout the life of the object. <STOP>
2.2 a local variable in a member function has to be static. a data member can change its value freely. <STOP>
2.2 a local variable is only useable within the function it is defined, whereas a data member is available to any method within its class <STOP>
2.2 Variable declared in a function defination 's body cannot be used outside of that function. <STOP> Data members accessible only to member function of that class. <STOP>
2.2 data members local variables are declared in a function definition s body. they Cannot be used outside of that function body. <STOP> When a function terminates, the values of its local variables are lost. <STOP>
2.2 local variable is only available in the function. <STOP>
2.2 local variables are accessed inside member functions only while data members can be accessed throughout the class <STOP>
2.2 A data member is accessible anywhere in the class, while i local variable in a member function is only accessible in that particular function, and is freed after the function exits. <STOP>
2.2 a Data member is encapsulated within a class or object, it is static and can be shared by all instances of that class. however local variable 's are only used from the function or block in which it is declared and not the whole class. other wise they would be called global variables. <STOP>
2.3 A constructor initializes an object or objects of a class. <STOP> A function of a class performs a task such as display a line of text or do some kind of mathematical operations. <STOP>
2.3 all constructors are functions but not all functions are constructors. <STOP> Also functions can have nearly infinite purposes, while constructors always create an instance of whichever class you are using. <STOP> You can change how a constructor does something but not what it does. <STOP> With functions you can change not only the how but also the what. <STOP>
2.3 Unlike regular functions, constructors are only used to initialize an object s data when it is created. <STOP> Constructors must also be given the same name as the class and cannot return any values. <STOP>
2.3 A constructor typically used to intialize data members and allocate resources, for instance memory, files, etc. Also a constructor cannot return values. <STOP> Functions are operations that maybe globally defined. <STOP>
2.3 Constructors cannot return values, so they cannot specify a return type. <STOP> Normally, constructors are declared public. <STOP>
2.3 A constructor is a method that starts new instances of a class. <STOP> -LRB- Example: Employee employee 1 -LRB- parameters -RRB- starts a new instance of object of type Employee -RRB- . <STOP> A function is simply a module within a program that completes its single desired task. <STOP>
2.3 A constructor is called whenever a new object of that class is made. <STOP>
2.3 A constructor does not return any date and has no return type. <STOP> Functions can return date or not return data can have a return type. <STOP>
2.3 A constructor is automatically called whenever an instance of a class is created, a function must be explicitly called by the user. <STOP>
2.3 constructors cannot return values, so they cannot specify a return type like functions can. <STOP>
2.3 A constructor is a function used to initialize an object 's data when it is created. <STOP>
2.3 a constructor initialises everything so that nothing is left empty or with random varioubles and a function modifies those variables with data. <STOP>
2.3 A constructor initialized values at the execution of its instantiation. <STOP> It provides default values. <STOP>
2.3 A constructor sets up the default values of variables when an object is instantiated, whereas a function allows interaction with that object. <STOP>
2.3 A constructor is used to create an object that can be employed in the main function of a program. <STOP> This may or may not execute code along with it. <STOP> A function is a set of code that executes when called, but does not create a new object. <STOP>
2.3 a constructor initializes data members but the functions actually perform tasks. <STOP> Constructors cant return values either. <STOP>
2.3 a constructor does not need a type, and it is used to initialize the variables. <STOP>
2.3 Constructors do not have a return type. <STOP>
2.3 constructor creates the class object into memory where functions perform actions against that object <STOP>
2.3 constructors cannot return values <STOP>
2.3 A constructor initializes values and a function usual performs some sort of operation. <STOP>
2.3 A constructor is a function used to initialize an object 's data when it is created. <STOP> It is call is made implicitly when the object is created and must be defined with the same name as the class. <STOP> Constructor also cannot return a value like a function can. <STOP>
2.3 A constructor is used to create an instance of a class and has the same name as that class. <STOP> A function cannot have the same name as a class and computes data. <STOP>
2.3 a constructor is a function that initializes a class instance, a function performs whatever task it is written for <STOP>
2.3 A constructor cannot return values, not even void, but function get a return value. <STOP>
2.3 a constructor cannot return values, its not even void. it is used to initialize an object 's data when it is created. whereas, a function is created to do a specific task, and it can return values. <STOP>
2.3 A constructor initializes an object. <STOP> A function is part of an object. <STOP>
2.3 constructors initialize the data that is then used in the calculations of a function <STOP>
2.3 a constructor is called when the class is created, a function can be called any time. <STOP>
2.3 constructor is a special block of statements called when an object is created, either when it is declared statically or constructed on the stack. <STOP> However a function is a portion of code within a larger program, which performs a specific task and independent to the rest of the code. <STOP>
2.4 The compiler creates a default constructor when we do not define one in our class file <STOP>
2.4 during compilation <STOP>
2.4 When the class does not explicitly include a constructor. <STOP>
2.4 When no parameters are set is when a default constructor is used. <STOP>
2.4 When a class does not explicitly include a constructor. <STOP>
2.4 When there are no arguments passed. <STOP>
2.4 when there is not one already for a specific class <STOP>
2.4 When it the programs compiles <STOP>
2.4 when a constructor is not provided by the programmer of the class <STOP>
2.4 In any class that does not explicitly include a constructor. <STOP>
2.4 Before the main function of the code. <STOP>
2.4 whenevery you dont specifiy your own <STOP>
2.4 When non are provided <STOP>
2.4 C plus plus will create a default constructor when no other constructor is present. <STOP>
2.4 When no constructor was specified in the constructor 's class, but the class is instantiated in a program. <STOP>
2.4 When no constructor exists when one is needed, a parameterless default constructor is declared. <STOP>
2.4 The Compiler creates this automatically for you, unless you specifically create one. <STOP>
2.4 In any class that does not explicitly include a constructor. <STOP>
2.4 when no user-defined constructor exists <STOP>
2.4 If a class does not explicitly include a constructor, the compiler creates one. <STOP>
2.4 When you do not provide your own constructor. <STOP>
2.4 When a class does not explicitly include a constructor. <STOP>
2.4 C plus plus creates a default constructor during compilation if one is not provided. <STOP>
2.4 when a class does not explicitly include a constructor <STOP>
2.4 The compiler will provide one when class does not explictly include a consructor. <STOP>
2.4 when the programmer does not explicitly include a constructor <STOP>
2.4 When one is not explicitly stated. <STOP>
2.4 when one is not explicitly included by a class <STOP>
2.4 When you dont specify any constructors. <STOP>
2.4 at the very beginning when you run a complier, matter a fact in C plus plus it generates its own default constructor for the class provided if no other constructors have been provided by user <STOP>
2.5 Just one per class. <STOP>
2.5 As many as you want so long as they have different parameters. <STOP>
2.5 There is no limit to the number of constructors in a class because like functions, constructors can be overloaded. <STOP>
2.5 It depends what type of class is being defined. <STOP> Typically you would have a constructor call for each object. <STOP>
2.5 In C plus plus, the constructor can be overloaded in that there can be more than one constructor for a class, each having different parameters. <STOP>
2.5 1 <STOP>
2.5 any number you want <STOP>
2.5 One <STOP>
2.5 by default just one, but they may be overloaded to create as many constructors as necessary <STOP>
2.5 as many as you want <STOP>
2.5 As many as you want, with different parameters. <STOP>
2.5 infinite <STOP>
2.5 as many as you need <STOP>
2.5 As many as are needed, depending on how many variables one wishes to directly modify or leave as default when instantiating an object. <STOP>
2.5 A very large amount of constructors can be created for any given class through overloading. <STOP> When two constructors with a different type or number of parameters are created, they are said to be overloaded, and C plus plus can recognize which constructor to use based on the type of the variables that are passed or returned. <STOP>
2.5 It depends on the number of objects. <STOP> Each object should have a constructor. <STOP>
2.5 Theoretically unlimited, as long as they are defined by the programmer. <STOP>
2.5 As many as needed. <STOP>
2.5 as many as wanted or needed <STOP>
2.5 several <STOP>
2.5 One <STOP>
2.5 one <STOP>
2.5 There can be infinite constructors as long as the signature is different. <STOP>
2.5 that depends on the number of data members in the class <STOP>
2.5 one <STOP>
2.5 you can overload constructors as you need <STOP>
2.5 As many as the programmer wants to create. <STOP>
2.5 one <STOP>
2.5 as many as you want, as long as they each have a unique argument list <STOP>
2.5 as many as the user decides to use. <STOP>
2.6 A function definition does not require any additional information that needs to be passed inside its parenthesis to execute. <STOP> While a definition prototype requires more than one parameters to be passed in order to complete its task. <STOP>
2.6 The FUNCTION PROTOTYPE is where the programmer declares that he or she is using a function other than main -LRB- -RRB- . <STOP> This is like declaring a variable, the programmer knows that he or she will be using in the future, but has yet to say where they are going to use it, or how. <STOP> This is answers the question who, it gives the function a name and character. <STOP> The function prototype, by common practice is placed at the beginning of the program after the includes and before main -LRB- -RRB- . <STOP> The FUNCTION DEFINITION is the guts of the function. <STOP> This is where the programmer decides what the function is going to do and tells it how to do it. <STOP> It takes whatever information it is given and performs the operations. <STOP> It works sort of like the brain, the brain takes in input and based upon that input performs in some way producing an output. <STOP> The function defintion is placed outside of main -LRB- -RRB- and any other functions. <STOP> A function is its own entity and should be thought of as such. <STOP>
2.6 A function prototype tells the compiler the function name, return type and the number and type of parameters without revealing the implementations contained in the function definition. <STOP>
2.6 Function prototype is a declaration. <STOP> Function definitions -LRB- with multiple parameters -RRB- often require more than one piece of information. to perform their tasks. <STOP>
2.6 A function prototype is a declaration of a function that tells the compiler the function 's name, its return type and the types of its parameters. <STOP>
2.6 A prototype shows only return types and necessary parameters. <STOP> The definition includes names for those parameters and defines what the object is actually capable of doing. <STOP>
2.6 prototype only tells the user what data types go into a function and what type is returned. <STOP>
2.6 Function prototype is located in the. h file and only contains the access function name and paramater type. <STOP> Function definition contains the code for the function to perform its activity. <STOP>
2.6 a function prototype is used to reference the compiler to a function that will be defined later on, a function definition is the actual function itself, complete with return type, parameters, etc ... <STOP>
2.6 A function prototype describes a class 's public interface without revealing the class 's member function implementations <STOP>
2.6 Function definitions are just that, the definition. <STOP> The prototype is what the compiler uses to check that calls to function are correct. <STOP>
2.6 a prototype does not include any actual code where the function has all the code that is executed in the program. <STOP>
2.6 a prototype declares what will be used in the program and the definition <STOP>
2.6 A function prototype lays out the name, return type, and the number and types of parameters the function expects to receive in a certain order. <STOP> The details for function prototypes are in the function definition. <STOP>
2.6 A function definition is the code that defines the function placed in the brackets that determines that function 's operation. <STOP> A function prototype shows the function 's public interface without exposing implementation. <STOP> It shows name, return type and type of paramaters. <STOP>
2.6 A function prototype is just a declaration of the function existing, and cant be used as an actual function. <STOP> A function has to be created with a definition within to tell the compiler what the function does. <STOP>
2.6 the Prototype creates a framework to call the function definition. <STOP> While a function definition is where the function is actually programmed out and created into a final product. <STOP>
2.6 A function prototype describes the class 's public interface without providing how the function works. <STOP> A function definition contains the inner workings of the function. <STOP>
2.6 prototype states all functions in that class before compilation, where the definition actually holds the source for the functions <STOP>
2.6 Function prototypes tell the compiler the function names, its return type, and the types of its parameters where as, function definitions actually implement the member functions. <STOP>
2.6 A function prototype just specifies parameters. <STOP> A function definition includes parameters and a code body. <STOP>
2.6 Function prototypes describe the class 's public interface <STOP>
2.6 A prototype only declares name, return type, and input type. <STOP> A definition also defines the scope, variables, process, and return function <STOP>
2.6 a function prototype simply declares the functions parameters, the function definition includes any necessary variables and the function 's actual code <STOP>
2.6 A functgion prototype is a declaration of a function, while function definition specifies what a function does <STOP>
2.6 in a function prototype you include the return type, the name of the function, and its parameters if any are needed. in a function definition you write the code of what the function will do. <STOP>
2.6 A function definition contains all the code for a function to work. <STOP> A function prototype just shows the output, input and function name. <STOP>
2.6 function prototype describe the class 's public interface without revealing the class 's member function implementations, function definitions show what implementations are being done <STOP>
2.6 A function prototype only names the function, its return type, and it is argument list, while a definition defines the above as well as what the function actually does. <STOP>
2.6 function prototype describes a classes interface without reviling whatever is inside as for the function definition cannot do that. <STOP>
2.7 the role of a header file list all the functions a class can do while hiding the inner workings of its functions <STOP>
2.7 The main role of header file is it is used to share information among various files. <STOP>
2.7 Header files separate files in which classes are defined and allow the compiler to recognize classes when used elsewhere. <STOP>
2.7 No <STOP>
2.7 A header file consists of "reusable" source code such as a class in a file that by convention has a. h filename extension. <STOP> This differs from. cpp files that contain "source-code." <STOP>
2.7 To provide information about the contents of a library. <STOP> It includes the definition of classes, declarations of functions, data types, and constants. <STOP>
2.7 the header file shows the user what types go into and come out of a function but does not allow a user to manipulate the actual code for the function. <STOP>
2.7 Header files declares the class member functions. <STOP>
2.7 A header file allows for the separation of declaration and implementation into separate files. <STOP>
2.7 the header file has access to the C plus plus Standard Library and makes certain classes like class string work. <STOP>
2.7 Instruct the compiler on how to interface with library and user-written components. <STOP>
2.7 create a comon area to contain reusable functions. <STOP>
2.7 to declare the functions being used in the classes <STOP>
2.7 include "hat. h" allows the use of the hat container, so called from the act of pulling names from a hat. <STOP> The header file for hat includes functions for storage and retrieval of it is contents, mainly put -LRB- -RRB- , peek -LRB- -RRB- , and pull -LRB- -RRB- . <STOP>
2.7 To hold reusable content or modules separate from the actual source-code file that can be easily referenced and employed for different programs. <STOP>
2.7 a header file is a file used to store a list of prototye functions and data members. <STOP>
2.7 A header file is a cross communication method between source files, to help limit the size of each individual program. <STOP> Without header files a program will be 1 large lump of code and thus fairly hard to debug and traverse. <STOP>
2.7 It contains reusable source code for use by other classes. <STOP>
2.7 to separate the source code from the main function, allows the methods or classes to be included in the program without direct coding. allows re usability. <STOP>
2.7 Header files have reusable source code in a file that a programer can use. <STOP>
2.7 To hide the definition and details of a class. <STOP> Also to help readability of the main C plus plus file. <STOP>
2.7 To allow the compiler to recognize the classes when used elsewhere. <STOP>
2.7 A header file declares a class, its data, and functions available through that class. <STOP>
2.7 header files contain code which can be used in multiple files <STOP>
2.7 Allow compiler to recognize the classes when used elsewhere <STOP>
2.7 Allow compiler to recognize the classes when used elsewhere <STOP>
2.7 To promote function reusuablitly <STOP>
2.7 class definitions are placed here <STOP>
2.7 A header file usually contains class and function prototypes. <STOP>
2.7 contains all the standard C plus plus library 's i. e. string <STOP>
3.1 It includes the name of the program, the type of parameters it can take. <STOP> It should also include a brief description of what the function does. <STOP>
3.1 it includes the specific information about the function such as input and output variable types and how many of each. <STOP>
3.1 The function signature includes the name of the function and the types of its arguments. <STOP>
3.1 A function signature consists of the function prototype. <STOP> This tells you the general information about a function, its name, parameters, what scope it is in, and other miscellaneous information. <STOP>
3.1 It includes the name of the function and the types of its arguments. <STOP>
3.1 Name, paramaters, scope, and other general function information <STOP>
3.1 It includes a function name and parameter list. <STOP> Does not include return type. <STOP> Function signatures must be different. <STOP>
3.1 input parameters and return type <STOP>
3.1 The portion of the function prototyp tha has the function name and the arguments but NOT the return type. <STOP>
3.1 Name of the function and the types of it is arguments <STOP>
3.1 The name of the function and the types of its arguments. <STOP>
3.1 Includes the name of the function and the types of its arguments. <STOP>
3.1 identification of a function and the data types of its parameters, it has the name, and the data type variables <STOP>
3.1 a return type, and input parameters <STOP>
3.1 The function signature includes the method name and the input types. <STOP>
3.1 A function signature includes the name of the function and types of arguments, but not the return type. <STOP>
3.1 The signature can include a result type and thrown errors. <STOP>
3.1 function name, and input paramaters <STOP>
3.1 The name of the function and the types of its arguments. <STOP> This includes the number, type, and order the parameters appear in. <STOP>
3.1 the name of the function and the types of its arguments <STOP>
3.1 A function signature includes the name of the function and the types of its arguments <STOP>
3.1 A function signature includes a function 's return type, parameters and semi-colon. <STOP>
3.1 the name of the function and the types of its arguments <STOP>
3.1 the function 's name and parameters <STOP>
3.1 The name of the function and the types of its arguments. <STOP>
3.1 The portion of a function prototype that includes the name of the function and the types of its arguments <STOP>
3.1 the name of the function and its parameters <STOP>
3.1 The function name and parameters <STOP>
3.1 name of function and types of arguments <STOP>
3.1 a function 's return type and parameter list <STOP>
3.1 it includes the name of the function, and the types of its arguments. it does not specify the function return type. <STOP> Function in the same scope must have unqiue signatures. <STOP>
3.2 Any functions that follows their deceleration that are in the source code file are allowed to have access the variables. <STOP> Also global scope variables retrain their value throughout the execution of the program. <STOP>
3.2 they can be accessed by any C plus plus file anywhere. <STOP>
3.2 Global variables have file scope. <STOP>
3.2 The scope of global variables are created by placing variable declarations outside any class or function definition. <STOP> Global variables retain their values throughout the execution of the program and they can be referenced by any function that follows their declarations or definitions in the source file. <STOP>
3.2 A global variable is an identifier that retains it is value throughout the execution of the program. <STOP> It has file scope. <STOP>
3.2 Global Variables can be used in any function as long as the appropriate. h file that holds the variable is included <STOP>
3.2 They can be accessed by any part of the program. <STOP> It can be referenced by any function that follows the declarations or definitions in the source file. <STOP>
3.2 can be accesed by any classes that have and object of that variables class in it <STOP>
3.2 Global variables have file-scope. <STOP> The variable is know to all functions throught the file <STOP>
3.2 The entire program <STOP>
3.2 They have file scope when placed outside a function. <STOP>
3.2 File scope. <STOP>
3.2 They can be used throughout the program <STOP>
3.2 Global variable can b accessed by any class wit an object in the variables class <STOP>
3.2 The scope of global variables is at the file level. <STOP>
3.2 Global variables all have file scope. <STOP>
3.2 it is accessible by all functions within a program <STOP>
3.2 variables accessible anywhere in the program, as long as they are public. <STOP>
3.2 They can be referenced by any function following their declaration or definition inside the source file. <STOP>
3.2 globally, anywhere in the program. <STOP>
3.2 Global variables have a file scope <STOP>
3.2 The entire program. <STOP>
3.2 throughout the execution of the program <STOP>
3.2 If a variable is declared global, any function or class can use that variable. <STOP>
3.2 The entire program or file. <STOP>
3.2 throught the programm <STOP>
3.2 the whole code <STOP>
3.2 File scope <STOP>
3.2 can be referenced by any function that follows their declarations or definitions in the source file <STOP>
3.2 global variables have program scope -LRB- accessible anywhere in program -RRB- <STOP>
3.2 variables that exist throught the entire script. their values can be changed anytime in the code and fucntions. <STOP>
3.3 It expands the function 's definition in that place. <STOP> Once the functions is called you can use it as many times as you need. <STOP> The compiler just expands on the function. <STOP>
3.3 When the compiler inline-expands a function call, the function 's code gets inserted into the caller 's code stream -LRB- conceptually similar to what happens with a define macro -RRB- . <STOP> This can, depending on a zillion other things, improve performance, because the optimizer can procedurally integrate the called code optimize the called code into the caller. <STOP>
3.3 The inline keyword advises the compiler to copy the function 's code in place to avoid function calls; however the compiler can and typically does ignore the inline qualifier for all but the smallest functions. <STOP>
3.3 The compiler can ignore the inline qualifier and typically does so for all but the smallest functions. <STOP>
3.3 Placing the qualifier inline before a function 's return type in the function definition "advises" the compiler to generate a copy of the function 's code in place to avoid a function call. <STOP>
3.3 You declare your inline function in the header or before your int main -LRB- -RRB- . <STOP> You then can call that function at anytime in your main program quickly and easily. <STOP>
3.3 It expands a small function out ... making your code longer, but also makes it run faster. <STOP>
3.3 the function is not treated as a separate unit like other functions <STOP>
3.3 When the program compiles, it will copy the function inplace, avoiding a function call. <STOP>
3.3 It replaces all instances of that function call with the inline code itself, resulting in longer but faster programs. <STOP>
3.3 The compiler can ignore the inline qualifier and typically does so for all but the smallest functions. <STOP>
3.3 Ignores the inline qualifier and typically does so for all but the smallest functions. <STOP>
3.3 If the function is small enough it will expand it but it will run faster as it will avoid making so many calls to the function. <STOP>
3.3 it treats them as the same function <STOP>
3.3 Inline functions are copied in place, instead of being referenced. <STOP>
3.3 For inline functions, the compiler creates a copy of the function 's code in place so it does not have to make a function call and add to the function call stack. <STOP>
3.3 it generates a copy of the function 's coding which eliminates calling the function <STOP>
3.3 not answered <STOP>
3.3 It generates a copy of the function 's code by by inserting it in the program. <STOP>
3.3 tells the compiler to make a copy of function 's code in place to avoid a function call. it typically ignores it, except for the smallest functions. <STOP>
3.3 The compiler can ignore the inline qualifier and typically does so for all but the smallest functions. <STOP>
3.3 Multiple copies of the function code are inserted into the program, making it bigger. <STOP>
3.3 compiler ignores inline qualifier <STOP>
3.3 It generates a copy of the function, if it is needed again. <STOP>
3.3 The complier includes copies of inline functions instead of making function calls, but usually only with very small functions. <STOP>
3.3 Compiler generate a copy of the function 's code in place -LRB- when appropriate -RRB- to avoid a function call <STOP>
3.3 instead of calling the function every time it is invoked, the compiler will replace the function call with a copy of the function body <STOP>
3.3 Expands the function into the program <STOP>
3.3 it generates a copy of the functions code in place to avoid a function call <STOP>
3.3 the function call will be replaced by the code that was defined in the inline function <STOP>
3.3 When the compiler inline-expands a function call, the function 's code gets inserted into the caller 's code stream -LRB- conceptually similar to what happens with a define macro -RRB- . <STOP> This can, depending on a zillion other things, improve performance, because the optimizer can procedurally integrate the called code optimize the called code into the caller. <STOP>
3.4 Overall the program has better performance -LRB- means it is faster -RRB- because it does not have to copy large amounts of data. <STOP>
3.4 because you cannot change the original and passing by reference limits memory needed for the program. <STOP>
3.4 Passing by reference can eliminate the pass-by-value overhead of copying large amounts of data. <STOP>
3.4 It is often more efficient to pass references, rather than large objects, to functions. <STOP> This allows the compiler to pass the address of the object while maintaining the syntax that would have been used to access the object. <STOP>
3.4 Pass by reference is good for performance reasons, because it can eliminate the pass by value overhead of copying large amounts of data. <STOP>
3.4 You do not alter the original value of the variable that was passed. <STOP>
3.4 Do not have to make copies of stuff. <STOP>
3.4 you do not use unessesary memory space to copy variables between functions <STOP>
3.4 It elimitates the need to copy large amonts of data <STOP>
3.4 The function can change the data stored in a variable passed by reference directly. <STOP>
3.4 Gives called function the ability to access and modify the caller s argument data. <STOP>
3.4 Gives called function the ability to access and modify the caller s argument data directly. <STOP>
3.4 It is more efficient and it changes the variable not online inside the function but outside so that the new value can be used elsewhere. <STOP>
3.4 you do not make another copy and waste memory <STOP>
3.4 Passing by reference eliminates the copying of large amounts of data, typical with pass by value. <STOP>
3.4 If a function 's arguments are large in size, computing time and memory space is not wasted copying down the argument and passing it to the function. <STOP> Also pass by reference gives the function called the permission to read edit the argument directly. <STOP>
3.4 Gives access to the caller data directly, also it allows for modifying the data. <STOP>
3.4 less overhead overall, and you modify the variable directly. <STOP>
3.4 The original variable being referenced can be modified directly by the called function. <STOP>
3.4 gives function ability to access and modify the caller 's argument data directly <STOP>
3.4 Gives the called function the ability to access and modify the caller 's argument data directly. <STOP>
3.4 Less overhead than passed by value, especially when using large numbers. <STOP>
3.4 large data items can be passed without copying the entire data point, reducing execution time and the amout of memory space needed <STOP>
3.4 The data can be modified directly instead of making a copy of the data. <STOP> Improves execution time with large amounts of data. <STOP>
3.4 Functions can directly modify arguments that are passed by reference. <STOP>
3.4 It gives access and modify the caller 's argument data directly. <STOP> It eliminate the pass by value overhead of copying large amounts ofdata <STOP>
3.4 it takes less memory, thus it would make the program faster <STOP>
3.4 You are able to modify the variable that is referenced directly. <STOP>
3.4 if you pass by reference, you can modify the value as opposed to passing by value where you cannot change the value <STOP>
3.4 only the memory address is sent to the function, so no copy of the object sent needs to be made. <STOP> It makes the function run faster, and saves memory. <STOP>
3.4 Actual arguments are associated with dummy arguments when a function or subroutine is referenced. <STOP> In a procedure reference, the actual argument list identifies the correspondence between the actual arguments provided in the list and the dummy arguments of the subprogram <STOP>
3.5 The compiler selects the proper functions to execute based on number, types and order of arguments in the function call. <STOP>
3.5 They differentiated by the compiler by the conditions or inputs used for one of the overloaded functions. <STOP>
3.5 The compiler distinguishes overloaded functions by their signatures. <STOP> It encodes each function identifier with the number and types of its parameters to generate type-safe linkage, which ensures the proper overloaded function is called. <STOP>
3.5 Overloaded functions are distinguished by their signatures, Name mangling or name decoration, and type-safe linkage ensures that proper overloaded functions is called and types of the arguments conform to tpes to the parameters. <STOP>
3.5 The compiler selects proper function to execute based on number, types and order of arguments in the function call. <STOP>
3.5 By the type they are initilized with -LRB- int, char, etc. -RRB- <STOP>
3.5 It selects the proper function to execute based on number, types and order of arguments in the function call. <STOP>
3.5 overloaded functions must have the same return type but different input parameters <STOP>
3.5 It examines the names, types, and order of arguments on each function. <STOP>
3.5 unique function signatures <STOP>
3.5 Is based on number, types, and order of arguments in the function call. <STOP>
3.5 Compiler selects proper function to execute based on number, types and order of arguments in the function call. <STOP>
3.5 not answered <STOP>
3.5 they have to have same return type, but different input parameters <STOP>
3.5 Overloaded functions are differentiated by their parameters. <STOP>
3.5 The compiler selects the right function to execute from the number, types and order of arguments in the function call. <STOP>
3.5 it creates a set of candidate functions then a set of viable functions <STOP>
3.5 their function signature. <STOP>
3.5 The number and type of its parameters. <STOP>
3.5 by their function signature <STOP>
3.5 They have the same name, just different parameters. <STOP>
3.5 They are differntiated by number, types and order of arguments in the function call. <STOP>
3.5 it looks at the number, types, and order of arguments in the function call <STOP>
3.5 The compiler differentiates overloaded functions by their signature. <STOP>
3.5 By the number, types, and order of their arguments <STOP>
3.5 Compiler selects proper function to execute based on number, types and order of arguments in the function call. <STOP>
3.5 paremeters <STOP>
3.5 By the number, and the types and order of the parameters. <STOP>
3.5 by the number and type of arguments <STOP>
3.5 by their signature -LRB- return type, argument list -RRB- <STOP>
3.5 overloaded function simply invovles haing a method with the same name within the class. is used to implement a method for subclass which overrides in other words replaces the implementation of the super class. <STOP> Overloading the concept of providing different meaning to a object based on the context of its presence. <STOP> Overloading is one type of polymorphism and this is also a feature in programing. <STOP>
3.6 A base case that is the simplest case for a problem so that the function will lead to it, if this does not happen then it will end up as an infinite loop. <STOP> And a condition to know when to terminate. <STOP>
3.6 badly designed algorithyms. using recursion for a non recursive problem. <STOP>
3.6 Infinite recursion can occur when the base case is omitted or the recursion step is written incorrectly so that it never converges on the base case. <STOP>
3.6 Infinite recursion is an infinite loop if the condition is not met. <STOP> Either omitting the base case, or writing the recursion step incorrectly so that it does not converge on the base case causes "indefinite" recursion, eventually exhausting memory. <STOP>
3.6 Either omitting the base case or writing the recursion step incorrectly so that it does not converge on the base case can cause an infinite recursion. <STOP>
3.6 Not having a base case that returns a base value. <STOP>
3.6 Incorrect or missing base case. <STOP> Must reduce to the base case. <STOP> The function must get simpler each time it is run -LRB- converge to the base case -RRB- . <STOP>
3.6 no base case no change in values. <STOP>
3.6 If at each recursive call the problem does not diminish or if it does not diminish to a base case, can cause infinite recursion. <STOP>
3.6 Omitting the base case or incorrectly calling the recursive step. <STOP>
3.6 The recursive problem cannot be reduced to reach the base case. <STOP>
3.6 Lack of defining a base case, or writing the recursion step incorrectly so that it does not converge on the base case <STOP>
3.6 Not having the proper case to leave the recursion <STOP>
3.6 no base case, or the recursive calls do not converge to the base case <STOP>
3.6 No base case, or an incorrectly written recursion step that does not converge on the base case will lead to infinite recursion. <STOP>
3.6 If the recursion function never reaches or successfully defines the base case it will recurse forever. <STOP> This happens many ways, such as the function does not progress towards the base case, or the function is coded poorly and does not even contain a base case. <STOP>
3.6 not creating a base case, or in the case where the base case will never be met. <STOP>
3.6 improper handling of cases such that not all possible values are able to be handled. <STOP>
3.6 There is no base case. <STOP> The recursion step does not reduce the problem during each recursive call. <STOP>
3.6 no base case, as in a single return that does not include calling the function again. a static value to end at. <STOP>
3.6 Either omitting the base case, or writing the recursion step incorrectly so the it does not reach the base case can cause infinite recursion. <STOP>
3.6 omitting the base case or writing the recursive call so that it does not converge upon the base case. <STOP>
3.6 Either omitting the base case, or writing the recursion step incorrectly so that it does not converge on the base case <STOP>
3.6 Infinite recursion may occur if no base case is defined or if the call is not varied. <STOP>
3.6 Not having a base case, or building a recursion process that does not converge on the base case. <STOP>
3.6 Either omitting the base case, or writing the recursion step incorerectly <STOP>
3.6 no base case or if the programmar does not define the base case as the simplest case and it never gets reached <STOP>
3.6 No easily reached base case and no base case at all <STOP>
3.6 function is never allowed to reach the "base case" <STOP>
3.6 it has no base case, or the base case is never met <STOP>
3.6 recursion refers to situations in which functions call themselves. <STOP> These types of functions are known as recursive functions. <STOP> That being said Infinite recursion occurs when the function is designed in such a way as to call it self forever without stopping possible causes <STOP>
3.7 Both involve a controlled repetition structures, and they both have a termination test. <STOP> Also both of them can loop forever. <STOP>
3.7 As discussed earlier, recursion may be used to process iterative actions. <STOP> Recursion is used for calculations where the answer can be described in a function that relates to itself. <STOP>
3.7 Both iteration and recursion are based on control statements and involve repetition. <STOP> They can both also occur indefinitely. <STOP>
3.7 Both are based on a control statement <STOP> Iteration-repetition structure <STOP> Recursion-selection structure <STOP> Both involve repetition <STOP> Iteration-explicitly uses repetition structure <STOP> Recursion-repeated function calls <STOP> Both involve a termination test <STOP> Iteration-loop-termination test <STOP> Recursion-base case <STOP> Both gradually approach termination <STOP> Iteration-modifies counter until loop-termination test fails <STOP> Recursion-produces progressively simpler versions of problem <STOP> Both can occur indefinitely <STOP> Iteration-if loop-continuation condition never fails <STOP> Recursion-if recursion step does not simplify the problem <STOP>
3.7 Iteration and recursion have many similarities: both are based on a control statement, involve repetition, involve a termination test, gradually approach termination and can occur infinitely. <STOP>
3.7 Both rely on repetition, both have a base case, both can become an infinite loop. <STOP> Anything recursive can also be solved with iteration. <STOP>
3.7 Both will repeat -LRB- loop -RRB- until a condition is met, and exit the loop. <STOP> Both are capable of entering an infinite loop. <STOP>
3.7 anything you can do iterativly you can do recursively <STOP>
3.7 Both are repetative and both have a end test. <STOP>
3.7 Incorrectly writing either can result in infinite loops, both perform the same task over and over. <STOP>
3.7 Both are based on a control statement. <STOP> Both involve repetition. <STOP> Both involve a termination test. <STOP> Both gradually approach termination. <STOP> Both can occur infinitely. <STOP>
3.7 Both are based on a control statement, Both involve repetition, Both involve a termination test, Both gradually approach termination, Both can occur infinitely <STOP>
3.7 not answered <STOP>
3.7 anything you can do recursively you can do iteratively <STOP>
3.7 Many problems can be solved by both iteration and recursion, and either may go into a condition of infinite execution if a termination test is omitted. <STOP>
3.7 Iteration and recursion both use repetition and perform several simple operations and algorithms successively until they reach a certain limit. <STOP> So both involve a termination test to find that limit and both slowly approach that termination limit. <STOP> Both are based on a control statement as well. <STOP> If coded poorly, both can continue on for forever until the compiler or the computer either locks up, shuts down or halts the operation. <STOP>
3.7 both based on control statement, involve repetition, and involve a termination test within loops <STOP>
3.7 they are methods of repeating the same task. <STOP>
3.7 Both involve a termination test. <STOP> They use a control statement and repition to solve the problem. <STOP> They can also result in an infinite loop. <STOP>
3.7 based on a control statement, involve repetition, involve a termination test. <STOP>
3.7 Both are bases on a control statement. <STOP> Both involve repetition. <STOP> Both involve a termination test. <STOP> Both gradually approach termination. <STOP> Both can occur infinitely. <STOP>
3.7 both based on a control statement, both involve repitition, both involve a termination test, both gradually approach termination, both can potentially occur infinetly. <STOP>
3.7 they are both based on a control statement, both involve repetition, both involve a termination case, both graduatlly approach that termination case, and both can occur infinitely <STOP>
3.7 They both use repetition, a control or test to terminate, and both can infinitely repeat if not defined correctly. <STOP>
3.7 Both are based on a control statement; both gradually approach termination ending with a termination test; both involve repetition, and can both repeat infinitely if their termination requirements are not met. <STOP>
3.7 both are based on a control statement, involve repetition and involve a termination test. both gradually approach termination, both can occur infinitely <STOP>
3.7 they are used to solve the same type of problems. they do a task over and over again until a cirtain conditional statement is reached -LRB- its called the base case in recursion -RRB- . <STOP>
3.7 Based on control statement; involve repetition; involve a terminal test; both can occur infinitly <STOP>
3.7 repetition, termination test, eventually terminate, occur infinately <STOP>
3.7 both need to have some kind of base case to tell when the loop needs to stop. <STOP>
3.7 they both are able to do repetiive tasks. however recurisve calls itself with different parameters and defines and exit clause that is guaranteeed to be reached. <STOP> Iterative includes a loop which iterates a pre-determined number of times, or checks for an exit clause every time through <STOP>
4.1 int n [10]; or or array of 10 integers and int n [arraySize] or or where arraySize is some positive integer defined by the user <STOP>
4.1 by either inputing the different elements in the array at coding or giving the array specifacations as to the size of the array. it is also possible when giving it specifacations to tell the array to grow as needed. <STOP>
4.1 You can initialize and array by using an initializer list in its declaration or by initializing its size with a constant variable. <STOP>
4.1 Pass the length along with the array or use a vector. <STOP>
4.1 One way is to declare a size of the array using a variable that is equal to an integer. <STOP> The other way, if the size is omitted in the declaration, the compiler determines the size of the array based on the size of the initializer list. <STOP>
4.1 In the declaration -LRB- int array [x] -RRB- or with an initilizer -LRB- int array [] equals 0,1,2, etc. <STOP>
4.1 1. Declare the length of the array -LRB- int array [10]; -RRB- <STOP> 2. Initialize the array -LRB- int array [] equals 0, 1, 2, 3; or or compiler will assume size of 4 -RRB- <STOP>
4.1 statically and dynamically <STOP>
4.1 Explicitly int array [10]; or by variable const int size equals 10; int array [size]; <STOP>
4.1 Array lengths can be explicitly specified by inputing the number of elements between the brackets [] during declaration, or implicitly by including an initializer list WITHOUT specifying a number between [], the compiler will automatically declare the array with the proper number of elements needed for the list. <STOP>
4.1 Specify an array s size with a constant variable. <STOP> And setting array elements with calculations. <STOP>
4.1 statically, using and dynamically, using [] <STOP>
4.1 define it as array [5] or array [1,2,3,4,5] <STOP>
4.1 Static and dynamic. <STOP>
4.1 manually inside the brackets or automatically via an initializer list <STOP>
4.1 You can use an initializer list, or simply tell the compiler how many elements you want in the array. <STOP> For an Initializer list: int a [] equals 10, 2, 3, 4, 5; <STOP> For an elemental declaration: int b [5]; <STOP> Both arrays have 5 elements in them, but array a is already initialized. <STOP>
4.1 In a string you can specify with the strlen -LRB- arrayname -RRB- command. <STOP> This gets the length of the string. <STOP> Another way is with integers where you initiate the size from the start, ex array [40] specifying a possible length of up to 40. Then it is passed by an object the actual ammout in the array. <STOP> Another way is to declare it in an initializing program. <STOP>
4.1 Implicit, namely when you give it values, like 1,2,3,4,5,6,7,8,9, at which the compiler will automatically give this a size. <STOP> Static, during the declaration. <STOP>
4.1 Supply an integer inside the brackets or the compiler counts the number of elements in the initializer list. int n [5]; int n [] equals 1,2,3,4,5 <STOP>
4.1 either initializing the array with a specific length or initializing an array while declaring its contents. <STOP>
4.1 within the brackets or by using an initializer list. <STOP>
4.1 specify the number of elements in the array declaration with a constant or using a constant variable for future scalability <STOP>
4.1 with a number and with a variable <STOP>
4.1 explicitly, by declaring it in brackets -LRB- i. e. int array [50]; -RRB- and implicitly, by initializing several values -LRB- i. e. int array [] equals 1, 2, 3; -RRB- <STOP>
4.1 one way of specifying of array is A [10]; other way of specifying array is a [arraysize] equals [1,2,3,4,5,6,7,8,9,10 <STOP>
4.1 1-Initializing an array in a declaration with an initializer list <STOP> 2-Specifying an array s size with a constant variable <STOP>
4.1 Initializing the size in the brackets: int a [100]; <STOP> Initializing the length by assigning variables: int a [] equals 1,2,3; <STOP>
4.1 user defined value or by the number of elements in initializer list <STOP>
4.1 you can assign the size of it inside the brackets when you declare the array [3], or you can have it set by how many items you set the array equal to 1,2,3 <STOP>
4.1 use an arraylist, or have your program ask the array how many elements it has. <STOP> As an obj it it should have member length that is the number of slots it has. <STOP>
4.2 strings that are used in an char array are much easier to manipulate than as a string object, because each character is stored separately rather than as a whole <STOP>
4.2 the type string uses less storage and you have to change the string all at once. with an array of characters you can make permutations of words using the characters stored in the array, without needing to actually access and change the variables. with an array of characters you can just change how they are accessed. <STOP>
4.2 Unlike in a string declared using type string, in a string declared using an array of characters the programmer must provide the null terminating character and must ensure the array is large enough to hold the string and null terminating character. <STOP>
4.2 All strings represented by character arrays end with the null character. <STOP> You declare an object of type string just like any other type, for example: string s; <STOP>
4.2 By using an array of characters, one can store and manipulate the strings rather than just having a type string variable. <STOP>
4.2 type string is an array of chars that will make an array of single letter characters while an array of strings will be an actual array of words -LRB- or an array of char arrays -RRB- <STOP>
4.2 They are basically the same, however, a string ends with a null character, denoting the end of the string -LRB- and the size -RRB- . <STOP> A char array has potential to be any size, so it must be declared or limited. <STOP>
4.2 string is a class in the standard library and has method that modify it. <STOP> Whereas the char array is on able to be modifie by the user. <STOP>
4.2 By using an array of characters, you are limited to the size of the array of characters. <STOP> By declaring by type the end of the string is acknowledged by white space. <STOP>
4.2 The data class type string are designed to handle character data, and has many functions built into the class library to deal with them. <STOP> An array of characters however is subject to all the same rules of any other array with no real additional functionality. <STOP> Another difference is that the string class deals with the null character implicitly, unlike an array of characters, which must handle the null character explicitly. <STOP>
4.2 string declared used in an array of characters contains each character in the array and a special string-termination character called the null character versus the type string. <STOP>
4.2 A char array reads a string as each individual character. <STOP> A string literal array reads the entire string. <STOP>
4.2 array of characters can only hold as many characters as the array size and strings are not that limited. <STOP>
4.2 Stings can only be modified by functions of the String class, an array of characters can be modified by the user <STOP>
4.2 if by type string, the array contains an additional terminating null character <STOP>
4.2 The array of characters has a null character 0 at the end of the array to signify the array 's end. <STOP> The string does not have this. <STOP>
4.2 strings with type string are just that. <STOP> Strings. <STOP> They are not part of an array list at all where as one declared by an array is actually an array of characters able to be pointed and detected. <STOP>
4.2 the array of characters has a set length, while the type string has virtually unlimited length. <STOP>
4.2 Char array Individual letters can be accessed directly with array subscript notation. <STOP> String array array subscript will return the entire string. <STOP>
4.2 array of characters need a termination character as well as size specification whether its explicit or implicit. <STOP>
4.2 when using an array individual characters can be accessed and manipulated. <STOP>
4.2 strings declared using an array of characters could result in data loss if character array not initialized large enough. <STOP>
4.2 an array is passed by reference therefore if an array of characters is changed, the memory is changed not just the variable <STOP>
4.2 the type string has several built-in functions not available when using a char array, but the individual characters in an array or more directly accessible than the characters in a string type string. <STOP>
4.2 declaring a string, it includes white spaces but declaring a array of character does not include white spaces <STOP>
4.2 an array of characters has one element a string doesnt have. it is the termination element, or "null" <STOP>
4.2 Strings declared using the type string can vary in length. <STOP> Strings declared using an array of characters can not extend past the array length. <STOP>
4.2 cant modify individual characters of a type string array, character type array can modify individual characters <STOP>
4.2 the type string is a class and is safer, while the other is just an array of characters. <STOP>
4.2 array it is the collection of similar data types ex: int a [10] ten indicates the size of array. <STOP> [] is index of array, we can give only integer values to array of a. where as string mean collection of group of characters. string declarations have a datatype usually causes storage to be allocated in memory that is capable of holding some predetermined number of symbols. <STOP> However Arrays can be declared to contain values of any non reference data type. <STOP> Multiple arrarys of the same type <STOP>
4.3 by reference only <STOP>
4.3 a reference pointer to an element in the array. <STOP>
4.3 Arrays are passed to functions by reference. <STOP>
4.3 Arrays are passed by reference <STOP> Individual array elements passed by value <STOP> Functions that take arrays as arguments <STOP> Function prototypes may include parameter names const array parameters <STOP>
4.3 Arrays are passed by reference. <STOP>
4.3 you must pass the array and its size to the function. <STOP> Ex. function -LRB- array, size -RRB- ; <STOP>
4.3 Usually the same way you pass anything else ... you do not have to specify the length of a char array, just pass it to the function by sending the name of the array. <STOP> Example: char str [20]; isPalindrome -LRB- str -RRB- ; or or this sends the char array to the function isPalindrome. <STOP> Otherwise, would need to send the length of the array as well. <STOP>
4.3 you pass a pointer to the first item and also pass the size. <STOP>
4.3 By reference. <STOP>
4.3 In two parts, the array itself, and it is size, so that the function it is being passed to can avoid out of bounds errors. <STOP>
4.3 Specify array name without brackets. <STOP> Array size is normally passed as another argument so the function can process the specific number of elements in the array. <STOP> Arrays are passed by reference. <STOP> Individual array elements passed by value. <STOP> Functions that take arrays as arguments. <STOP>
4.3 Arrays are passed by reference. <STOP>
4.3 the same way but with [] at the declaration and the actual function. <STOP>
4.3 specify the array name without brackets. <STOP>
4.3 by reference <STOP>
4.3 You pass the name of the array to the function. <STOP> So for: int bin [10]; you pass it to an array like so: jingle -LRB- bin -RRB- ; but jingle must be declared correctly in order to receive an array, either with prototype void jingle -LRB- int [] -RRB- ; or with the definition in its initialization: void jingle -LRB- int array [] -RRB- ; <STOP> It is also worth noting that arrays are passed to function by reference, so as to not copy large arrays over and over and burn memory. <STOP> This gives the function complete control over the array however. <STOP>
4.3 They are called by the function then the function must loop through the array to get the set of characters. <STOP>
4.3 by reference by default, unless you specify const, at which the later will make the array unmodifiable. <STOP>
4.3 The function recieves both the array and the array size as parameters. function -LRB- arrayName, arraySize -RRB- <STOP>
4.3 specifying array name and passing as reference in an argument into the function <STOP>
4.3 1st you must specify the array name without brackets and then the array name and size are passed as two arguments in the function call. <STOP>
4.3 arrays are passed by reference, passing the starting address of array. programmer specifies the array name without brackets and passes the array size as another argument so the function can process the specific number of elements in the array <STOP>
4.3 by reference only <STOP>
4.3 by reference <STOP>
4.3 by reference <STOP>
4.3 by refrence <STOP>
4.3 function -LRB- int [], int length -RRB- <STOP>
4.3 by reference <STOP>
4.3 by reference <STOP>
4.3 The function reads the variables, stores them. then returns the what ever the variable reads. <STOP> The function then prints the content of the array. <STOP>
4.4 a static array will store the new values that were assigned to each of its elements. meaning if you call a function twice it will use the last values that were returned the first time. if you do not declare it static then the new values will not be stored and will be reset to their original value <STOP>
4.4 a static array can only be referenced not accessed. <STOP> Also static arrays can be used without creating an object. <STOP>
4.4 An array declared as static is not created and and initialized each time the function and it is also not destroyed when the function terminates. <STOP>
4.4 A program intializes static local arrays when their declarations are first encountered. <STOP> If a static array is not initialized explicityly by the programmer, earch element of that array is intialized to zero by the compiler when the array is created. <STOP> Non-static array members cannot be initialized at all in C plus plus. <STOP>
4.4 Arrays that are static remain the same size throughout the program execution. <STOP>
4.4 a static array will only be initilized once, a non static array will be re-initilized once the program reaches the initilization line again. <STOP>
4.4 An array declared as static is available from beginning of program to end. <STOP> One with o static declaration disappears if it is not accessed within the right scope. <STOP>
4.4 a static array has pre-runtime size and that size cannot be changed. <STOP> A dynamic array gets its size at runtime. <STOP>
4.4 If an array is declared as static, it is not created each time the array is called. <STOP>
4.4 An array that is not declared as static will re-initialize every time the function declaring it is called. <STOP> A static array will initialize only once, at the declaration, and will store the values in it is elements throughout the duration of the program, even if the same function is called multiple times, a static array will only initialize once. <STOP>
4.4 All elements are initialized to zero if not explicitly initialized, this does not happen for automatic local arrays <STOP>
4.4 All elements are initialized to zero if not explicitly initialized for a static array, while a non-static array is not initialized to zero. <STOP>
4.4 static cannot be changed <STOP>
4.4 A static array has a set size that cannot change. <STOP> The data may not need all of the space assigned, or could go beyond the size. <STOP>
4.4 A static member prevents naming conflicts -LRB- not put into global namespace -RRB- while allowing for information hiding -LRB- private, public -RRB- . <STOP>
4.4 A static local array exists for the duration of the program and its elements are initialized to 0 if not explicitly initialized. <STOP> So a static local array 's elements will still be the same when called later unless specifically initialized to something else. <STOP> This does not happen for automatic arrays. <STOP>
4.4 Static arrays are those with a declared size, that is known to the program, whereas non-static arrays leave the size undeclared and open so it can be assigned later. <STOP> Usually used for input purposes. <STOP>
4.4 static arrays keep the values after the end of a function, while non static reinitialize every time. <STOP>
4.4 Static arrays are created and initialized only once, and the values are not destroyed when the function terminates in the program. <STOP> Automatic arrays reset everytime the function is called. <STOP>
4.4 its not created and initialized each time program calls the function, and is not destroyed every time the function ends in the program. <STOP>
4.4 When we declare it static the array is not destroyed after the function is over. <STOP> When an array is not declared as static, the array is created and initialized every time a function calls it. <STOP>
4.4 the static array exists for the duration of the program <STOP>
4.4 an array declared as static can only be declared once <STOP>
4.4 A static array exists in memory until the program terminates, whereas an automatic -LRB- or normal -RRB- array is removed when the function that created it terminates <STOP>
4.4 not answered <STOP>
4.4 Only constants can be used to declare the size of automatic and static arrays <STOP> Exists for the duration of the program <STOP> Is initialized when its declaration is first encountered <STOP> All elements are initialized to zero if not explicitly initialized <STOP>
4.4 A static array cannot be changed in the program. <STOP>
4.4 static arrays are available throughout the program <STOP>
4.4 a static array is allocated when the program starts and is freed when the program exits but has limited scope, while an array that is not declared static is allocated and freed when it comes into and out of scope. <STOP>
4.4 if they are declared fixed or static that means they cannot change size once their storage has been allocated, however one that is not or dynamic arrarys can be resized. <STOP>
4.5 at least 2, depending on how many arrays are being used. <STOP>
4.5 all of them. <STOP>
4.5 When passing a multi-dimensional array, all dimensions must be specified except for the first dimension. <STOP>
4.5 It depends what parameters you are passing in a multidimensional. <STOP> A multideminsional can have more than two dimensions. <STOP>
4.5 The first dimension is not required however the subsequent dimension -LRB- s -RRB- are needed for the compiler. <STOP>
4.5 all but the first <STOP>
4.5 All of the dimensions must be specified. <STOP>
4.5 just the first one at least. <STOP>
4.5 Two paramaters, the array and how many columns. array -LRB- a [], [3] -RRB- <STOP>
4.5 The size of the first dimension can be omitted, same as a regular array. <STOP> However, for every dimension outside the first, the size of those dimensions must be specified when passed, for example, a multi-dimensional array of [2] [4] [6] with the name MultiArray would be passed as: "MultiArray [] [4] [6], 2" <STOP>
4.5 Size of subsequent dimensions are required. <STOP> Compiler must know how many elements to skip to move to the second element in the first dimension <STOP>
4.5 Every dimension after the first. <STOP>
4.5 both <STOP>
4.5 the size of the first dimension does not need to be specified, but all other dimensions do. <STOP>
4.5 when passing -LRB- in main -RRB- a multidimensional array to a function, no dimensions need be specified <STOP>
4.5 All dimensions except for the first one need to be specified when passing an array to a function, the compiler needs to know how many memory addresses to skip to make it back to the 2nd element in the first dimension. <STOP> The size of the first dimension does not need to be specified. <STOP>
4.5 as many as there are dimensions. <STOP> Most commonly just rows and columns <STOP>
4.5 at least 2, but it should always equal the number of dimensions that the argument is expecting ... like ... blah [] [] [] [] will require 4 dimensional array input. blah [] [] [] will require a 3 dimensional array. blah [] [] will require a 2 dimensional array. <STOP>
4.5 None, just pass the array name. <STOP>
4.5 all subsequent dimensions after the first dimension. first is not needed to be specified. <STOP>
4.5 all dimensions, excluding the first one. <STOP>
4.5 all dimensions but the first <STOP>
4.5 the first needs to be specified by size and the rest need only be stated -LRB- first like this [3] then [] [] [] -RRB- <STOP>
4.5 one less than the number of dimensions the array contains <STOP>
4.5 not answered <STOP>
4.5 one <STOP>
4.5 All subsequent dimensions after the first one. <STOP>
4.5 two or more <STOP>
4.5 1 less than the total number of dimensions <STOP>
4.5 Multi dimensional arrays are accessed using more than 1 index, one for each dimension at least. <STOP>
4.6 compilation error <STOP>
4.6 compilation error. <STOP>
4.6 Using an index outside the bounds of the array generates a run-time error. <STOP>
4.6 run-time error <STOP>
4.6 Its a run-time error. <STOP>
4.6 run time error <STOP>
4.6 Run-time error. <STOP>
4.6 run-time error <STOP>
4.6 compilation error <STOP>
4.6 This is a run-time error. <STOP> The program will compile AND execute, so these errors can be difficult to debug. <STOP>
4.6 this is a run-time error or execution-time error. <STOP>
4.6 Run-time. <STOP>
4.6 run time <STOP>
4.6 Generates a compilation error. <STOP> The compiler will complain that the variable you are referring to was never declared. <STOP>
4.6 run-time <STOP>
4.6 Run-time error. <STOP>
4.6 run time error <STOP>
4.6 runtime error. <STOP>
4.6 Compilation error. <STOP>
4.6 run-time error <STOP>
4.6 run-time error <STOP>
4.6 run-time error <STOP>
4.6 compilation error. <STOP>
4.6 run-time error <STOP>
4.6 not answered <STOP>
4.6 run-time error <STOP>
4.6 compilation error <STOP>
4.6 compilation error <STOP>
4.6 It will NOT cause a compilation error. <STOP> It will either give a run-time error, or will give the value at that actual location in memory, causing a logic error. <STOP>
4.6 it is a run-time error <STOP>
4.7 usually it is by rows then followed by the column, but it is up to the programmer to determine how values are stored in bi-dimensional arrays. <STOP>
4.7 by rows. <STOP>
4.7 Multi-dimensional arrays are stored in memory by rows. <STOP>
4.7 A bi-dimensional or two-dimensional array is stored in a row-column matrix. <STOP> Where the first index indicates the row and the second indicates the column. <STOP> This means that when array elements are accessed in the order in which they are actually stored in memory, the right index changes faster than the left. <STOP>
4.7 They are stored in memory in rows. <STOP>
4.7 rows <STOP>
4.7 By rows. <STOP>
4.7 by rows <STOP>
4.7 m-by-n. by row-column. <STOP>
4.7 bi-dimensional arrays are stored by rows <STOP>
4.7 By rows. <STOP>
4.7 By column. <STOP>
4.7 columns <STOP>
4.7 By rows <STOP>
4.7 by-dimensional arrays are stored by row <STOP>
4.7 x by y is row by column. <STOP> So x is rows, and y is columns. <STOP> Since the length of the row is not needed when passing the array to the function, this leads me to believe that bi-dimensional arrays are stored by rows at a time. <STOP>
4.7 Both, they are stored in seperate sections. <STOP>
4.7 by rows, then columns. <STOP>
4.7 Rows <STOP>
4.7 by rows of rows <STOP>
4.7 by rows <STOP>
4.7 rows <STOP>
4.7 stored by rows <STOP>
4.7 by rows <STOP>
4.7 by rows <STOP>
4.7 by rows <STOP>
4.7 rows <STOP>
4.7 by row and column <STOP>
4.7 by rows <STOP>
4.7 No answer <STOP>
5.1 Takes an element of an array and compares it with the next element, depending on the values of the two elements they will switch and then the program will compare the new switched element with the next one in the array. <STOP>
5.1 Insertion sort divides the list into sorted and unsorted regions, then takes each item from the unsorted region and inserts it into its correct order in the sorted region. <STOP>
5.1 The sorted array or list is built one entry at a time. <STOP>
5.1 It starts with the second element and checks it to see if it is less than the element -LRB- s -RRB- to the left of it and if it is it inserts it into its corrected position. <STOP>
5.1 Compare two numbers at a time and swap until the entire list is sorted. <STOP>
5.1 Assume the first number is sorted, then move down the list and "insert" the numbers you come across into the corresponding place on the sorted side of the list. <STOP>
5.1 insertion sort is were after k iterations the first k items in the array are sorted it take the k plus 1 item and inserts it into the correct position in the already sorted k elements. <STOP>
5.1 Looking at the 2nd element move forward and place the element in the correct spot. <STOP>
5.1 Starting at the beginning of an array, take each element in order and place it in it is correct position relative to all previously sorted elements. <STOP>
5.1 To sort the elements in an array by removing an element from the input data and inserting it at the correct position. <STOP>
5.1 Insertion sort removes an element from the data, and inserts it at the correct position in the already sorted list. <STOP>
5.1 Take a number and choose a pivot point and insert the number in the correct position from the pivot point. <STOP>
5.1 have a marker and sort everything to the left of the value for every new value when moving to the right. <STOP>
5.1 The main idea behind insertion sort is to take a random variable from the right and insert it in order to the left. <STOP>
5.1 Insertion sort progresses through a list of elements and determines where the next element should be inserted into an already sorted array starting with sorting and using the first two elements. <STOP>
5.1 it goes through the list only once, picking each integer and putting it in its desired position, then continuing. <STOP>
5.1 Inserting array items in to their appropriate positions from smallest to largest at a pivot which starts on the second element of the array. <STOP>
5.1 Insert the item into its proper position by shifting larger sorted array values to the right. <STOP>
5.1 a comparison sort in which the sorted array is built one entry at a time <STOP>
5.1 Insertion sort is an algorithm where the first element of the array is in the sorted list, all the other pick one by one and taken from the unsorted array, to the sorted array. <STOP>
5.1 Every iteration of an insertion sort takes away an element from the input data, inserting it at the right position in the sorted list. <STOP>
5.1 the insertion sort creates a new array and inserts each item in its place with respect to the new array. <STOP>
5.1 Insertion sort takes each entitity of an unsorted array in order, and sorts it into the correct position between the entities it has sorted. <STOP>
5.1 it takes the second element and swaps it with the 1st if it is less and keeps it there if its larger, then it goes to the third element and inserts it in the right places with respect to the first 2 elements and so on ... <STOP>
5.1 Starting with the first element in the array, each following element is put in place by determining if it is smaller or larger than the starting element. <STOP>
5.1 one by one, each item is taken and placed into the correct place in the sorted portion of the array until there are no more items <STOP>
5.1 you take each element and insert it in the correct position with respect to all the elements before it <STOP>
5.1 Insertion sort is a simple sorting algorithm, a comparison sort in which the sorted array -LRB- or list -RRB- is built one entry at a time. <STOP>
5.2 Searches an array for the largest or the smallest element and is moved out to the front of the array then it will search for the next largest or the smallest element to move out to the front <STOP>
5.2 Selection sort searches the whole array for the largest item and puts it at the end of the array, then searches for the second largest item and puts it at the second to last spot and so on. <STOP>
5.2 Finds the minimum value and swap it with the value in the first position. <STOP>
5.2 It finds the minimum element in the array and swaps it with the first element then repeats this step swapping the minimum element with nth positions in the array. <STOP>
5.2 Find the lowest value and place it at the front, then find the next lowest and place it in front of the last value, etc. <STOP>
5.2 Cycle through the unsorted list, place the minimum in the next slot in the sorted list, and repeat. <STOP>
5.2 find the minimum value in the list swap it with the first element in the list the find the second largest and swap it with the second element in the array continue like this until the array is sorted. <STOP>
5.2 Find the smallest and put it in the current position till you get to the end. <STOP>
5.2 Find the lowest unsorted value in the array and place it at the current position -LRB- starting at the first element in the array -RRB- and advance the "current" position by one. <STOP>
5.2 To sort the elements by comparing two elements and swapping the smaller one to sort the elements in the array. <STOP>
5.2 Selection sort finds the minimum value in the list, swaps it with the first value in the list, and repeats throughout the list. <STOP>
5.2 Select the minimum number from the array and put it in the current position, then move on <STOP>
5.2 Find the lowest value and place it in the front of the list and swap it with that value. <STOP> Continue moving right. <STOP>
5.2 The main idea behind selection sort is to take the least variable from the right and put it directly to the left. <STOP>
5.2 Find the smallest value in the list and make it the first element, then find the smallest value of the leftover list and make it the first element of the leftover list and continue until the list is sorted. <STOP>
5.2 It runs through and finds the lowest -LRB- or highest -RRB- value and puts it in its desired position. <STOP>
5.2 Places the smallest item in the list at position 1, and then proceeds to each value until the last position of the ray is reached. <STOP>
5.2 Search for the largest item in an array and swap it with the last unsorted item. <STOP>
5.2 finds the smallest element and places in 1st position. then the process is repeated on the rest of the array. <STOP>
5.2 Selection sort is an algorithm that selects the larges item the array and puts it in its place; then select the next largest until the array is sorted <STOP>
5.2 Select the smallest number in the list and move it to the front of the list and then advance to the next number. <STOP>
5.2 the selection sort chooses the largest or smallest value in an unsorted list and creates a new list using the selection depending on how it is sorted. <STOP>
5.2 Selection sort finds the smallest number left unsorted in an array, and puts it at the end of what it has sorted <STOP>
5.2 selects the minimum from the remaining elements of the array, and palces the miminum in the current position and moves to the next position <STOP>
5.2 To put the biggest element at the end of the list and place the next highest element behind it, and so on. <STOP>
5.2 the sort finds the largest item and places it at the end, then then next largest is found and placed next to last, continue until there is only one number left, this is the beginning of the sorted array <STOP>
5.2 you loop through the entire list, and for each iteration you find the smallest element and move it to the current position. <STOP>
5.2 Find the minimum value in the list swap it with the value in the first position; repeat the steps above for remainder of the list -LRB- starting in the second position. <STOP>
5.3 The run time for this sorting program is n to the power of 2. Best case is the list is already sorted, worst case is the list is sorted but in reverse. <STOP>
5.3 Insertion sort is O -LRB- n -RRB- and performs n minus 1 operations in the best-case scenario, which is when the list or array is already sorted. <STOP>
5.3 The number of operations for insertions sort, under best-case, is n -LRB- n minus 1 -RRB- divided by 2. The best case for insertion sort is on a sorted list where it runs is O -LRB- n -RRB- . <STOP>
5.3 Best case would be O -LRB- n -RRB- or n minus 1, because that is what it takes to scan the array and make one swap. <STOP> The array would then be sorted and would take only 1 operation. <STOP>
5.3 Best case-1 <STOP> Worst Case-N <STOP>
5.3 It will do -LRB- n -RRB- operations where -LRB- n -RRB- is the number of elements in the array. <STOP> Best case is when all the elements are already sorted. <STOP>
5.3 O -LRB- n -RRB- <STOP>
5.3 Best case is all elements sorted. n minus 1. <STOP>
5.3 The best case scenario for an insertion sort, where all the elements of the array have been already sorted, will cause the for loop to iterate "x" times -LRB- "x" being the number of elements in the array -RRB- and the while loop to never have to iterate, resulting in the insertion sort to require "x" operations. <STOP>
5.3 1 operation. the best case scenario s where it is already sorted and does one comparision. <STOP>
5.3 n operations, where n is the number of items. <STOP>
5.3 n minus 1 <STOP>
5.3 O -LRB- n -RRB- , the list is already sorted. <STOP>
5.3 Insertion sort will take n minus 1 operations if the array is in reverse order. <STOP>
5.3 In the best case scenario of an already sorted list, insertion sort will progress once through the list. <STOP> So the number of operations is directly proportional to the number of elements in the list. <STOP> Also noted as O -LRB- n -RRB- in big o notation. <STOP>
5.3 1 where there is a list of two ints and only one must be moved. <STOP>
5.3 Best case is N, while the worst case is N factorial. <STOP>
5.3 n minus 1 <STOP> The best case is when the array is already sorted. <STOP>
5.3 worst case its equals O -LRB- n -RRB- time best case its equals O -LRB- n to the power of 2 -RRB- time <STOP>
5.3 O -LRB- n -RRB- <STOP>
5.3 N number of times. <STOP> Where N equals the number of elements in the list. <STOP> Best-case scenario is that the elements in the list are already sorted. <STOP>
5.3 the best case scenario for insertion sort is a list that is already sorted. the number of operations would be the same as the number of elements <STOP>
5.3 insertion sort will make zero operations -LRB- and length 1 comparisons -RRB- in the best case scenario, that is, when the array its given is already in order. <STOP>
5.3 theta -LRB- n -RRB- the best case senario is that everything is already sorted <STOP>
5.3 n operations <STOP> The best case scenario is when all the numbers are in increasing order. <STOP>
5.3 it could be considered that having only one item would be the easiest to sort, but this could also be a trivial result as nothing is moved having two items allows the algorithm to sort the items into the correct order <STOP>
5.3 the best case is if it only has to look through the list once. <STOP> The best case scenario is when it goes through the list and does not have to make any changes -LRB- the list is already sorted -RRB- <STOP>
5.3 very simplistic it moves one element from the list by one and inserting them in their correct position into a new slot then starting over. best case is -LRB- 0 -RRB- 1 <STOP>
5.4 The base case for a recursive merge sort is one number. <STOP> One number by itself is a sorted list, regardless of what number it is. <STOP>
5.4 The base case for a recursive implementation of merge sort is when the sequence being passed to merge sort has less than 2 elements. <STOP>
5.4 The base case for a recursive implementation of merge sort is one. <STOP>
5.4 The best case is the same as the worst case O -LRB- n log n -RRB- for a recursive merge sort. <STOP>
5.4 there is one object in the split array to sort. <STOP>
5.4 The base case is when the length of the current array is 1. <STOP>
5.4 O -LRB- nlog -LRB- n -RRB- -RRB- <STOP>
5.4 Best case is one element. <STOP> One element is sorted. <STOP>
5.4 If the array being sorted has 0 or 1 elements <STOP>
5.4 T -LRB- n -RRB- equals 0, if n is less than 2. <STOP>
5.4 A list size of 1, where it is already sorted. <STOP>
5.4 Single element in the array <STOP>
5.4 O -LRB- nlog -LRB- n -RRB- -RRB- <STOP>
5.4 n multiplied by log -LRB- n -RRB- <STOP>
5.4 A list or array of only 1 element. <STOP>
5.4 where you only must merge sort once <STOP>
5.4 A single Element on the Array. <STOP>
5.4 There is only one element in the subarray. <STOP>
5.4 if the array length is less than or equal to 1, then that array is returned to the other array and merged together <STOP>
5.4 if -LRB- right is greater than left -RRB- mid equals -LRB- right plus left -RRB- divided by 2; m sort -LRB- numbers, temp, left, mid -RRB- ; m sort -LRB- numbers, temp, mid plus 1, right -RRB- ; merge -LRB- numbers, temp, left, mid plus 1, right -RRB- ; <STOP>
5.4 The sequence of numbers has zero or one elements. <STOP>
5.4 one element in an array <STOP>
5.4 array of length 1 <STOP>
5.4 the array has one element <STOP>
5.4 When there is only one element in the array, or when the starting element in the array is the same as the ending element. <STOP>
5.4 when each half or the original array has nothing else to sort, and puts the halfs back together <STOP>
5.4 the size of the list being sent is is less than or equal to 1 <STOP>
5.4 O -LRB- n log n -RRB- <STOP>
6.1 Its a location in memory that contains the memory address of another location in memory that contains information. <STOP>
6.1 A pointer is a variable that contains a memory address as its value. <STOP>
6.1 A pointer is a variable which stores the address of another variable. <STOP>
6.1 Pointers are variables that contain as their values memory addresses of other variables. <STOP>
6.1 A data type whose value refers to another value stored elsewhere in the computer memory using its address. <STOP>
6.1 a pointer holds a memory location <STOP>
6.1 a name that represents actual location or value of a data type. int star of bPtr points to an integer value. <STOP>
6.1 A variable that stores the address of another variable <STOP>
6.1 a pointer is a programming language data type whose value refers directly to -LRB- or points to -RRB- another value stored elsewhere in the computer memory using its address <STOP>
6.1 A data type whose value refers to another value stored somewhere else in the computer memory using its address. <STOP>
6.1 It is like a variable however instead of holding data, it holds a location in memory. <STOP>
6.1 A pointer is a reference to a location in memory <STOP>
6.1 A pointer is a reference to the memory location of an object. <STOP>
6.1 A pointer is a variable that contains the memory address of a variable that has a value. <STOP>
6.1 It is a variable that contains not only a star of value but has a memory address associated with it, and can be moved along a string or an array by jumping up one memory address. <STOP>
6.1 Contains a variable 's memory address as a value. <STOP>
6.1 variable that points to the memory address of another variable and it is type specific. <STOP>
6.1 An element that references a memory cell <STOP>
6.1 Is a reference call to the place in memory where the object is stored. <STOP>
6.1 a variable that contains the address of another variable <STOP>
6.1 A pointer variable contains the number of a memory address as its value, which may be null or 0, or the address of some value stored in memory. <STOP>
6.1 A pointer is a variable that contains a memory address of anther variable <STOP>
6.1 A variable that contains the memory address of another variable that contains a specific value. <STOP>
6.1 a variable with a memory address as the value <STOP>
6.1 it is a type that points to something else. <STOP> It is the memory address of something else <STOP>
6.1 A pointer is a way to get at another object. <STOP> Essentially it is a way to grab an instance of an object and then either pass that instance a message or retreive some data from that object. <STOP> A pointer is actually just an address of where an instance is held in memory. <STOP>
6.2 This operator returns the memory address of its operand. <STOP>
6.2 The address operator returns the memory address of its operand. <STOP>
6.2 Returns memory address of its operand. <STOP>
6.2 The address -LRB- ADDRESS -RRB- operator returns the memory address of its operand. <STOP>
6.2 Returns the memory address of its operand. <STOP>
6.2 returns the place in memory of that element <STOP>
6.2 The address of the where the data is stored: address of b will return the address of b. <STOP>
6.2 The ADDRESS operator returns the address of a variable <STOP>
6.2 the ampersand -LRB- ADDRESS -RRB- means "pass by reference". <STOP> When the function is called, a pointer to the variable, instead of the variable itself, will be passed into the function. <STOP>
6.2 ADDRESS returns the memory address of its operand. <STOP>
6.2 the address of the variable in memory <STOP>
6.2 Returns the address location in memory of the item. <STOP>
6.2 The address operator returns the memory address of its operand. <STOP>
6.2 The ADDRESS operator returns the memory address of the variable it precedes. <STOP>
6.2 The memory address of operand, 0x 000000 or something along those lines. <STOP>
6.2 The object 's memory address. <STOP>
6.2 the reference to a variable <STOP>
6.2 returns the memory address of its operand <STOP>
6.2 memory address of its operand <STOP>
6.2 returns the address number of the specified variable <STOP>
6.2 It returns the memory address of it is operand. <STOP> That is, if applied to a normal variable, it gives the variable 's memory address, just as a pointer variable might. <STOP>
6.2 The ADDRESS is a unary operator that returns the memory address of its operand <STOP>
6.2 the address of the variable it is attached to <STOP>
6.2 the memory address of its operand <STOP>
6.2 returns the address of what it is put in front of <STOP>
6.2 returns a pointer <STOP>
6.3 returns a synonym for the object to which its pointer operand points. <STOP>
6.3 The star operator returns a synonym for the object to which its pointer operand points. <STOP>
6.3 Returns synonym for the object its operand points to. <STOP>
6.3 It returns a synonym, alias or nickname of the name of the object that its operand points to in memory -LRB- dereferencing the pointer -RRB- . <STOP>
6.3 Returns an alias or nickname for the object to which the pointer operand points. <STOP>
6.3 the STAR operator returns the value in the memory address the element points to. <STOP>
6.3 The STAR returns the value <STOP>
6.3 The STAR operator returns the dereferenced pointer variable -LRB- ie: it returns the value of whatever variable the pointer is pointing to -RRB- <STOP>
6.3 The dereferencing operator returns the dereferenced object. <STOP>
6.3 multiplied by returns the synonym for the object its operand points to. <STOP>
6.3 it returns the information in the address the pointer points to. <STOP>
6.3 the star operator returns the value at the memory address the pointer is pointing at. <STOP>
6.3 The star operator returns the object at that memory location. <STOP>
6.3 The STAR operator returns the value of the object 's memory address it precedes. <STOP>
6.3 The value of the object that the operand points to <STOP>
6.3 The value stored in the object being pointed to. <STOP>
6.3 the value of the variable the pointer points to. <STOP>
6.3 returns synonym for the object its operand points to <STOP>
6.3 synonym for the object its operand points to <STOP>
6.3 Returns synonym for the object its operand points to <STOP>
6.3 It dereferences a pointer, meaning it returns the value stored in the memory address a pointer refers to. <STOP>
6.3 It is unary operator that returns the value of the variable located at the address <STOP>
6.3 a reference to a equals variable <STOP>
6.3 a synonym for the object to which its pointer operand points <STOP>
6.3 it returns the actual data at the address pointed to <STOP>
6.3 will return zero or many characters placed before the operator <STOP>
6.4 The array itself can be signed to a pointer or each element of the array can be assigned to a pointer. <STOP>
6.4 An array can be addressed in pointer or offset notation by setting a pointer variable equal to the variable name of the array. <STOP> Elements of the array can then be accessed by adding an offset value to the pointer variable. <STOP>
6.4 Element b [n] can be accessed by multiplied by -LRB- bPtr plus n -RRB- . <STOP>
6.4 Using either the name of the array as a pointer or using a separate pointer that points to the array. <STOP>
6.4 An element b [3] can be referenced by using multiplied by -LRB- bPtr plus 3 -RRB- instead. <STOP>
6.4 you get the memory location of the first element and the you add an offset to it to get other elements. <STOP>
6.4 yes multiplied by -LRB- array plus offset -RRB- <STOP>
6.4 The name of an array is considered to be a pointer in C plus plus, and can be passed as such in functions parameters. <STOP> Declaring int a [10]; creates a pointer "a" which stores the address of a [0]. <STOP>
6.4 Element b [n] can be accessed by multiplied by -LRB- bPtr plus n -RRB- is an example of how an array can be addressed as pointer or offset notation. <STOP>
6.4 multiplied by -LRB- array plus element -RRB- <STOP>
6.4 multiplied by f [3] <STOP>
6.4 you can have a pointer to the front of the array and add to the memory location -LRB- or offset from the initial value -RRB- . <STOP>
6.4 The pointer to the array will initially point to the first element of that array. <STOP> When the pointer is incremented, it will point to the next element, and so on. <STOP>
6.4 With int x [10]; int star of xPtr; xPtr equals x; <STOP> Address address of x [1] is the same as xPtr plus 1. <STOP>
6.4 Takes the number of array elements and points to each at a time <STOP>
6.4 The array can act as a pointer or be referenced by a pointer. multiplied by -LRB- arrayPtr plus 3 -RRB- or multiplied by -LRB- array plus 3 -RRB- <STOP>
6.4 by using the multiplied by -LRB- pointer plus element-index -RRB- <STOP>
6.4 using the star operator. array: b [n] can be accessed by multiplied by -LRB- bpointer plus n -RRB- <STOP>
6.4 Element A [n] can be accessed by multiplied by -LRB- APtr plus n -RRB- <STOP>
6.4 by referencing a pointer and referring to other pointers relative to the first pointer -LRB- pointer plus 1, pointer plus 2, etc -RRB- <STOP>
6.4 First, some pointer variable must reference the first entity in the array. <STOP> Any variable in the array can then be accessed by referring to that first entity 's address plus some offset. i. e. ptrToArray equals array; nthEntity equals multiplied by -LRB- ptrToArray plus n -RRB- ; <STOP>
6.4 ADDRESS [b 3] is as bptr plus 3. <STOP> Array can be treated as pointer <STOP>
6.4 a [i] equals multiplied by -LRB- a plus i -RRB- <STOP>
6.4 address of b [3] bPtr plus 3 <STOP>
6.4 multiplied by -LRB- arrayName plus index -RRB- <STOP>
6.4 multi-dimensional array <STOP>
6.5 the number of bytes of an array during program compilation. <STOP>
6.5 The sizeof operator returns the size of the operand. <STOP>
6.5 Returns size of operand in bytes. <STOP>
6.5 It returns the size of an array in bytes. <STOP>
6.5 Returns the size of the array in bytes during the program compilation. <STOP>
6.5 it returns the size of the argument passed in <STOP>
6.5 The byte size of the date stored ina variable. <STOP>
6.5 sizeof returns the size of the operand in bytes <STOP>
6.5 The amount of memory required for a specific parameter such as ints, doubles. <STOP>
6.5 sizeof returns the size of the operand in bytes. <STOP>
6.5 the size of the information in bits. <STOP>
6.5 the size of the string. <STOP>
6.5 sizeof returns the size in bytes of the respective object. <STOP>
6.5 The sizeof operator returns the total number of bytes of its operand. <STOP>
6.5 The size of an operand in bytes. <STOP> Used with variable names, type names, and constant values <STOP>
6.5 the size in bytes needed to store the object in memory <STOP>
6.5 the size of the list object. <STOP>
6.5 the sizeof operator returns the size in bytes of an array parameter <STOP>
6.5 the size of operand in bytes <STOP>
6.5 returns the size in bytes of the specified data <STOP>
6.5 It returns the size of an operand in memory, which is checked at compiler-time. <STOP>
6.5 Return size of operand in bytes <STOP>
6.5 the total number of bytes of an object. <STOP>
6.5 total number of bytes in the array <STOP>
6.5 it returns the size in bytes of a certain variable type <STOP>
6.5 it yields the size in bytes of the operand, which can be an expression or the parenthesized name of a type <STOP>
6.6 They can be passed by value or by reference <STOP>
6.6 Nonconstant pointer to nonconstant data, nonconstant pointer to constant data, constant pointer to nonconstant data, constant pointer to constant data. <STOP>
6.6 Nonconstant pointer to nonconstant data <STOP> Nonconstant pointer to constant data <STOP> Constant pointer to nonconstant data <STOP> Constant pointer to constant data <STOP>
6.6 Four different ways: Nonconstant pointer to nonconstant data, a nonconstant pointer to constant data, a constant pointer to nonconstant data and a constant pointer to constant data. <STOP>
6.6 Pass-by-value or pass-by-reference. <STOP>
6.6 you can pass a pointer to a pointer or pass a reference to pointer. <STOP>
6.6 by address address of bPtr or directly bPtr. <STOP>
6.6 Nonconstant pointer to nonconstant data, constant pointer to nonconstant data, nonconstant pointer to constant data, constant pointer to constant data. <STOP>
6.6 By argument and reference. <STOP>
6.6 Nonconstant pointer to nonconstant data, nonconstant pointer to constant data, constant pointer to nonconstant data, and constant pointer to constant data. <STOP>
6.6 pass by value and pass by reference with reference or pointer arguments. <STOP>
6.6 you can pass them with the pointer -LRB- STAR -RRB- or the memory address -LRB- ADDRESS -RRB- <STOP>
6.6 nonconst implies nonconst const implies nonconst nonconst implies const const implies const <STOP>
6.6 Nonconstant pointer to nonconstant data <STOP> Constant pointer to nonconstant data <STOP> Nonconstant pointer to constant data <STOP> Constant point to constant data <STOP>
6.6 Non-constant pointer to non-constant data, non-constant pointer to constant data, constant pointer to constant data, constant pointer to non-constant data. <STOP>
6.6 Pass by reference with reference arguments. function -LRB- int ADDRESS -RRB- <STOP> Pass by reference with pointer arguments. function -LRB- int STAR -RRB- <STOP>
6.6 you can pass the reference or the dereference in a function <STOP>
6.6 1. nonconstant pointer to nonconstant data. <STOP> Its delcaration does no include const qualifier. <STOP> 2. nonconstant pointer to constant data. <STOP> Provides the performance of pass-by-reference and the protection of pass-by-value <STOP> 3. Constant pointer to nonconstant data. <STOP> 4. Constant pointer to constant date. <STOP>
6.6 constant pointer to constant data, constant pointer to nonconstant data, nonconstant pointer to constant data, nonconstant pointer to nonconstant data <STOP>
6.6 Nonconstant pointer to nonconstant data <STOP> Nonconstant pointer to constant data <STOP> Constant pointer to nonconstant data <STOP> Constant pointer to constant data <STOP>
6.6 Pointers may be passed to functions by value, by reference with reference arguments, or by reference with pointer arguments. <STOP>
6.6 There are four way to pass pointer to a function <STOP> 1. non constant pointer to non constant data <STOP> 2. non constant pointer to constant data. <STOP> 3. constant pointer to non constant data. <STOP> 4. constant pointer to constant data. <STOP>
6.6 nonconstant pointer to nonconstant data nonconstant pointer to constant data constant pointer to nonconstant data constant pointer to constant data <STOP>
6.6 pass by value, pass by reference with reference arguments, pass by reference with pointer arguments <STOP>
6.6 you can pass it where either the pointer cant be moved, the data pointed to cant be changed, or both or neither <STOP>
6.6 there are only two ways to pass something, by value and by reference. <STOP> Use of dot or pointer operators within the receiving function and use of " <STOP> ADDRESS" operator inside the passing function <STOP>
6.7 A pointer that points to the memory address of the beginning part of a functions. pretty much the pointer points to the function so it can be called to execute. <STOP>
6.7 A function pointer is a pointer that contains the address of the function in memory. <STOP>
6.7 Function Pointers are pointers, i. e. variables, which point to the address of a function. <STOP>
6.7 A pointer to a function is the address where the code for the function resides. <STOP> They can be passed to functions, returned from functions, stored in arrays and assigned to other pointers. <STOP>
6.7 It contains the address of the function in memory. <STOP>
6.7 when it is dereferenced a function pointer calls its function with zero or more arguments. <STOP>
6.7 a pointer to a function <STOP>
6.7 A pointer to a function itself, contains the address of the function and can be used to call that function <STOP>
6.7 Function Pointers are pointers, i. e. variables, which point to the address of a function. <STOP>
6.7 A pointer to a function that contains the addresses of the function. <STOP>
6.7 a pointer that contains the address of a function <STOP>
6.7 a function pointer is a pointer to a function. <STOP> It can be used in substitution for calling a function. <STOP>
6.7 Points to the memory address of a function. <STOP> Kind of like breaking a branch off of a tree object and hitting other objects with it. <STOP>
6.7 They are pointers that contain the addresses to functions, they can be passed and returned from functions, as well as stored in arrays and assigned to other function pointers. <STOP>
6.7 Pointer variables that point to function addresses. <STOP>
6.7 Contains the address of the function in memory. <STOP>
6.7 a pointer that points to a function itself, which allows passing a function as a parameter to another function. <STOP>
6.7 pointers that contain the addresses of functions. <STOP>
6.7 is a pointer that contains the address of a function <STOP>
6.7 a pointer that contains the address of the function definition <STOP>
6.7 A function pointer contains the memory address of a function. <STOP> Using a function pointer, a function can be passed to or returned by another function. <STOP> Function pointers can also be stored in arrays. <STOP>
6.7 Function pointer is a pointer to a function. function pointer contains address of functions <STOP>
6.7 a pointer that contains the address of a function in memory. <STOP>
6.7 it contains the address of the function in memory <STOP>
6.7 it is a pointer that points to the address of a function. <STOP>
6.7 When dereferenced, a function pointer invokes a function, passing it zero or more arguments just like a normal function. <STOP> In programming languages like C, function pointers can be used to simplify code, such as replacing large switch statements. <STOP>
7.1 Consists of sequence of nodes, each containing a number of data fields and one or two links called pointers that point to the next or previous nodes. <STOP>
7.1 A linked list is a list in which each item in the list points to the next item in the list. <STOP>
7.1 A linked list is a chain of structs or records called nodes and you have the ability to add, delete, or retrieve items. <STOP>
7.1 A list of elements, or nodes, that are linked to one another such that each element points to the next element. <STOP>
7.1 A sequence of nodes, each containing data fields -LRB- specified by programmer -RRB- and pointer -LRB- s -RRB- which can point to the next or previous nodes. <STOP>
7.1 a list of nodes where each node contains a data member and also a pointer to the next node. <STOP>
7.1 A list of items linked together. <STOP> Each item is linked to its successor. <STOP>
7.1 A linked list is a chain of nodes that each store a single piece of data and pointer variables that point to other nodes in the list. <STOP>
7.1 one of the fundamental data structures, and can be used to implement other data structures. <STOP> It consists of a sequence of nodes, each containing arbitrary data fields and one or two references -LRB- "links" <STOP> -RRB- pointing to the next and previous nodes. <STOP>
7.1 A data structure in a sequence of nodes, each containing arbitrary data fields and one or two references -LRB- "links" <STOP> -RRB- pointing to the next and previous nodes. <STOP>
7.1 Information in memory linked to the next piece of information and can only be linked forwards and not backwards. <STOP>
7.1 A linked list is a data structure that is not necessarily in the same contiguous memory space -LRB- such as arrays -RRB- . <STOP> It holds the data type and points to the next data item in the list, or in a doubly linked list also to the previous item. <STOP>
7.1 A linked list is a data structure containing one or more data elements with a pointer to the next node. <STOP>
7.1 A series of "Nodes" structures with a value and a pointer that point to a similar "Node". <STOP> Not quite an array, but still can carry a list of values. <STOP>
7.1 A data type that contains a pointer to at least the next element in a list. <STOP>
7.1 Each component contains a Node a data item and a pointer to the next item in the list <STOP>
7.1 A linked list is a chain of structs or records called nodes. <STOP> Each node has at least two members, one of which points to the next item or node in the list. <STOP>
7.1 An array based list that uses an implicit ordering scheme, often using pointers. <STOP>
7.1 a series of structures containing data items and a pointer that links the structure to the next structure. <STOP>
7.1 A linked list is a collection of Objects each containing at least one data member, and a pointer to the next object in the list -LRB- and the previous object in the case of a doubly linked list -RRB- <STOP>
7.1 A link list is a data structure which is built from structures and pointers. <STOP> It forms a chain of nodes with pointers representing the links of the chain and holding the entire thing together <STOP>
7.1 its a list of pointers that are linked 2 each other. every pointer points to the next pointer which has the next element <STOP>
7.1 linear collection of self-referential nodes connected by pointers. <STOP>
7.1 the items of a data structure are linked to each other using pointers <STOP>
7.1 A list of objects where each object contains a link to the next item in the list <STOP>
7.1 A linked list is one of the fundamental data structures, and can be used to implement other data structures. <STOP> It consists of a sequence of nodes, each containing arbitrary data fields and one or two references -LRB- "links" <STOP> -RRB- pointing to the next and previous nodes. <STOP>
7.2 Elements can be inserted into a link list at any point and does not need to be resized unlike an array needs to be. <STOP>
7.2 Unlike arrays, linked lists can insert and delete without shifting data and change in size easily. <STOP>
7.2 Array size is fixed, but Linked is not fixed. <STOP>
7.2 You can insert into and delete items from a pointer-based linked list without shifting data. <STOP>
7.2 Arrays must be of a defined size ... elements can be added to a linked list with o defining any size. <STOP>
7.2 The principal benefit of a linked list over a conventional array is that the order of the linked items may be different from the order that the data items are stored in memory or on disk, allowing the list of items to be traversed in a different order. <STOP> A linked list is a self-referential datatype because it contains a pointer or link to another datum of the same type. <STOP> Linked lists permit insertion and removal of nodes at any point in the list in constant time <STOP>
7.2 You can expand when you need it. <STOP> You do not have to predetermine the size. <STOP>
7.2 Linked lists are able to grow and shrink in size as needed <STOP>
7.2 Linked list is able to grow in size as needed. <STOP> Does not require the shifting of items during insertions and deletions <STOP>
7.2 A linked list is not fixed in size, and does not require the shifting of items during insertions and deletions. <STOP>
7.2 There is no limit as to how many you create where an array can only hold a given amount of information. <STOP>
7.2 Linked lists have constant time insertion and deletion <STOP>
7.2 Linked lists can be grown dynamically, items do not require shifting, and they have a greater awesome factor than that of arrays. <STOP>
7.2 Linked lists have an indefinite size. <STOP> They can be added to and taken away from very easily with little difficulty in the shifting of data. <STOP>
7.2 Nearly infinite size, limited only by system memory and also the ability to expand the size dynamically. <STOP>
7.2 They grow as needed, while arrays are of fixed size. <STOP>
7.2 Does not have a fixed size. <STOP> Linked list is able to grow as needed. <STOP> The time to access an array bases list takes a contant amount of time where as an linked-base like depends on "i" <STOP>
7.2 Linked lists can grow and shrink as you need them to. <STOP> Arrays have a fixed size. <STOP>
7.2 more memory can be allocated on the fly for more items <STOP>
7.2 A linked list may be increased in size as needed, while an array 's size is set when it is created <STOP>
7.2 Array has a fixed size, but linked list is able to grow in size as needed <STOP>
7.2 its resizeable <STOP>
7.2 Linked lists do not have a set size and can grow or shrink as needed. <STOP>
7.2 linked lists are abe to grow as needed to a new size <STOP>
7.2 The size is not fixed, easier sorting because of no shifting, easier to insert items into the list <STOP>
7.2 The size of array is restricted to declaration. <STOP> Insertion or Deletion of values in middle of array is not possible. <STOP>
7.3 Array can retrieve memory from any place in the list while in a link list you have to traverse through each individual node. <STOP>
7.3 Arrays require less memory than linked lists and allow direct access to a specified item. <STOP> Also, insertion and deletion in arrays does not require a list traversal. <STOP>
7.3 Access to a particular element is very fast, because its location in memory can be determined mathematically and accessed directly. <STOP>
7.3 Arrays are good for random access and good for sequential access which are both in constant time. <STOP> Where linked lists are linear for random access. <STOP> Arrays are faster in this case. <STOP>
7.3 An array is capable of accessing any part of that array based on the index. <STOP> The link list must be traversed from the beginning or the end, that is, data can only be accessed if it is adjacent to the previous or next nodes. <STOP>
7.3 On the other hand, arrays allow random access, while linked lists allow only sequential access to elements. <STOP> Singly-linked lists, in fact, can only be traversed in one direction. <STOP>
7.3 You have to keep up with the head of the list. <STOP>
7.3 Arrays are easier to implement and require less memory <STOP>
7.3 Linked list has an increase complexity of the implementation. <STOP> The linked list has an array that keeps growing which leads to a increase in memory. <STOP>
7.3 You do not have to iterate through the entire list to access elements. <STOP>
7.3 you can go forwards and backwards and point to any piece of data at any given time where linked lists have to point to the next piece of data. <STOP>
7.3 Take up less memory and are contiguously stored <STOP>
7.3 Arrays, being fixed, are less error prone. <STOP>
7.3 Arrays have a set list of values. <STOP> Meaning you can pick a spot in the array such as a [7] picks the 8th spot in the array. <STOP> With linked lists you have to keep track with pointers if you want to take specific nodes out, otherwise you must traverse the entire list. <STOP>
7.3 direct access to elements, and speed, linked lists have increased search times to access elements even if the list is sorted. <STOP> -LRB- like getting the last element without a pointer directly to the end of the list. <STOP> -RRB- <STOP>
7.3 Array items are accessed directly with equal access time <STOP>
7.3 Array-bases implementations require less memory than a pointer-bases one. <STOP>
7.3 You can access specific elements quickly in an array. <STOP> In a linked list you must traverse the list to get access the same element. <STOP>
7.3 link lists only allow sequential access where arrays allow random access <STOP>
7.3 Any entitiy in an array may accessed immediately, whereas a linked list must be traversed one item at a time because each object only points adjacent objects <STOP>
7.3 Array based implementation requires less memory than lined lists based implementation <STOP>
7.3 Array-based implementations require less memory than a pointer-based ones <STOP>
7.3 You can go up and down an array, but you can only go one direction while traversing a linked list. <STOP>
7.3 arrays allow for the random access of any item cotained a any time, linked lists must be gone through toget to the desired item <STOP>
7.3 In arrays you have direct access to each element, but in linked lists you have to traverse the list up to the element that you need. <STOP>
7.3 Array size is fixed. <STOP> But Linked is not fixed, data is also accessed quicker in array list, also memory requirement is less and no pointers required. <STOP> Arrays have random access and less overheads compared to Linked list have sequential access only with too much overheads and no cache memory support. <STOP> On the other hand, arrays allow random access, while linked lists allow only sequential access to elements. <STOP> Singly-linked lists, in fact, can only be traversed in one direction. <STOP>
7.4 They are passed by reference because you want the function to change the pointer <STOP>
7.4 Linked lists are passed as arguments to a function by passing the head pointer of the list by reference. <STOP>
7.4 minus A function with access to a linked list 's head pointer has access to the entire list. <STOP> Pass the head ponter to a function as a reference argument. <STOP>
7.4 By using a node. <STOP>
7.4 Pass-by-reference <STOP>
7.4 you send a pointer to an object of the LinkedList class <STOP>
7.4 Passed as a pointer to the head. <STOP>
7.4 Passing the head pointer of a linked list to a function gives that function access to all nodes of that linked list <STOP>
7.4 You have to pass the head pointer to a function since it has access to the entire list. <STOP>
7.4 You pass the head pointer to a function as a reference argument. <STOP>
7.4 not answered <STOP>
7.4 passes a pointer to a linked list object <STOP>
7.4 The linked list object contains the head, through which the other elements are accessible. <STOP>
7.4 By the head of the list. <STOP> It takes the head address and traverses from there on in. <STOP>
7.4 as a pointer node. <STOP>
7.4 A method with access to a linked list 's head pointer as access to the entire list <STOP>
7.4 A function with access to a linked list 's head pointer has access to the entire list. <STOP> Pass the head pointer to a function as a reference argument <STOP>
7.4 the head pointer is passed to a function as a reference argument. <STOP>
7.4 the pointer to the first element is passed to a function <STOP>
7.4 linked lists are passed by reference, specificly the Head pointer <STOP>
7.4 Pass the head pointer to a function as a reference argument <STOP>
7.4 by refrenece <STOP>
7.4 By passing the head pointer and going through the list as needed inside the function. <STOP>
7.4 linked lists are passed by using pointers <STOP>
7.4 the head object is passed to the function <STOP>
7.4 Linked lists permit insertion and removal of nodes at any point in the list in constant time, [1] but do not allow random access. <STOP>
7.5 They are passed by reference because you want the function to change the pointer <STOP>
7.5 In a circular linked list, every node has a successor which means that the last node 's successor is the head or first node. <STOP>
7.5 A circular linked list is a linked list that links items in a continuous circle. <STOP> This allows the full list to be traversed by starting at any item in the list; a fixed head or tail is not required. <STOP>
7.5 In a circular linked list, the last node points to the first node. <STOP>
7.5 On a circular linked list, the end element points to the head, thus making the circle. <STOP> A basic link list has nothing pointing to the head, and the last element points to null. <STOP>
7.5 the circular linked list 's last node points to the begining of the list while a standard linked list points to NULL <STOP>
7.5 The last item in the list points to the head <STOP>
7.5 In a circular linked list, the last node points back to the first node, there is no NULL <STOP>
7.5 Circular linked lists are most useful for describing naturally circular structures, and have the advantage of regular structure and being able to traverse the list starting at any point. <STOP>
7.5 A circular linked list has the last node point back to the head of the linked list. <STOP>
7.5 Basic linked list points to a NULL at the end and circular points to the head at the end. <STOP>
7.5 in a circular linked list the the last item points to the first item. <STOP>
7.5 The circular linked list 's tail points to the head, whereas the basic linked list 's tail points to a NULL. <STOP>
7.5 a basic linked list has an end with a null value where a circular linked list has a pointer from the end to the beginning <STOP>
7.5 how to determine the end of the list, in basic linked lists the last element links to a null pointer, while circular linked lists link to the head element at the end. <STOP>
7.5 No Node in a circular linked list contains NULL, the last Node points pack to a Node within the list. <STOP>
7.5 The difference between a circular linked list and a basic linked list is that a circular linked list, the last node references the first node. <STOP> Every node in a circular linked list has a successor and no node in a circular linked list contains NULL. <STOP>
7.5 No node in a circular linked list contains NULL. <STOP>
7.5 in a circular linked list the last element points to the head of the list <STOP>
7.5 In a regular linked list the last object points to NULL. <STOP> In a circular linked list, the last object points back to the beginning of the list <STOP>
7.5 In circular linked list each node has successor, no node contains NULL, while in basic linked list last node contain NULL. <STOP>
7.5 in a circular linked lists, the last element points to the first <STOP>
7.5 A circular linked list does not have a last element. <STOP> Instead, it is last item points to the head of the list. <STOP>
7.5 in a circular linked list, the last node contains a pointer that goes back to the first node; in a basic linked list, the last node contains a null pointer <STOP>
7.5 in a circular linked list, the last object is linked back to the first object. <STOP>
7.5 In the case of a non circular link list, if you are at the last node of the list and u want to move to first u need to go to one, step back till u reach to first. <STOP> But in circular link list from last to first you need to make only one move. <STOP> In a single link list u can move only in one direction but in double link list u can move in any direction back or forward or forward. <STOP>
7.6 they can traverse in both directions <STOP>
7.6 In a doubly linked list you can delete a node without having to traverse the list. <STOP>
7.6 A doubly-linked list allows you to delete a node without traversing the list to establish a trailing pointer. <STOP>
7.6 A doubly linked list allows you to traverse the list in either direction. <STOP> Each node points to its successor as well as to its predecessor. <STOP>
7.6 Doubly-linked lists can traverse backwards, though they still cannot access data at any point in the list, it can be shorter to traverse backwards. <STOP>
7.6 you can traverse the list from front to back and back to front <STOP>
7.6 You can traverse the list in reverse. <STOP>
7.6 Doubly linked lists can be traversed in both directions <STOP>
7.6 Double-linked lists require more space per node, and their elementary operations are more expensive; but they are often easier to manipulate because they allow sequential access to the list in both directions. <STOP>
7.6 You can traverse forwards and backwards through nodes. <STOP>
7.6 You can point both forwards and backwards <STOP>
7.6 You can go backwards in the linked list and access previous data easier without having to keep track of the previous item <STOP>
7.6 Doubly linked lists allow backward movement through the nodes. <STOP>
7.6 they have double pointers, so each node can point forwards or backwards. <STOP> Making it a little easer to get to where you need. <STOP>
7.6 ability to backtrack through a list. <STOP>
7.6 You can move forwards and backwards in the double-linked list. <STOP> Basic only moves forwards. <STOP>
7.6 The advantage is that each node points to bothe its predecessor and its successor. <STOP> There are no special cases for insertion and deletion. <STOP>
7.6 each node points to both its predecessor and its successor. <STOP>
7.6 a doubly linked list has pointers in both directions. this allows for access from back to front as well as front to back <STOP>
7.6 A doubly linked list can be traversed either direction, while a normal linked list can only be traversed from start to finish <STOP>
7.6 Double Linked list are often easier to manipulate, because they allow sequential access to the list in both direction <STOP>
7.6 given a node in the list, one can navigate easily in either direction <STOP>
7.6 You can traverse the list both forward and backwards. <STOP>
7.6 a doubly linked list allows you to back up from a node rather than having to go through the entire list again <STOP>
7.6 Gives faster times for some operations such as insertion and deletion <STOP>
7.6 The primary disadvantage of doubly linked lists are that -LRB- 1 -RRB- each node requires an extra pointer, requiring more space, and -LRB- 2 -RRB- the insertion or deletion of a node takes a bit longer -LRB- more pointer operations -RRB- . <STOP>
7.7 they take up twice as much memory for each node <STOP>
7.7 In a doubly linked list, there are more pointers to set and the mechanics of inserting and deleting are more difficult. <STOP> Also, the special cases at the beginning or end of the list are more complicated. <STOP>
7.7 There are more pointers to set, the mechanics of inserting into and deleting from a doubly linked list are a bit more involved than for a singly linked list. <STOP>
7.7 Insertion and deletion with a doubly linked list are more involved than with a singly linked list leaving more room for error and complex algorithms. <STOP>
7.7 Need more memory to store "previous" pointers. <STOP>
7.7 a node in a doubly linked list takes up more memory than a node in a singly linked list. <STOP>
7.7 You have to keep up with where you are and you have to consider the predecessor and successor connections when inserting or deleting. <STOP>
7.7 Each node requires an extra node, requires more memory, and is more difficult to insert and remove individual nodes <STOP>
7.7 Double-linked lists require more space per node, and their elementary operations are more expensive <STOP>
7.7 More difficult to delete and create nodes. <STOP>
7.7 They use more memory and you have to make 2 pointers and update 2 pointers each time you change the list. <STOP>
7.7 nodes take up more memory <STOP>
7.7 Each node requires an extra pointer -LRB- space requirements increased -RRB- , Insertion or deletion of a node takes a longer -LRB- more pointer operations -RRB- . <STOP>
7.7 its a little more confusing. <STOP> The special cases at the end and beginning become more difficult to do. <STOP>
7.7 increased actions to add and remove elements to the linked list. <STOP>
7.7 Inserting and deleting in a double-linked list is more involved, and has special cases at the beginning and end. <STOP>
7.7 The main disadvanate is that if hard to remove all items in the list. <STOP>
7.7 each node requires an extra pointer, taking up more storage. insertions and deletions require more pointer operations. <STOP>
7.7 in a doubly linked list there are twice as many pointers for each element, therefore more memory is used <STOP>
7.7 The process of adding and removing Nodes in a Doubly linked list is more complex than in a basic linked list <STOP>
7.7 Double linked lists require more space per node, and their elementary operation are more expensive <STOP>
7.7 1-each node requires an extra pointer, requiring more space <STOP> 2-the insertion or deletion of a node takes a bit longer, more pointer operations <STOP>
7.7 It takes up twice the storage needed. <STOP>
7.7 using more pointers to enable the backward movement takes up more memory, having more pointers make it slightly more work to add or remove a node from the list <STOP>
7.7 increased memory requirements, slightly more complicated when modifying elements in the list <STOP>
7.7 not answered <STOP>
8.1 A data structure for storing items which are to be accessed in last-in first-out order that can be implemented in three ways. <STOP>
8.1 A stack is an abstract data type that is based on the principle that the last element inserted into the stack will be the first element removed from the stack. <STOP>
8.1 Stores a set of elements in a particular order. <STOP>
8.1 An ADT whose most recently inserted item is the first item removed or retrieved. <STOP> This property is called last in, first out -LRB- LIFO -RRB- . <STOP> Items enter and leave a stack at its top. <STOP>
8.1 A list in which only the top -LRB- or last item added -RRB- can be modified. <STOP>
8.1 a stack is a data structure that uses push to insert an item and pop to remove ad item. <STOP> The stack use a last in first out structure for inserting and removing items. <STOP>
8.1 A data structure that stores data using LIFO. <STOP>
8.1 A stack is similar to an array, but does not allow for random access. <STOP> Stacks only allow a user to retrieve the last item put into the stack. <STOP> Last in, fist out. <STOP>
8.1 Stores a set of elements in a particular order. <STOP> Stack principle: LAST IN FIRST OUT. <STOP> It means: the last element inserted is the first one to be removed. <STOP>
8.1 A stack is an ADT that stores a set of elements in a particular order. <STOP>
8.1 a data type that stores a set of elements in a certain order, last in, first out. <STOP>
8.1 a data structure that moves elements in last in first out <STOP>
8.1 Stores a set of elements in a last in first out order. <STOP>
8.1 A list that can be added to or removed from only from the top. <STOP>
8.1 a stack is an Abstract data type which operates on a last in first out basis for storing a list of objects, and does not support -LRB- at least in the pure stack -RRB- peeking at a element without removing the rest of the stack first. <STOP>
8.1 Stores a set of elements in a particular order based on the principle of Last In First Out -LRB- LIFO -RRB- . <STOP>
8.1 an object list that stores elements in a particular order, the first object inserted is at the bottom with the last object at the top so the first object in is the last object out. <STOP>
8.1 An ADT that stores a set of elements in a particular order. <STOP> The stack principles are LIFO. <STOP> The last item inserted in the list is the first out. <STOP>
8.1 An abstract data type that stores a set of elements in a particular order. <STOP>
8.1 a collection of data to be executed in the order of last in first out <STOP>
8.1 A stack is a data structure that allows data members to be added or removed one at a time, and in order. <STOP> They are a "Last in First Out" structure. <STOP>
8.1 Stores a set of element in a particular order <STOP>
8.1 is a list of element where the first one to be removed is the last one inserted <STOP>
8.1 A data structure that puts elements in a list and only allows the user access to the last element. <STOP>
8.1 a finite ordered list with zero or more elements <STOP>
8.1 A storage container that holds objects in a certain order, which has a LIFO priority <STOP>
8.1 Stacks are a type of container adaptors, specifically designed to operate in a LIFO context -LRB- last-in first-out -RRB- , where elements are inserted and extracted only from the end of the container. <STOP>
8.2 Push and pop are two main functions defined in a stack <STOP>
8.2 Push which inserts an element on the top of the stack and pop which removes the last inserted element from the stack. <STOP>
8.2 Push and pop. <STOP>
8.2 Pop function and Push function <STOP>
8.2 push and pop. <STOP>
8.2 push -LRB- insert an item -RRB- pop -LRB- remove an item -RRB- <STOP>
8.2 Adding a new item and removing the item <STOP>
8.2 Push -LRB- insert -RRB- and pop -LRB- retrieve -RRB- . <STOP>
8.2 push and pop. <STOP>
8.2 Push and Pop. <STOP>
8.2 pop and push <STOP>
8.2 push -LRB- add an element -RRB- pop -LRB- remove an element -RRB- <STOP>
8.2 Push and pop. <STOP>
8.2 pop and push <STOP>
8.2 push -LRB- to add to a item the Stack -RRB- <STOP> Pop -LRB- to pull the last item added from an array. <STOP> -RRB- <STOP>
8.2 pop and push <STOP>
8.2 push and pop, push puts an object into the list, and pop takes the last object off. <STOP>
8.2 Push and Pop are the two main functions of a stack <STOP>
8.2 Push and Pop <STOP>
8.2 push, which adds an element to the stack ... and pop which takes an element off the stack <STOP>
8.2 Push and Pop, which add and remove data from the stack, respectively. <STOP>
8.2 push and pop <STOP>
8.2 pop to remove item push to insert an element <STOP>
8.2 Pop and push <STOP>
8.2 pop and push <STOP>
8.2 push adds an item to the top of the stack pop removes the top item from the stack <STOP>
8.2 push and pop. <STOP> Push adds a given node to the top of the stack leaving previous nodes below. <STOP> Pop removes and returns the current top node of the stack <STOP>
8.3 An array has a fixed size. <STOP> You can add and delete elements to the end of the array and you use a pointer to keep track of the last element added. <STOP> Each time you add or delete an element you update the pointer and check if it is equal to the max size of the array. <STOP>
8.3 By implementing an array of a pre-defined size with the bottom stack element stored at element 0 and the last element stored in the array is the top. <STOP> You increment top when an element is pushed and you decrement it when an item is popped. <STOP>
8.3 If you use a dynamically allocated array, you must provide a destructor and copy constructor. <STOP>
8.3 Create a int value that stores the "head" of the stack. <STOP> Increment the top when one element is pushed and decrement after it is popped. <STOP>
8.3 Use a pointer that always points to the end of the array list for push or pop modifications. <STOP>
8.3 if you used an array to implement a stack when you add an element just add it to the end of an array and remove items from end of array also. <STOP>
8.3 You predetermine the size of the stack as you would an array. <STOP> This type can not grow. <STOP>
8.3 Declare a variable that points the last item in the array, which increases -LRB- plus plus -RRB- when items are pushed onto the stack, and decreases -LRB- -- -RRB- when an item is popped off the top. <STOP>
8.3 Allocate an array of some size. <STOP> The bottom stack element is stored at some element. <STOP> Last index in the array is the top. <STOP> Increment top when one element is pushed, decrement after pop. <STOP>
8.3 You allocate an pre-defined array, the bottom element is stored at element 0, and the last index is the head. <STOP>
8.3 Make an array, make the bottom at spot 0, make the last spot in the array the top, and increment top when you ad <STOP>
8.3 treat the beginning of the array as the beginning of the stack <STOP>
8.3 Use an index value called top to keep track of the last element in the array. <STOP>
8.3 create an array and implement pointers that point to the next list item down and stack them up. <STOP>
8.3 for efficiency it is easiest to implement the left to right method, with the right most item being the one that is retrieved when a pop is performed, and a push places an object on the furthest element. <STOP>
8.3 Create an array based on a pre-defined size N There cannot be more elements than N. <STOP> Bottom stack element stored at element 0 last index in the array is the top <STOP> Increment top when one element is pushed, decrement after pop <STOP>
8.3 with the element added to the array, so that the last element added is at the end, and when the element is popped it takes the last element off the array <STOP>
8.3 Allocate an array of some pre-defined size. <STOP> Bottom stack element stored at element 0. The last index in the array is the top. <STOP> Increment top when one element is pushed. <STOP>
8.3 Create an array, size N. N plus plus when one element is pushed. <STOP> N --when one element is popped. <STOP>
8.3 define an array and keep track of a pointer to the last element as items are added <STOP>
8.3 By allocating an array of predetermined size, and an integer to track the top element of the stack. <STOP> The bottom member of the stack will go in element 0 of the array, and for each element pushed the "top" tracking integer is incremented. <STOP>
8.3 Allocate an array of some size, bottom stack element stored at element 0 <STOP>
8.3 you store the stack in the array but you have to keep in mind the first element <STOP>
8.3 You keep track of the last item entered into the array and do not allow the user access to the other parts of the array. <STOP>
8.3 using arrays, you are pushing one int at a time into the stack until you get to the end of your array <STOP>
8.3 by having a max number of elements, allocating an array with that number of elements, storing the elements starting at 0, and keeping track of how many elements are currently in the list <STOP>
8.3 Stack usually holds a bunch of items with the same type, therefore u can use an array, to hold the content of the stack and an integer top that holds the index of the element at the top of the stack. u Choose an array size. <STOP> Then the sequence of operations used. u have to decide what data types are needed for this stack data structure. <STOP>
8.4 You can add an element to the end of the linked list and update a pointer called top each time you modify the list. <STOP>
8.4 You implement a list in which the head pointer points to the element most recently pushed onto the list and the pop function changes the head pointer to point to the next to last element in the list and removes the element head pointer previously pointed to. <STOP>
8.4 This is the implementation of the stack using single linked list. <STOP> The operations performed on a stack are <STOP> 1 -RRB- push -LRB- -RRB- : This is the function which is for insertion -LRB- pushing -RRB- of an element into stack <STOP> It is similar to the insertion of an element at the end of a single linked list see the function insert end -LRB- -RRB- in the program for operations of single linked list <STOP> 2 -RRB- pop -LRB- -RRB- : This is the function which is for deletion -LRB- popping up -RRB- of an element from the stack <STOP> It is similar to the deletion of an element at the end of a single linked list see the function delete end -LRB- -RRB- in the program for operations of single linked list <STOP> 3 -RRB- stack display -LRB- -RRB- : This is the function which is for displaying the elements of a stack <STOP>
8.4 Using nodes to keep track of the head of the stack. <STOP> Then using Push -LRB- -RRB- and Pop -LRB- -RRB- to create the stack as needed. <STOP>
8.4 Use the head as the top of the stack, only modify the head when you push or pop ... push would add a new item to the head, pop would remove the item from the head. <STOP>
8.4 you implement a stack with a list by changing the pointer to the first element of the list to the new item and move the pointer from the top of the stack to the next item when removing an item. <STOP>
8.4 You dynamicly create space as the stack grows. <STOP> The stack can be as long as you need. <STOP>
8.4 Declare a pointer that points to the head of the linked list, only add and remove nodes from the beginning of the list. <STOP>
8.4 Creating a linked list. <STOP> Add an element to the top of the stack when pushing and deleting an element when popping. <STOP>
8.4 A singly-linked list is already a lot like a stack, it just depends on the way you address moving the head. <STOP>
8.4 make a list, make the bottom the head, add on the end and make the end top <STOP>
8.4 use the add function with a list as the beginning of the stack and remove for pop <STOP>
8.4 Use head as the top and push and pop nodes from the head. <STOP>
8.4 create a node based list that points to the next list item down. <STOP>
8.4 have the head of the list be the last item added, and a push just adds a new head. <STOP>
8.4 Create a new list. <STOP> Pop elements in the stack as needed. <STOP> Push the stack to remove items, unless the stack is empty. <STOP> The top item is at the head of the list. <STOP> The last item is at the end. <STOP>
8.4 adding the element to the end of the list so that it links to the element before it. when popping the element it takes the last element in the list and sets the previous one as the end of the list. <STOP>
8.4 You can implement a stack using arrays or and linked list. <STOP> By the use of pointers, that point element -LRB- node -RRB- to the next element in the stack. <STOP> By the use of pointers, the stack becomes a linked list. <STOP>
8.4 Elements are only inserted and removed from the head of the list. <STOP> There is no header node or current pointer. <STOP>
8.4 use a linked list and keep track of a pointer that points to the first item <STOP>
8.4 A singly linked list can already be easily used for LIFO data storage. <STOP> Members of a stack can simply be pushed and popped from a list, the first item in will be the last out. <STOP>
8.4 using pointer <STOP>
8.4 the top is the first pointer. <STOP>
8.4 Keep a pointer pointing to the last element entered at the front of the array and move the pointer "back" when you delete an element. <STOP>
8.4 using linked list, you are pushing the node that contains each int to the stack until you get to the end of your linked list <STOP>
8.4 have a linked list, and for each push, add an item onto beginning of the list, and for each pop remove the first element in the list. <STOP>
8.4 Using a linked list is one way to implement a stack so that it can handle essentially any number of elements. <STOP> It is usually convenient to put a data structure in its own module, thus, you will want to create files stack. h and a stack. c <STOP>
8.5 List based is preferred because it is not constrained to a fix size. <STOP> The down fall is that it takes up more memory because each node has at least two parts, the item and the pointer. <STOP>
8.5 List based is preferred because the stack you create is not limited in size and can increase or decrease in size as needed. <STOP>
8.5 Array-based prevents the push operation from adding an item to the stack if the stack 's size limit, which is the size of the array, has been reached. <STOP> List-base much simpler to write and does not have a fixed size. <STOP>
8.5 Array based because they are faster, easier to keep track of and less complexity in code. <STOP>
8.5 list-based because it does not use a fixed size like an array would. <STOP>
8.5 usually linked list because it does not have a fixed size. <STOP> But if you know or want to set a max size array is better. <STOP>
8.5 List-based. <STOP> Allows more flexablity with size of the stack. <STOP>
8.5 Linked lists are preferred for implementing stacks because they are not limited to a set number of elements. <STOP>
8.5 The list-based implementation is preferred since the big O -LRB- 1 -RRB- is very efficient. <STOP>
8.5 Linked list implementation is preferred. <STOP> That way, the list can be moved along without iteration. <STOP>
8.5 list because it its size is not determined <STOP>
8.5 Linked list because it takes up less memory and is scalable <STOP>
8.5 List-based, as the list can be grown dynamically, and as the head node is easily accessible. <STOP>
8.5 list based because the nodes are easier to work with and can be traversed easier <STOP>
8.5 list based, because of the lower processing overhead and nearly unlimited space, due to linked list design. <STOP>
8.5 list-based <STOP> It can grow and shrink dynamically, unlike the fixed size array. <STOP>
8.5 list based because arrays can become full, lists can grow or shrink as needed <STOP>
8.5 List-bases implentation is preferred. <STOP> One of the main reasons is because of that the list has no fixed size. <STOP>
8.5 Array is preferred. <STOP> Linked list implementation requires extra space to store pointers. <STOP> Space is allocated dynamically in the list-based which takes more time. <STOP>
8.5 link list is preferred because it makes pushing elements easier because there is no limit other than memory to the number of elements <STOP>
8.5 List-based implementation is much easier to implement, and allows the stack to scale as necessary. <STOP> It is therefore the preferred implementation. <STOP>
8.5 Array based implementation requires less memory than a list based. inceasing the size of a resizeable array can waste storage and time <STOP>
8.5 in an array based stack you would need to pre-determine a size, where in a list you can increase or decrease the size however you want. <STOP>
8.5 A list-based implementation is preferred because the list is more flexible than a array. <STOP>
8.5 i would think a list based would be better because you can change the pointers of the nodes to add or remove things from your stack <STOP>
8.5 list based, because it is much more flexible, easier to use, and doesnt need to have a max size defined when it is made. <STOP>
8.5 array based list is preferred because it can hold any size as long as u specify it. <STOP>
8.6 They are converted to post fix expressions. <STOP> It still follow the order of precedence for the operators. <STOP>
8.6 They are first converted to postfix expressions and then evaluated. <STOP>
8.6 Computers cannot evaulate infix expressions, it must first convert infix to postfix expression then it can evaluate. <STOP>
8.6 By using parentheses to have order in the expression. <STOP>
8.6 In postfix notation. <STOP>
8.6 computers usually convert infix expressions to post fix expression and evaluate them using a stack. <STOP>
8.6 they are converted to postfix <STOP>
8.6 Infix expressions are interpreted as postfix expressions by implementing stacks. <STOP>
8.6 They are first converted into an equivalent postfix expression so it can be read by the computer. <STOP>
8.6 The computer translates the infix expression to a postfix expression, then solves. <STOP>
8.6 in postfix format <STOP>
8.6 they use parenthisis and a stack to determine which evaluations need to be made first <STOP>
8.6 By throwing variables into a postfix expression and operands onto a parentheses regulated stack until end parentheses and enough variables to operate on are encountered. <STOP>
8.6 by being passed to the function by a leading term <STOP>
8.6 i have an hard time explaining this so i will show how infix is evaluated instead. <STOP> Start with an infix expression, like, -LRB- -LRB- -LRB- 5 plus 2 -RRB- multiplied by 5 -RRB- plus -LRB- 400 divided by -LRB- 2 plus 3 -RRB- -RRB- -RRB- , and push items until you get a " -RRB- " and once that happens, perform the operations until you reach an " <STOP> -LRB- " <STOP> ... with that complete, you will now have <STOP> -LRB- -LRB- 7 multiplied by 5 -RRB- plus -LRB- 400 divided by -LRB- 2 plus 3 -RRB- -RRB- -RRB- as now the expression that will be evaluated ... perform last step again ... <STOP> -LRB- 35 plus -LRB- 400 divided by -LRB- 2 plus 3 -RRB- -RRB- -RRB- is now the stack ... repeat agian ... <STOP> -LRB- 35 plus -LRB- 400 divided by 5 -RRB- -RRB- is now the stack after that ... repeat ... <STOP> -LRB- 35 plus 80 -RRB- is now the stack, repeat again ... <STOP> 115 is now the stack, and is returned. <STOP>
8.6 The infix expression is converted to postfix form <STOP>
8.6 by converting them to postfix expressions and putting the operations in a stack <STOP>
8.6 The computer converts the infix expression to postfix form. <STOP> Then evaluates the postfix expression. <STOP>
8.6 infix expressions are converted to postfix expressions before they can be evaluated by a computer. <STOP> Operands stay in the same order. <STOP> Operators always follow the operands. <STOP>
8.6 infix expressions are pointers evaluated by reference to the memory location <STOP>
8.6 computers convert infix expressions to postfix form before evaluation <STOP>
8.6 convert infix expressions to postfix expression and evaluate the postfix expression <STOP>
8.6 When an operand is entered, the computer <STOP> Pushes it onto a stack <STOP> When an operator is entered, the computer <STOP> Applies it to the top two operands of the stack <STOP> Pops the operands from the stack <STOP> Pushes the result of the operation onto the stack <STOP>
8.6 Computers convert an infix expression into a postfix expression. <STOP> They then push the numbers onto a stack and pop them out as they are needed. <STOP>
8.6 infix expressions are converted to postfix, -LRB- i. e. 3 plus 2 is changed to 32 plus -RRB- <STOP>
8.6 they are transformed into post-fix expressions, then evaluated with a stack. <STOP>
8.6 Writing arithmetic expressions is called infix notation. <STOP> This is because a binary operator -LRB- like "plus" <STOP> -RRB- is written in between its two operands -LRB- as in "a plus b" -RRB- . <STOP> There are two alternative forms of notation used in certain situations. <STOP> One is prefix notation, in which an operator is written before its operands. <STOP> In prefix notation, the sum of a and b is written "plus a b". <STOP> This is the notation used to write function calls in mathematics and computer science. <STOP> It is also used in the Lisp and Scheme programming languages. <STOP> In postfix notation, an operator is written after its operands. <STOP> The sum of a and b is written "a b plus". <STOP> -LRB- You may have seen this as "reverse Polish notation". <STOP> -RRB- Postfix notation forms the conceptual basis for the way that arithmetic expressions are evaluated by a computer. <STOP> One important characteristic of both postfix and prefix notations is that they are unambiguous; no parentheses are needed to indicate the order of operations. <STOP>
8.7 isEmptry -LRB- -RRB- or or determines if the stack is full or not pop -LRB- -RRB- or or to remove the top element if it is not the on you are looking for search -LRB- -RRB- or or you compare each element of the stack to the data you are looking for. <STOP>
8.7 You would have to keep using peek or getTop to see what the top element is then popping the top element until peek or getTop provides the element you are looking for. <STOP>
8.7 Push adds a given node to the top of the stack leaving previous nodes below. <STOP> Pop removes and returns the current top node of the stack. <STOP>
8.7 Using linked lists and stacks, you would need a temp stack to retain the values. <STOP> Then you would use the Pop -LRB- -RRB- function to pop off each element and then compare it. <STOP> If its not the element your looking for, Push -LRB- -RRB- it to the temp stack. <STOP> Repeat until the element is found. <STOP> When you find it, Pop -LRB- -RRB- off the temp stack back onto the regular stack to have a complete stack again. <STOP>
8.7 Pop each item off the top until you find what you are looking for. <STOP> If the stack ends up empty and you never found the item, then it does not exist in the stack. <STOP> It may also be necessary to save the popped values in case you want to recreate the stack. <STOP>
8.7 if the stack is implemented using an array you could simply search the array for the item. <STOP> If the stack is implemented using a linked list you would have to pop the values off of the stack until either the value is found or the stack is empty, you would then have to have the items put back into the list. <STOP>
8.7 You need to pop each item on the stack and compare the item. <STOP> Once the item is found, no more items need to be removed. <STOP>
8.7 Pop an element from one stack, check to see if it is the desired element, if not push it onto another stack. <STOP> When finished, pop the items from the second stack and push them back onto the first stack -LRB- this will ensure the order of the elements is maintained -RRB- . <STOP>
8.7 Basically pop the stack until you find the given element. <STOP>
8.7 Iterate through the stack, checking the number against the current element. <STOP>
8.7 pop and push <STOP>
8.7 pop all elements off stack until you find that element and then push the popped elements back on the stack <STOP>
8.7 Keep popping nodes and storing them in an alternate stack until the given element is found, then pop the given element and push the previously popped nodes back onto the stack. <STOP>
8.7 either traverse the entire list and pop the given part or create a pointer system that automatically points to it. <STOP>
8.7 Depends on the type of stack, on a true stack you will haft to pop all of the elements of the stack until you find the element you want, and then after that you will need to push all the elements that where removed back in to the stack in the order that they where removed. <STOP> With a Java style stack, where there is a peek function, it will return the element you wanted instead of requiring you to perform all the excessive actions that are required from a true stack. <STOP>
8.7 if top item! equals given element pop the stack. <STOP> Repeat until item is found or stack is empty <STOP>
8.7 could traverse through the list or array to find the element. <STOP>
8.7 you need the pop opertation to go throught the stack and find the element. <STOP>
8.7 createStack, push, isEmpty, pop, and a boolean return value. <STOP>
8.7 you would have to traverse the stack popping each element to search it <STOP>
8.7 Pop each element off the stack -LRB- and into another stack for storage -RRB- until the desired element is found. <STOP>
8.7 pop operation <STOP>
8.7 to pop elements then push them back <STOP>
8.7 A function to keep track of the elements popped and a function to put the popped elements backinto the function. <STOP>
8.7 you would pop each element and compare it to what you are looking for and then push it back on the stack so that it is not lost <STOP>
8.7 you would need to perform a search through the list of elements -LRB- i dont really understand what this question is asking ... its not very clear? <STOP> -RRB- <STOP>
8.7 StackPush -LRB- -RRB- <STOP> StackPop -LRB- -RRB- <STOP> StackIsEmpty -LRB- -RRB- <STOP>
9.1 A data structure in c plus plus which is a collection of data that is kept in order. <STOP> First in first out. <STOP>
9.1 a queue is a list of objects in a particular order that is read one at a time starting at the first followed by the second and so on. <STOP>
9.1 A queue is an abstract data structure in which operations are performed at both ends giving the queue first in first out behavior. <STOP>
9.1 A queue stores a set of elements in a particular order. <STOP> Its principle of operation is FIFO -LRB- first in first out -RRB- , which means the first element inserted is the first one to be removed. <STOP>
9.1 An ADT whose first inserted item is the first item removed. <STOP> This uses the FIFO idea where items enter a queue at its back and leave at its front. <STOP>
9.1 Last in, last out architecture. <STOP> It works the same way a line at the bank would work, the person that is been waiting the longest gets served first. <STOP>
9.1 a queue is a data structure that stores elements in a First in First out order. <STOP>
9.1 A waiting list of items that operation in a FIFO -LRB- first in first out -RRB- order. <STOP>
9.1 A queue is similar to an array, except that the data can only be accessed sequentially rather than at random. <STOP> Unlike a stack, a queue follows FIFO. <STOP> First in, First out. <STOP>
9.1 is a particular kind of collection in which the entities in the collection are kept in order and the principal -LRB- or only -RRB- operations on the collection are the addition of entities to the rear terminal position and removal of entities from the front terminal position. <STOP> First in First Out -LRB- FIFO Method -RRB- . <STOP>
9.1 Like a linked list but first in first out <STOP>
9.1 A queue is a FIFO data structure. <STOP>
9.1 A queue is a first in first out data structure. <STOP>
9.1 Its like a stack, but uses the linked list to stack a little differently. <STOP> It is FIFO so the first thing enqueued is the first thing dequeued <STOP>
9.1 A first in, first out Abstract Data type that can be used to store values. <STOP>
9.1 Stores a set of elements in a particular order with a First In, First Out principle <STOP>
9.1 object that stores elements in order that follows first in first out. the first element added is the first one to come off. <STOP>
9.1 A quese is an list that stores a set of elements in a particular order. <STOP> It has Stack principle, but in this case, its "First In, First Out". <STOP> The first element inserted is the first element to be removed. <STOP>
9.1 a finite ordered list with zero or more elements, based upon First In First Out <STOP>
9.1 a data structure that performs operations in the order of first in first out FIFO <STOP>
9.1 A Queue is a "first in first out" data structure, such that the first element added is also the first removed. <STOP>
9.1 Queue is a buffer, which store element in a particular order <STOP>
9.1 stores a set of elements where the first element in, is the first element to be removed <STOP>
9.1 A data structure that removes nodes from the head and adds nodes at the tail. <STOP>
9.1 a queue is a list of things that follows the first in first out behavior <STOP>
9.1 a queue is a storage container that holds its objects in a first in, first out priority <STOP>
9.1 The queue is another data structure. <STOP> A physical analogy for a queue is a line at a bank. <STOP> When you go to the bank, customers go to the rear -LRB- end -RRB- of the line and customers come off of the line -LRB- i. e., are serviced -RRB- from the front of the line. <STOP>
9.2 enqueue which adds data to the queue and dequeue which deletes data from the queue <STOP>
9.2 enqueue, which inserts a specified element at the head of the specified queue, and dequeue, which removes the specified element from the queue. <STOP>
9.2 The two main functions are enqueue which inserts an item at the back of the queue and dequeue which removes an item from the front of the queue. <STOP>
9.2 The two main functions are enqueue and dequeue. <STOP>
9.2 Enqueue and Dequeue <STOP>
9.2 Enqueue and Dequeue <STOP>
9.2 enqueue insert into queue dequeue remove element <STOP>
9.2 Remove the item added first, add items to the back. <STOP>
9.2 The two main functions of a queue are enqueue and dequeue. <STOP>
9.2 enqueue and dequeue. <STOP>
9.2 enqueue and dequeue <STOP>
9.2 Enqueue and Dequeue <STOP>
9.2 enqueue and dequeue <STOP>
9.2 enqueue and dequeue <STOP>
9.2 enque -LRB- Data -RRB- , Deque -LRB- -RRB- <STOP>
9.2 enqueue and dequeue <STOP>
9.2 enqueue and dequeue <STOP>
9.2 The two functions are, Enqueue and Dequeue <STOP>
9.2 enqueue, dequeue <STOP>
9.2 enqueue, that adds an item to the queue dequeue, that takes the first item out of the queue <STOP>
9.2 Enqueue and dequeue, which add and remove elements from the queue <STOP>
9.2 Enqueue and Dequeue <STOP>
9.2 dequeue and enqueue <STOP>
9.2 enqueue and dequeue <STOP>
9.2 enqueue and dequeue <STOP>
9.2 enqueue dequeue <STOP>
9.2 rear and front <STOP>
9.3 Make use of a front pointer and a tail pointer. <STOP> When the tail pointer reaches the end of an array it gets reset to the front of the array. <STOP> If the two pointers are equal then the queue is either full or just has one element. <STOP>
9.3 you create an array with the max size of your queue and adjust the items to make them follow FIFO procedure. <STOP>
9.3 By implementing an array and only adding items to the end of the array and only removing items from the beginning of the array. <STOP>
9.3 For applications in which a fixed-sized queue does not present a problem, you can use an array to represent a queue. <STOP>
9.3 Keep track of the front and the back of the array as you increase and decrease the elements inside the array. <STOP>
9.3 Declare the size of an array, and have special conditional statements -LRB- pointers -RRB- to make sure you re-use ALL of the array. <STOP> Say, you have an array of 20 elements, you load up 18, then dequeue 3, when you enqueue 4 more elements, you want to loop back to index 0 and continue from there ... this process saves resources. <STOP>
9.3 you could use the first element of the list as the remove point and insert at the end f you do this you would have to shift the elements down each time you remove an item unless you make the array circular. <STOP>
9.3 Utilizing indexes for the front and the back. <STOP> Front is 0 and as you add items the back index is incremented. <STOP>
9.3 Declare two variables, front and rear, to be used to denote which elements in the array can be accessed. <STOP> Increment rear whenever data is enqueued to the end and increment front whenever data is dequeued. <STOP>
9.3 It is an array of fixed size. <STOP> A queue of maximum N elements. <STOP>
9.3 make an array of a size, and add on to the front and delete from the back, keep track of the two so that you know when it is full and where to add or subtract from <STOP>
9.3 By using the beginning of the array as the removal point of the queue -LRB- or beginning of the queue -RRB- and the ith element as the end of the queue. <STOP>
9.3 add in data from the first element to the last, take out data from the first element to the last. <STOP>
9.3 you can take the array and put it in a queue stack or you can just traverse the list and keep track of top and bottom <STOP>
9.3 create a fixed array size, with with 2 integers to point to the beginning and the end of the que, and special cases to know when the que is empty or full. <STOP>
9.3 Keep track of the front and rear indexes. <STOP> Either: 1 -RRB- Dequeue items by shifting the array left <STOP> 2 -RRB- Use wrapped configuration <STOP>
9.3 add items into a fixed size array, pull the items out by calling on them with the starting index, increase starting index so when it calls again its now the next index element in the array. <STOP>
9.3 To use and array to implement a Queue, element or item 0, should be the top element in the array. <STOP> Every time an element is inserted, all the items in the array are pushed back one space. <STOP> The top element is always removed first. <STOP>
9.3 fixed size array with max N elements. <STOP> Need to keep track of front and rear of array. <STOP>
9.3 by keeping track of a front item and a rear item, or with a circular array that uses the modulo function <STOP>
9.3 Using an array for a queue, the size of the array allocated limits the size of the queue. <STOP> An array based queue class must keep track of both the front and back of the queue, which may need to wrap around the array. <STOP>
9.3 A pointer based implementation of a queue could use a linear linked list with two external pointers, one to the front and one to the back <STOP>
9.3 remove the element then shift the elements one space back <STOP>
9.3 By having the head pointer point to the first or least current data entered and having the tail point to the most current data entered. <STOP> A method must be created so that the tail pointer does not leave the array. <STOP>
9.3 an array is a type of queue with a fixed length <STOP>
9.3 your storage class has an array, and you keep track of the index of the first and last item in the array, and wrap around when end of the array is full <STOP>
9.3 Boolean isFullQ -LRB- queue -RRB- :: equals rear equals equals MAX QUEUE SIZE-1 <STOP>
9.4 A list can have unlimited elements in it. <STOP> You can push a node onto the end of the list and pop the one in the front. <STOP>
9.4 theoretically you could do it two ways one of which uses more processing power and memory no larger than the queue is ever at when full and the other which uses almost infinite memory. <STOP> The more practical method would be two place the items in an array and remove the item in position one of the array after which you can shift the array and add another element if required. <STOP> The other option which can use infinite memory when used for long term queues such as job scheduling that goes nonstop for extended periods. that is to implement an array and add the items read item one raise your counter value to two ecetera and continue adding more elements to the array. the downside to this method is after you use element one it is still in memory. or im crazy who knows <STOP>
9.4 By implementing a list in which a tail pointer points to the item most recently inserted onto the back of the list and a head pointer which points to the item least recently inserted onto the list. <STOP> Also, items can only be removed from the front of the list and can only be added to the back of the list. <STOP>
9.4 You can use list to represent the items in a queue. <STOP>
9.4 Have a pointer to the last element in the list and then use enqueue to insert items there. <STOP> Link the first and last elements together to dequeue the list. <STOP>
9.4 Enqueue to the end of the linked list ... dequeue items from the beginning -LRB- head -RRB- of the list. <STOP>
9.4 you use the first element in the list as the remove point for the queue and insert items at the end of the list. <STOP>
9.4 Utilizing a front pointer and a back pointer. <STOP> The front poiner and back pointer points to the first item into the queue. <STOP> As you add items, the front remains the same but the back poiner "next 'points to the new item and the new item is assigned to become the 'new" back pointer. <STOP>
9.4 Implement a linked list that only allows nodes to be added to the tail and can only be retrieved from the head. <STOP>
9.4 Check if list is empty and add elements to the list. <STOP>
9.4 make a linked list and add on to the front and delete from the back, keep track of both to do so. <STOP>
9.4 by making the head of the list the beginning of the queue and the last listed item the insertion point of the queue <STOP>
9.4 throw in data at the head and take it out at the tail <STOP>
9.4 You create a list of nodes that had a head and a top pointer, and the functions are basically the same substituting pop and push with enqueue and dequeue <STOP>
9.4 fairly easy ... singly linked list with a pointer to the head and tail of hte list. deque first item in que, create temp pointer to next element, delete head, and then make head the temporary pointer. enque new item, use pointer to end of list, add a new item to the next item of the tail, and make the tail the next item of the current tail. <STOP>
9.4 Use a linked list with 2 pointers, one to the front and one to the back. <STOP> As long as back! equals front, the queue is not empty. <STOP>
9.4 create a node with the input data, continue to add to the list. when dequeueing get the first elements data and set the next element in the list as the new first element <STOP>
9.4 A linked list with Stack principles. <STOP> The Queue 's top element is the element that is always being removed first. <STOP> Must use nodes to contain each element, with a pointer to the top element, which also could be called the head pointer. <STOP>
9.4 linked list checking for front and rear. <STOP> Keep enqueueing elements until front equal to rear 1. <STOP>
9.4 a queue can be implemented in a list by keeping track of two pointers, a head and a tail <STOP>
9.4 each element of a queue can be allocated in the nodes of an linked list. <STOP> New elements should be added to the head of the list, with each dequeued element coming off the tail. <STOP>
9.4 Implement the operation dequeue -LRB- -RRB- as the list operation remove -LRB- 1 -RRB- and the operation getFront -LRB- queueFront -RRB- as the list operation retrieve -LRB- 1, queueFront -RRB- <STOP>
9.4 remove the first element and reference the second element as the new head of the list. <STOP>
9.4 By creating and adding nodes at the end of the list and removing the nodes from the beginning of the list. <STOP>
9.4 you would have your list and add a back pointer so that your program knows where the end is <STOP>
9.4 your queue storage class has a list, and for enqueue, you add the item to the end of the list, and for dequeue you return the first item in the list <STOP>
9.4 temp implies next equals NULL; if -LRB- front -RRB- -LRB- rear -RRB- implies next equals temp; else front equals temp; rear equals temp; <STOP>
9.5 List based. <STOP> Because it is on the run time order of N, also it does not have a limited size like an array does <STOP>
9.5 linked list based. because it does not store the items linearly in memory but instead as individual blocks. <STOP>
9.5 List based is preferred because there are no size restrictions. <STOP>
9.5 A list-based implementation would be preferred. <STOP> The array is slightly more complicated, where you would need to keep track of both front and rear. <STOP>
9.5 List-based. <STOP> Array-based queues have a way to complicate things to an extent. <STOP>
9.5 List-based. <STOP> Less code, and no size limitation or declaration ... which means it is also more efficient and versatile. <STOP>
9.5 list based is prefered because it does not have a set size and insertion and deletion can be done very quickly of you keep pointers to first element and last. <STOP>
9.5 List based is preferred because there are space issues with array based due to rightward drift. <STOP> The fix for rightward drift requires constant shifting of the queue data. <STOP>
9.5 Similar to stacks, linked lists are preferable for queues because the size can be adjusted. <STOP>
9.5 array-based is preferred because all you have to keep track of is the array itself and the count. <STOP>
9.5 list because its size is not defined <STOP>
9.5 List-based, because when you enqueue -LRB- or dequeue depending upon your implementation -RRB- you would need to shift all elements to another space with an array, causing a horrid time complexity for large data sets, where as you can just modify the pointers in a list for a constant time complexity <STOP>
9.5 queue 's are best with lists, especially if the tail is kept track of, as the list can be dynamically grown without losing track of the head or tail. <STOP>
9.5 list based, its much simpler and the run time is better <STOP>
9.5 list based, because of the lessened memory usage initially, and the increased limits on how large the que can become. <STOP>
9.5 List-based because it is not fixed size. <STOP>
9.5 list, its dynamic and no size needs to be declared <STOP>
9.5 list bases implementatoin is best because you use pointers to keep track of the front and back pointers. <STOP> Easier to maintain, but uses more memory <STOP>
9.5 list based. <STOP> It can dynamically grow and has fewer restrictions. <STOP>
9.5 list based is preferred because memory allocation is not an issue <STOP>
9.5 List based solutions are preferred, because they allow for queues of any size. <STOP>
9.5 I think array based is batter, because of fixed size, but on other had list base is more flaxible. <STOP> You do not have to worry about the size <STOP>
9.5 list based because you dont need to shift the elements like you do in array based queues <STOP>
9.5 List-based because memory is not constricted. <STOP>
9.5 list based because the array based has to have a fixed size, it cannot be added to or removed from as easily <STOP>
9.5 list-based array is easier and more scalable <STOP>
9.5 list based becuase an arrary based has to have an arrary size and needs to be pre-defined and cannot be changed dynamically. <STOP>
9.6 Push. <STOP>
9.6 push, which inserts something at the top of the stack. <STOP>
9.6 The stack operation corresponding to enqueue in queues is the push operation. <STOP>
9.6 Push in a stack operation corresponds to the enqueue operation in queues. <STOP> These operations insert a new item into one end -LRB- the top and back, respectively -RRB- of the ADT. <STOP>
9.6 The stack operation is almost the opposite of the enqueue operation. <STOP>
9.6 push equals enqueue pop equals dequeue <STOP>
9.6 push <STOP>
9.6 Not sure what this question means. <STOP> You can use the stack "push" operation and the enqueue operation to detect palindromes. <STOP>
9.6 Enqueue is the queue equivalent of push, and dequeue is the queue equivalent to pop. <STOP>
9.6 Push operation. <STOP>
9.6 push <STOP>
9.6 push <STOP>
9.6 push <STOP>
9.6 push <STOP>
9.6 that would be the push operation, if it put the item at the end of the list. <STOP>
9.6 push <STOP>
9.6 push <STOP>
9.6 the Push method in the stack operations. <STOP>
9.6 push <STOP>
9.6 enqueue corresponds with push dequeue corresponds with pop <STOP>
9.6 Push corresponds with enqueue, both very similarly place new elements into their stack or queue <STOP>
9.6 FIFO: First in First out <STOP>
9.6 push <STOP>
9.6 Push <STOP>
9.6 push <STOP>
9.6 push <STOP>
9.6 push <STOP>
9.7 A stack, some printing jobs might have a higher priority than others and they can be easily inserted at the front of the list or anywhere between. <STOP>
9.7 a queue otherwise some things would never be printed. <STOP>
9.7 A queue is more appropriate for scheduling printing jobs because queues have first in first out behavior. <STOP>
9.7 Queue, its better to be FIFO than LIFO -LRB- stack -RRB- . <STOP>
9.7 Queue of course! <STOP>
9.7 Queue, the person who wanted to print first should be first served. <STOP>
9.7 queue because it guarantees that job are executed in the order they come in. <STOP>
9.7 queue <STOP>
9.7 Queues would be preferable to stacks for use as scheduling print jobs because it would print jobs in the order that they were sent to the printer. <STOP>
9.7 a queue. <STOP>
9.7 queue <STOP>
9.7 a queue <STOP>
9.7 Queue 's are more appropriate, as printers are usually first come, first serve. <STOP>
9.7 queue <STOP>
9.7 queue, because of the first in first out principles, and if it was a stack it would be last in last out, because it could possibly not let the first item that was added get removed in a timely manner. <STOP>
9.7 Queue <STOP>
9.7 a queue <STOP>
9.7 A Queue data structure is more appropriate for scheduling printing jobs at a printer. <STOP> The first job sent to the printer is the first job printed. <STOP>
9.7 a queue. <STOP> It would not be unfair for the first job to finish last. <STOP>
9.7 a queue, because it takes the job that has waited the longest <STOP>
9.7 A queue is more appropriate, because the clients which have waited the longest should be the first served. <STOP>
9.7 Queue <STOP>
9.7 a queue <STOP>
9.7 Queue <STOP>
9.7 i would say that a queue is better because the first thing you try to print should be the first one to come out of the printer -LRB- FIFO -RRB- <STOP>
9.7 a queue, because you want the jobs to execute in the order that they are received <STOP>
9.7 queue <STOP>
10.1 A hierarchy of nodes that are sorted in a particular order. <STOP> Each node has a ancestor -LRB- except for the root -RRB- and children -LRB- except for the leaves -RRB- . <STOP>
10.1 A tree is a finite set of one or more nodes with a specially designated node called the root and the remaining nodes are partitioned into disjoint sets where each of these sets is a tree. <STOP>
10.1 A tree is a finite set of one or more nodes such that: there is a specially designated node called the root. <STOP>
10.1 A connected, undirected graph without cycles. <STOP>
10.1 A data structure that contains a root, internal nodes and external nodes. <STOP> Each node references another node by means of pointers -LRB- pass-by-reference -RRB- . <STOP> The root is the "base" of the tree, it has no parents. <STOP> A "leaf" is a node at the end of the tree which points to NULL. <STOP>
10.1 a tree is a series of nodes where each node has links to other nodes. <STOP>
10.1 an infinite set of nodes that have a root and descendants, and each addition is a leaf. <STOP>
10.1 A set of one or more nodes that are hierarchically organized, with one special root node. <STOP>
10.1 A tree is a finite set of one or more nodes such that there is a specially designated node called the root. <STOP>
10.1 one or more nodes in a hierarchy starting with the root and branching off like a tree to subtrees <STOP>
10.1 A tree is a data structure where nodes are linked to each other in a hierarchical manner. <STOP>
10.1 a grouping of data in a parent to child structure <STOP>
10.1 It is a list of numbers in a list made by comparing values of nodes already in the tree and adding to the appropriate spot. <STOP> Its a list made up of nodes with left and right pointers. <STOP>
10.1 A tree is a branched data structure with nodes, and leaves ... a special node called root has no parent node, but however like all other nodes can and does have 2 nodes that it links to, namely one on the right, and one on the left. <STOP>
10.1 It organizes data in a nonlinear, hierarchical form, where items can have more than one successor. <STOP> Partitioned into a root node and subsets are general subtrees of the root. <STOP>
10.1 A tree is a finite set of one or more nodes such that there is a specially designated node called the root. <STOP> The remaining nodes are partitioned into n is greater than or equal to 0 disjoint sets T the n plus 1, where each element set is a tree. <STOP>
10.1 A finite set of nodes that starts with the root and terminates with leaves. <STOP>
10.1 a set of data arranged with pointers. each element can have many pointers, but no two pointers point to the same element <STOP>
10.1 A Tree is a data structure with one or more data nodes, each of which contains some data. <STOP> Each node itself can have a number of attached child nodes, creating the branched structure Trees are named for. <STOP>
10.1 a finite collection of nodes, where it starts with an element called the root, which has children, and its children have children until you get to the leaves which are the last elements and have to children <STOP>
10.1 A nonlinear, two-dimensional data structure. <STOP>
10.1 a finite set of one or more nodes such that there is a root node and all other nodes are split into trees of lesser value than the root <STOP>
10.1 A finite number of nodes such that there is one root node, each node has a certain number of children nodes, and each child is also a tree <STOP>
10.1 A type of data structure in which each element is attached to one or more elements directly beneath it. <STOP>
10.2 Each level of a generation in the tree, some people do not count the root as a generation <STOP>
10.2 The height of a tree is in terms of the levels of its nodes such that, if the tree is empty its height is 0 otherwise its height is equal to the maximum level of its nodes. <STOP>
10.2 The height of a tree is the number of nodes on the longest path from the root to a leaf. <STOP>
10.2 The number of nodes on the longest path from the root of the tree to a leaf. <STOP>
10.2 Height equals the number of times you must progress down the levels of a tree to reach a leaf of the greatest distance from the root. <STOP>
10.2 the height of a tree is the length from the root to the furthest leaf <STOP>
10.2 The height is the number of generations -LRB- levels -RRB- from the root. <STOP>
10.2 The height of a tree is the number of levels between the root and the leaf farthest away from it. <STOP>
10.2 is the depth of its furthest leaf <STOP>
10.2 the number of nodes from root to leaf <STOP>
10.2 the distance from the deepest leaf to the root <STOP>
10.2 the number of generations or levels of a tree <STOP>
10.2 The intensity of the children. <STOP> Say you begin with one node, Thats one height. <STOP> Then you add two children to that node and then two children to each of those nodes and two children to each of THOSE nodes. <STOP> Youre current height would be 4. <STOP>
10.2 the number of levels of a tree, like a tree can have at minimum a depth of 3 and at most a height of 8 for 8 nodes. <STOP>
10.2 The number of nodes on the longest path from the root to the leaf. <STOP>
10.2 The height of a tree is the number of nodes on the longes path from the root to a leaf. <STOP>
10.2 is equal to the number of levels. levels between the root node and the terminal nodes. <STOP>
10.2 the number of generations or levels the tree has <STOP>
10.2 The height of a tree is the depth of its subtrees, that is, how many layers deep it is. <STOP>
10.2 is the number of generations in the tree <STOP>
10.2 The number of nodes on the longest path from the root to a leaf. <STOP>
10.2 the number of distinct levels of separation <STOP>
10.2 the height of a tree is how many levels of nodes that it has <STOP>
10.2 The connections between elements are called branches. <STOP> Trees are often called inverted trees because they are normally drawn with the root at the top. <STOP>
10.3 A leaf is a child of a parent node that has no children nodes of its own. <STOP>
10.3 A leaf is a node with no children. <STOP>
10.3 A node with no children. <STOP>
10.3 A tree node with no children. <STOP>
10.3 And end point of the tree ... a node that does not have any children. <STOP>
10.3 a node with no children. <STOP>
10.3 A new item to the tree --a child <STOP>
10.3 A leaf is a node with children, it is a terminating node. <STOP>
10.3 The node with degree 0. <STOP>
10.3 the node with degree 0 <STOP>
10.3 a leaf is a node with no children <STOP>
10.3 the last child on any branch <STOP>
10.3 The last value in the tree. <STOP> A value with no children attatched. <STOP>
10.3 a node with no children. <STOP>
10.3 A node with no children. <STOP>
10.3 A leaf is a node with no children <STOP>
10.3 a node with degree 0. last node in the tree and furtherest away from the root. <STOP>
10.3 an endpoint on a tree that contains no pointers or pointers that are set to null <STOP>
10.3 A leaf is a node with no children. <STOP>
10.3 an element in a tree that has no children <STOP>
10.3 A node with no children. <STOP>
10.3 a leaf is a node that has no children nodes <STOP>
10.3 a leaf is a node with no children <STOP>
10.3 The elements at the very bottom of an inverted tree -LRB- that is, those that have no elements below them -RRB- are called leaves. <STOP>
10.4 A tree data structure in which each done has at most two children, typical called left and right nodes. <STOP> The right node is usually greater than the left node and the parent node. <STOP>
10.4 A binary tree is a set of nodes that is either empty or partitioned into a root node and one or two subsets that are binary subtrees of the root. <STOP> Each node can have no more than two children, a right and a left child. <STOP>
10.4 A set of nodes that is either empty or partitioned into a root node and one or two subsets that are binary subtrees of the root. <STOP> Each node has at most two children, the left child and the right child. <STOP>
10.4 A set of zero or more nodes, partitioned into a root node and two possibly empty sets that are binary trees. <STOP> Thus, each node in a binary tree has at most two children, the left child and the right child. <STOP>
10.4 A tree in which each parent has a maximum of 2 children. <STOP>
10.4 a tree where each node has at most 2 children. <STOP>
10.4 a tree with up to two children or a right subtree and a left subtree <STOP>
10.4 A binary tree is a tree in which all nodes have a maximum of two degrees, or can only have two children each. <STOP>
10.4 a binary tree is a tree data structure in which each node has at most two children. <STOP>
10.4 a tree with only 2 joints, left and right <STOP>
10.4 A binary search tree is a tree that also has the condition that each node may have at maximum 2 children <STOP>
10.4 a tree where each parent can have at max two children. <STOP>
10.4 a list of numbers that are ordered compared to how they compare to the other numbers already added in the tree <STOP>
10.4 a tree where each node can have at most 2 children. <STOP>
10.4 Starting at the root node, it branches off into one or two subsets that are binary subtrees of the root. <STOP> Each node has at most two children, the left child and the right child. <STOP>
10.4 A binary tree is a set of nodes that is either empty or partitioned into a root node and one or two subsets that are binary subtrees of the root. <STOP> Each node has at most two children, the left child and the right child. <STOP>
10.4 a tree that has a maximum of 2 children per node <STOP>
10.4 a tree with elements that can contain at most two pointers <STOP>
10.4 A binary tree can have only two children for each node. <STOP>
10.4 a tree where every parent has only two children <STOP>
10.4 A tree where every node has no more than two children <STOP>
10.4 a binary tree is a special search tree where each node has either 2, 1, or 0 children <STOP>
10.4 a binary tree is a special type of tree where each node can only have at maximum 2 children <STOP>
10.4 A binary tree is a special type of inverted tree in which each element has only two branches below it. <STOP>
10.5 A tree data structure where each node has a value, where the total order is defined on these values. the left subtree contains only values less than the parent node, and vice versa for the right subtree. <STOP>
10.5 A binary search tree is a binary tree where the value in any node "n 'is greater than the value in every node in n 's left subtree but less than every node in n" s right subtree. <STOP>
10.5 A binary tree where the value in any node n is greater than the value in every node in n 's left subtree, but less than the value of every node in n 's right subtree. <STOP>
10.5 A binary tree where the search key in any node n is greater than the search key in any node in n 's left subtree, but less than the search key in any node in n 's right subtree. <STOP>
10.5 A tree which is split based on values. <STOP> This makes it very easy to search. <STOP> One can compare the desired value to the root, and if the root is greater than, we search the left side of the tree, if it is less than, we search the right side ... and do the same thing recursively. <STOP>
10.5 a tree where each node has at most two nodes and the node on the left is less than the root and the node on the right is greater than the root. <STOP>
10.5 a special binary tree that has a rule that all the subtrees on the right are smaller than the node value and all the subtrees on the left are larger than the node value <STOP>
10.5 Binary search trees are similar to binary trees, but have been implemented to organize data in a specific way for later searching. <STOP>
10.5 it is a binary tree where each node has a value, a total order is defined on these values, the left subtree of a node contains only values less than the node 's value, and the right subtree of a node contains only values greater than or equal to the node 's value. <STOP>
10.5 A binary tree with the data organized in a specific arangment <STOP>
10.5 A binary search tree is a tree that also has the condition that each node may have at maximum 2 children and where the input data is compared to the data in the tree starting with the root. <STOP> If the value is smaller than the root it traverses left, if it is larger it traverses right until it becomes a leaf. <STOP>
10.5 a binary tree in which the data is in order from left to right. <STOP>
10.5 a tree that is set up so that it can be easily searched for numbers based on the location compared to the previous nodes. <STOP>
10.5 a binary tree where the children are ordered such that the right side is greater than the current node, and the left is less than or equal the current node. <STOP>
10.5 A binary tree where the value in any node n is greater than the value in every node n 's left subtree, but less than every value in n 's right subtree. <STOP>
10.5 A binary search tree is a finite set of nodes that is either empty or consits of a root and two disjoint binary trees call the left and right subtrees. <STOP>
10.5 it is similar to a binary tree. <STOP> The keys in a nonempty left subtree -LRB- right subtree -RRB- are smaller -LRB- larger -RRB- than the key in the root of subtree. the values in all nodes in the left subtree of a node are less than the node value the values in all nodes in the right subtree of a node are greater than the node values <STOP>
10.5 a set of numbers arranged by links. each node can contain two pointers to other elements. each node to the left of the parent is smaller and each node to the right is larger. recursive implementation implies that if traversed in order, the output would be sorted <STOP>
10.5 A binary search tree is a special binary tree arranged such that every left child node contains a value less than its parent, and every right child node contains a value greater its parent. <STOP>
10.5 a binary tree with a special organization of data. where the left child of the element is less than it, and the right child is larger than it. <STOP>
10.5 A tree in which the smaller values are located on the left of a parent node and the larger values are located on the right of the parent node. <STOP>
10.5 a binary search tree is a special tree in which each node has at most two children, labeled left child and right child <STOP>
10.5 it is a binary tree where each node has a unique key, the left child of a node has only values less than that node, and the right child of each node has higher values than that node. <STOP>
10.5 Binary search trees are a fundamental data structure used to construct more abstract data structures such as sets, multisets, and associative arrays. <STOP>
10.6 For every node in the binary tree we first visit its left sub-tree -LRB- if its there -RRB- and then visit the parent node itself, and then the right sub-tree -LRB- if its there -RRB- . <STOP>
10.6 The inorder traversal of a binary tree visits the node of a binary tree in order according to their data values. <STOP>
10.6 Traverses the binary tree in inorder. <STOP> It lets you visit the nodes in order according to their data values. <STOP>
10.6 Its used to visit nodes of a binary search tree in a search key order. <STOP>
10.6 -LRB- Left side of tree -RRB- -LRB- Root -RRB- -LRB- Right side of tree -RRB- <STOP>
10.6 printing a tree in order from least to greatest. <STOP> This done by going as far left down the tree as possible and printing the parent and then right tree. <STOP> Then move up the tree. <STOP>
10.6 The in order is to go from left, root, right <STOP>
10.6 Inorder traversal of a binary tree will retrieve start at the furthest left hand leaf and checks it, it s parent, and it s right side sibling, then it goes up a level and repeats until it gets to the root. <STOP>
10.6 traverse the left subtree. visit the root. traverse the right subtree. <STOP>
10.6 postorder <STOP>
10.6 in order starts with the root then does right child then left child recursively <STOP>
10.6 Left Child implies Parent implies Right Child <STOP>
10.6 it goes from lowest to highest inside of the tree <STOP>
10.6 starting by displaying the node furthest to the right, then the node, then the node on the right, in recursive order. <STOP>
10.6 It travels left to right <STOP>
10.6 void inorder -LRB- ptNode ptr -RRB- if -LRB- ptr -RRB- inorder -LRB- ptr implies left -RRB- ; coutdata; inorder -LRB- ptr implies right -RRB- ; <STOP>
10.6 the root is in the middle. <STOP> The left subtree is traversed first, then the root, and finally the right subtree. <STOP>
10.6 a traversal that visits the left branch first, then the parent node, then the right branch, recursively. <STOP>
10.6 Inorder traversal visits the left branch of a node -LRB- all the way to it is deepest left-most leaf -RRB- before visiting the node itself. <STOP> After visiting the entire left branch and the node, it visits the node 's right branch following the same pattern of left child, node, right child. <STOP>
10.6 left middle right <STOP>
10.6 You traverse all the nodes to the left, then visit the root, then traverse all the nodes on the right. <STOP>
10.6 you would go to the furthest down left most node, then to the root then to the right -LRB- if left and right exist -RRB- then you would return one node previous and do the same until you reached the root, then go to the furthest down left most node on the right side of the root and continue this process <STOP>
10.6 it means that you traverse one subtree of a node, then look at the node itself before traversing the other subtree of the node <STOP>
10.6 Level order traversal is a traversal method by which levels are visited successively starting with level 0 -LRB- the root node -RRB- , and nodes are visited from left to right on each level, with Push and Pop methods. <STOP>
10.7 This is on the runtime order of log -LRB- n -RRB- where n is the number of nodes in the binary tree. <STOP>
10.7 In a binary search tree of size "n" it takes log -LRB- n -RRB- comparisons to find a specified element. <STOP>
10.7 n minus 1 divided by 2 is the algorithm to compare and find an element. <STOP>
10.7 At most its equivalent to the height of the tree. <STOP>
10.7 Log -LRB- n -RRB- <STOP>
10.7 O -LRB- log n -RRB- <STOP>
10.7 Depends on what half of the tree and the levels you have. <STOP>
10.7 O -LRB- log n -RRB- in balanced trees <STOP>
10.7 n minus 1 <STOP>
10.7 log -LRB- n -RRB- <STOP>
10.7 O -LRB- nlog -LRB- n -RRB- -RRB- <STOP>
10.7 nLog -LRB- n -RRB- <STOP>
10.7 logn <STOP>
10.7 at the minimum log -LRB- n -RRB- or log -LRB- 2 -RRB- , at the maximum N searches, where N is the number of nodes. <STOP>
10.7 O -LRB- n -RRB- <STOP>
10.7 It takes at most 3 comparisons to find and element in a binary search tree <STOP>
10.7 log -LRB- n -RRB- where n equals the number of nodes. <STOP>
10.7 it takes as many comparisons as the number of levels of the binary search tree. it only compares one number at each level <STOP>
10.7 At most it takes one less comparisons than the tree 's height. <STOP> In big-O notation it takes O -LRB- log n -RRB- comparisons if the tree is balanced. <STOP>
10.7 O -LRB- log n -RRB- <STOP>
10.7 log n comparisons <STOP>
10.7 -LRB- n to the power of k -RRB- minus 1 where k is the height of the tree <STOP>
10.7 it takes h comparisons, where h is the height of the tree <STOP>
10.7 2 way key comparison <STOP>
11.1 The name of the class file, the parameters it must take to perform its function. <STOP> Also a brief description of what the class does. <STOP>
11.1 access specifiers and functions, oftentimes a constructor. <STOP>
11.1 The elements typically included in a class definition are the function prototypes, usually declared public, and the data members used in the class, which are usually declared private. <STOP>
11.1 Class is user defined. <STOP> It contains members, data and functions. <STOP> The keyword class is used and includes brackets -LRB- -RRB- <STOP>
11.1 Member functions and data members. <STOP>
11.1 the functions and variables used when the object is defined for the class. <STOP>
11.1 Data members, functions and function definitions, variables. <STOP>
11.1 return type and input parameters <STOP>
11.1 Constructor <STOP> Data members <STOP> Methods <STOP>
11.1 Function members and member attributes, or in other words, the class variables and functions. <STOP>
11.1 The elements that are included in a class definition is the access-modifier, data types, variables, and function signatures. <STOP>
11.1 The variables and function prototypes. <STOP>
11.1 public and private variables and initiations of functions included in the class. <STOP>
11.1 The return value and the accepted value. <STOP>
11.1 A class definition typically includes the class name, the classes constructor -LRB- s -RRB- , and any extra functions and class variables. <STOP>
11.1 Parameters and their type, Class name, and return type, and the code to be executed in the class. <STOP>
11.1 data members, class variables, and functions <STOP>
11.1 Constructor, functions, and variables native to the class. <STOP>
11.1 functions and data members <STOP>
11.1 data members and function definitions <STOP>
11.1 member functions and data members <STOP>
11.1 constructor, and function definitions. <STOP>
11.1 class name data of class definition of functions and methods <STOP>
11.1 A class definition includes the definitions of the class 's constructor -LRB- s -RRB- and any public or private functions. <STOP> Of course, it also includes the class header and any necessary C libraries <STOP>
11.1 Class name,, semicoln at the end of the defination, private and bublic followed by ":" <STOP>
11.1 a constructor, private and public variables, and function prototypes <STOP>
11.1 Data variables and Functions, Data members <STOP>
11.1 class definitions include the name of the class and type of parameters <STOP>
11.1 class variables, class function prototypes <STOP>
11.1 input ADDRESS return type elements <STOP>
11.2 Public and private specifiers. <STOP>
11.2 Public, Private, Restricted <STOP>
11.2 The access specifiers are public and private. <STOP>
11.2 public private protected <STOP>
11.2 Public or Private. <STOP>
11.2 public: the function or variable can be used outside the class private: the function or variable can only be used with the class <STOP>
11.2 Public and Private <STOP>
11.2 public private and protected <STOP>
11.2 Public <STOP> Private <STOP>
11.2 Private, public, protected <STOP>
11.2 The access-specifiers that can be used in a C plus plus class definition is private and public. <STOP>
11.2 public and private. <STOP>
11.2 static, long, unsigned <STOP>
11.2 Private, Public, Protected, or Friend. <STOP>
11.2 A C plus plus class definition may include access-specifiers public, private, and static. <STOP>
11.2 local, global, local-variable, function specific <STOP>
11.2 public, private <STOP>
11.2 Public, protected, and private. <STOP>
11.2 private, public <STOP>
11.2 public can be accessed by any of the program private can only be accessed by the class functions themselves and no outside functions or calls <STOP>
11.2 public, private, protected <STOP>
11.2 public and private <STOP>
11.2 public, private, protected <STOP>
11.2 functions and data members can be given access-specifications of public, private, and friend. public access is given to any functions or members not given specific access rights. <STOP>
11.2 data member or data functions are access specifiers <STOP>
11.2 public or private <STOP>
11.2 public and private <STOP>
11.2 public and private <STOP>
11.2 public can be accessed from outside the class private accessible only from inside the class, not inherited protected accessible only from inside the class, inherited <STOP>
11.2 public private protected <STOP>
11.3 ie. <STOP> GradeBook myGradeBook -LRB- -RRB- ; call upon the class and then give it a name like shown <STOP>
11.3 They are initialized as a named instance of the template formed by the class. <STOP> This named instance can then be modified to be different from the class that it was created from. <STOP>
11.3 not answered <STOP>
11.3 Objects are initialized by a value given. <STOP> When an object is defined for a certain task. <STOP>
11.3 They are initialized with a ". <STOP> " <STOP> -LRB- dot -RRB- between the constructor and the object being created. <STOP>
11.3 objectname classname -LRB- -RRB- ; to call a function from the class: objectname. funciton -LRB- -RRB- ; <STOP>
11.3 If the object refers to a class, the constructor -LRB- s -RRB- will initialize the objects based on return type and parameters passed. <STOP> Compiler will auto-create one if one is not provided. <STOP>
11.3 classname objectname -LRB- input parameters -RRB- ; <STOP>
11.3 When the class is called by the Constructor <STOP>
11.3 Constructors; default when not provided by user, or programmer specified constructors. <STOP>
11.3 Objects are usually initialized at the beginning of the program and are initialized usually in the main function. <STOP> They are initialized after the class 's name. <STOP>
11.3 ; or, if you want to initialize a variable to a certain value, equals; <STOP>
11.3 variables are set to a given value, or 0 if none is given. <STOP>
11.3 When the object is initialized, its constructor is called -LRB- whether one is provided or c plus plus assigns a default constructor -RRB- . <STOP>
11.3 Objects are initialized essentially as copies of the corresponding classes, complete with their own separate variables. <STOP>
11.3 If you had a class Gradebook, you would initialize it in your main function by use of a constructor in the Gradebook class. <STOP> If no constructor is specified or found, c plus plus will use a default one with no parameters. <STOP> Gradebook myGradebook; <STOP> In this bit of code, the class Gradebook has been initialized as object myGradebook. <STOP>
11.3 objects are initialized by stating the classname first then assigning a name to the object. <STOP> Within the object 's -LRB- -RRB- is a place where it can be initialized. <STOP>
11.3 They are initialized with a constructor. <STOP>
11.3 The value is specified after declaration, It can initialized anywhere between the declaration and the corresponding. <STOP>
11.3 with the default constructor for that object in its class. if no constructor is specified, it uses the default system constructor. <STOP>
11.3 initialized using the same name as the class <STOP>
11.3 they are initialized to a value dependent on the compiler <STOP>
11.3 memory is allocated in accordance with their type and initialization input. <STOP>
11.3 Objects are assigned a space in memory when they are created. the name given to the object points to the memory address where the objects data resides. <STOP>
11.3 using constructor <STOP>
11.3 by giving them a value <STOP>
11.3 By declaring the class first, the name of the variable, and then any variables that need to be put in the constructor. <STOP> Ex. <STOP> Class myClass -LRB- x, y -RRB- <STOP>
11.3 objects are initialized by giving the object a type, name, and initial value <STOP>
11.3 they are initialized to 0 <STOP>
11.3 obj. are initialized by the variables that call them, when they are created within a class. e. i. classname objectname etc. <STOP>
11.4 Name of the function, parameters it must receive in order to perform and a return type. <STOP>
11.4 a function signature is the elements that make it unique such as the variables it calls for and also I suppose this includes the program it is in. <STOP>
11.4 A function signature is the return type of a function, its name, and the number and type of its parameters. <STOP>
11.4 function prototype that contains functions and data members. <STOP>
11.4 A function signature is a declaration of the function that includes the parameter types and the number of parameters. <STOP>
11.4 the declaration of the function. <STOP>
11.4 Includes the name, accepted parameters, and return type. <STOP>
11.4 its return type and its input parameters <STOP>
11.4 Contains the function name and its paramaters. <STOP> The return type is not included <STOP>
11.4 Return type, function name, and the parameter types <STOP>
11.4 The function signature tells what the function parameters and includes all the function calls <STOP>
11.4 The function 's name, as well as what it returns and what it accepts. <STOP>
11.4 the body of the function that holds all the actual code <STOP>
11.4 A function signature is the return type and accepted pass value type it takes <STOP>
11.4 A function signature specifies the name and input variables of a function. <STOP>
11.4 A function signature is the function 's parameters and their type and the name of the function. <STOP> The return type is not a part of the function signature. <STOP>
11.4 the name of the function and what it accepts or returns <STOP>
11.4 the unique identifier of a function, which includes input variables along with the function name, but excludes the output type. <STOP>
11.4 The order, number, and type of data items included inside the function parameters. <STOP>
11.4 its the scope, type, and parameters of that function that give it it is properties and defines it against other functions. <STOP>
11.4 is the name of the fuction, return type, and parameters that are being used <STOP>
11.4 a function signature should include the name of the function, parameters, and a body. <STOP>
11.4 the name of the function and the arguments passed to that function <STOP>
11.4 A function signature, used in a function 's prototype, is the set of object types it take in as parameters, with or without names given for the objects. <STOP>
11.4 function name and parameter are called function signature. <STOP>
11.4 fuction name and parameters <STOP>
11.4 The parameters needed, the return type, and name of the function. <STOP>
11.4 the signature of a function includes the name of the function, the number and types of parameters, and the return type <STOP>
11.4 It is what uniquely separates overloaded functions. <STOP> It includes the return type, and the parameter list of the function. <STOP>
11.4 function sig is, is what is the class recognizes as the main function, or rather its specification <STOP>
11.5 A function that calls upon it self to solve a problem. <STOP> Each time it calls upon it self it splits up a problem into a simplier form until it reaches a "base case" which is the most simplest form of the problem. <STOP>
11.5 A function that calls itself to perform an opperation such as a factorial recursive function. <STOP>
11.5 not answered <STOP>
11.5 A base case that calls upon itself until the problem becomes smaller and terminates. <STOP>
11.5 It is a function that calls itself. <STOP> It runs multiple times until the base case is reached. <STOP>
11.5 a function that calls itself untill it reaches a base case. <STOP>
11.5 A function that calls itself. <STOP> Each time it does, it must get smaller, and eventually MUST converge to a base case, otherwise you can start an infinite loop. <STOP>
11.5 a function that calls itself until a base case is met <STOP>
11.5 A function that calls itself. <STOP> With each function call the problem is diminished. <STOP>
11.5 A function that calls itself to perform a certain task <STOP>
11.5 A recursive function is a function that calls itself. <STOP> Usually called the base case. <STOP> If the base case is not correct it causes a infinite loop. <STOP>
11.5 A function that calls itself, in order to solve a problem. <STOP>
11.5 a function that calls itself over and over until it finds the simplest form of solution, or the base case. <STOP>
11.5 A recursive function is a function that calls itself repeatedly until a base case is achieved. <STOP> The fundamental idea is to break one large problem into a series of smaller, similar problems. <STOP>
11.5 A recursive function typically simplifies a problem by calling itself, until arriving at a base case, at which it recursively returns a solution. <STOP>
11.5 A recursive function is a function that breaks down a large problem into two or more smaller problems and calls itself to solve those smaller problems until a base case or terminating point is reached. <STOP> At the base case, a definite answer is called and the function no longer recurses, but unwinds itself back through function calls to determine the answer to the original large problem. <STOP>
11.5 a function that calls itself into a loop with a base case for a loop exit. <STOP>
11.5 a function that calls itself until the base cases are met. <STOP>
11.5 A recursive function only knows how to solve base cases <STOP> A recursive function calls itself directly or indirectly until a base case is reached. <STOP>
11.5 a function that calls on itself and uses a base case to stop the recursion <STOP>
11.5 a function that calls itself, and which eaach calls get closer and close to the base case. <STOP>
11.5 A function that divides and conquers a problem. <STOP> There is a base case that will eventually be reached. <STOP> The function calls itself over and over until the base case is satisfied. <STOP>
11.5 a function that calls itself in the definition code <STOP>
11.5 A recursive function solves a problem by repeatedly calling itself. the initial problem is broken into successively smaller parts until a much simpler base case is reached. the solutions to each piece of the problem are then returned a step at a time. <STOP>
11.5 It invoke by itself again ana again, unless it reach bas case <STOP>
11.5 a function that solves a problem by dividing the problem into smaller problems, by calling its self again and again, until a base case is reached. <STOP>
11.5 A function that calls itself over and over again till a base case is reached, then it returns back to the original function. <STOP>
11.5 a recursive function is a function that during execution, calls itself over and over until a base case is reached <STOP>
11.5 A function that calls itself. <STOP> Usually used to split a problem into several smaller problems of the same type. <STOP>
11.5 function that calls it self till the base case is met <STOP>
11.6 Iteration, performers a series of checks and loops. <STOP>
11.6 The alternative method is to use loops in the program instead of a function which calls itself. <STOP>
11.6 An alternative to solving a problem using recursive functions is to solve the problem using iteration. <STOP>
11.6 Iteration, this would be more efficient and has repetition structure. <STOP>
11.6 One can use iteration or by using a simple while or for loop. <STOP>
11.6 iteration <STOP>
11.6 Iteration. <STOP> A while loop or a for loop will be able to accomplish the same desired outcome ... It may be faster than recursion, but could also be harder to understand. <STOP>
11.6 you can also solve the problem iteratively <STOP>
11.6 iterative <STOP>
11.6 Using iteration loops. <STOP>
11.6 Another alternative way to solve a problem instead of using recursive functions is by using iteration. <STOP>
11.6 A recursive function can often be solved using an iterative function, which runs faster, but is often more complicated. <STOP>
11.6 iteration <STOP>
11.6 Any recursive function can be solved using an iterative method. <STOP>
11.6 Many recursive solutions may also be solved with looping control statements, such as while, for, do-while, etc. <STOP>
11.6 Using an iterative function, which repeats a specified operation or set of operations until a terminating point or base case is reached. <STOP>
11.6 iteratively <STOP>
11.6 using an Iterative calls <STOP>
11.6 Iteration. <STOP>
11.6 iteration is the alternative way to solve a problem <STOP>
11.6 using an iterative solution instead <STOP>
11.6 Using an iterative solution. <STOP> For, while, or do while loop. <STOP>
11.6 the alternative way to solve a problem that could be solved using recursion is iteration. <STOP>
11.6 Any problem solved recursively could be solved with an iterative function. <STOP> Iterative replacements for recursive functions may be more difficult to program, but often lead to more efficient solutions to a problem. <STOP>
11.6 by iteration <STOP>
11.6 itteration, like a for loop, a while loop, or a do while loop <STOP>
11.6 Iteration by using loops <STOP>
11.6 iterative functions <STOP>
11.6 iteration <STOP>
11.6 the alt, way is to use a functions parameter in a call "to" function. <STOP>
11.7 The array that is declared static retains its modified elements so once it is called upon again the latest elements are modified again. <STOP> An array that is not declared static will keep its original elements. <STOP>
11.7 A static array only has a specific size and it cannot grow. <STOP> Also static arrays cannot be accessed outside the program which created it. <STOP>
11.7 Arrays declared as static are not created and initialized when a function is called and destroyed when the function terminates. <STOP>
11.7 Static can be initialized and non-static cannot in C plus plus. <STOP>
11.7 An array declared static remains the same throughout the execution of the program. <STOP>
11.7 a static array will be called only once. once it has been declared the complier will ignore the static line if it comes to it again. <STOP>
11.7 The static array will be available to the whole of the program, whereas an array that is not static is only available within the scope in which it is declared. or or pass-by-reference??? <STOP>
11.7 a static array has a predetermined size and that size cannot be altered <STOP>
11.7 Arrays declared static can not be changed. <STOP> One not declared static can be altered. <STOP>
11.7 an array that is declared as static will retain the values stored in it is elements between function calls, and will not reinitialize them to default values. <STOP>
11.7 An array that is declared static causes anything that is not initialized to be set to 0. <STOP>
11.7 A static array will have a null character at the end of the array. <STOP>
11.7 static arrays cannot be changed while normal arrays can be changed <STOP>
11.7 An array they is declared as static can be accessed outside of the method it was declared without passing it as an argument to other functions in the same class. <STOP>
11.7 A static array has class scope, allowing it to remain where other arrays might be recycled. <STOP>
11.7 An array that is static does not change or uninitialize if called later unless explicitly acted upon. <STOP> It does not terminate or change across objects. <STOP> An automatic local array will be cleared and uninitialized if called later outside of it is specific scope. <STOP>
11.7 one declared as static is one that is already defined. <STOP> The program knows the length and the array from the start, whereas non-static arrays are declared or assigned later. <STOP>
11.7 a non static array must reinitialize itself every function call, while a static array will only initialize itself once, unless otherwise forced. <STOP>
11.7 A static array retains any modified values after a function call. <STOP> Automatic arrays reset to their initial values when the function ends. <STOP>
11.7 a static array is one that keeps its values and is not initialized every time a class function is called, it is data is not lost at function end. <STOP>
11.7 an array that is declared as static can only be used in the function that its being called in. <STOP> Its a constant array. <STOP> Static is another way of say const. <STOP>
11.7 Values in an array that is not delcared as static will remain constant. <STOP> When an array is declared const values within the array can be manipulated. <STOP>
11.7 the data of a static array cannot be changed <STOP>
11.7 Standard arrays terminate when the functions that call them finish. <STOP> A static array is not removed from memory when it is parent function terminates, leaving it available for other functions -LRB- or new instances of the original function -RRB- . <STOP>
11.7 by defining static array it doese not lose scope in locala function. static array makes programm more scalable. non static array lose scope inside the local function. <STOP>
11.7 static arrays can be called from anywhere <STOP>
11.7 A static array cannot be changed. <STOP> A regular array can be changed when it is passed to a function or manually. <STOP>
11.7 a static array can be can be edited throughout the program, while a non-static array can only be edited within a given function <STOP>
11.7 An array that is declared static is allocated when the program begins to run, and is not freed until the program exits, but has limited scope. <STOP> A non-static array is allocated and freed every time that it comes in and out of scope. <STOP>
11.7 static has a predetermined size that cannot be passed while vis versa. <STOP>
11.8 the type char [] has a null -LRB- "n" -RRB- element at the very end. <STOP>
11.8 a variable char is basically any non command key on the keyboard that you can press. <STOP> A string is a collection of letters or numbers that is stored together to be used later. <STOP> Comonly strings are used for words. <STOP> Chars can be used for less but can have opperations performed on them in a useful way. <STOP>
11.8 The programmer must provide the null terminating character in a string of characters using type char [] and must also ensure that the array is large enough to contain the input string of characters and the null terminating character. <STOP>
11.8 String of characters are followed by a null statement. type string is for example string s; <STOP>
11.8 String contains a word where as char can contain phrases or a string of characters. <STOP>
11.8 a string is a variable with a single entinty of letters combined into one while in a char [] each letter is assigned a memory value and each has its own variable assigned i. e. char [0] char [1]. <STOP>
11.8 A string contains a null character at the end of the string, which makes it easily possible to get the string length. <STOP> A char array can have a virtually unlimited length, therefore, its size must be declared or limited. <STOP>
11.8 an array of characters stores a null character at the end <STOP>
11.8 When you read a string of characters, you also read in the white space. <STOP> When you read characters declared char you only read the characters, no white space. <STOP>
11.8 Character arrays will terminate at any whitespace, including spaces. <STOP> Strings terminate when they encounter the new line character. <STOP>
11.8 The difference is that a string that is declared a variable of type char [] is each char is included in the array versus the string of characters that is read into a variable. <STOP>
11.8 An array of strings reads the string literals, meaning anything within "quotes". <STOP> A char array reads a string as each individual character. <STOP>
11.8 character arrays can call on individual letters were a string array can only call words. <STOP>
11.8 The character array has an end of line character at the end of it. <STOP>
11.8 Type char [] may contain a null value as the last element, whereas type string will not. <STOP>
11.8 The variable of type string has a terminating character 0 at the end of it. <STOP>
11.8 the one that is type string has an extra string member. <STOP> The or 0 at the end. <STOP>
11.8 a string has variable size and function calls available, while an character array usually has a static size. <STOP>
11.8 a string char [] adds a null value to the end of the string. <STOP>
11.8 char array needs an end character signature and is made up of characters each separate from each other, a string is an object in itself, with a value that the user enters. <STOP>
11.8 the variable of type char [], each character is stored into a different memory address and can be accessed easly, where as in a string of character, its not easy to be able to access each character in the string. <STOP>
11.8 When the string is passed into the array char, individual characters are stored and can be manipulated. <STOP> Although when a word is stored into a string variable, it is stored as one word and not as individual characters. <STOP>
11.8 a string variable can change in size and is passed to functions by value, whereas a type char [] cannot change in size and is passed to functions by reference only <STOP>
11.8 A string type string acts as a single object, with individual char entities accessible only through specific string class functions. <STOP> A char array is less robust, but allows direct access to specific char entities. <STOP>
11.8 In arrays strings are stored as a characters -LRB- char [] -RRB- , each character of string will be stored in each memory location of the array, while string of characters is only one memory location. <STOP>
11.8 an array of characters has one more element, its last element, the terminating element, or null, which doesnt exist in a variable of type string <STOP>
11.8 A string of characters is a specific variable type that has no extra data at the end. <STOP> A string of type char [] is all the characters and a null -LRB- " <STOP> 0" <STOP> -RRB- <STOP>
11.8 a string of characters will have a null character or value at the end of the string <STOP>
11.8 when the characters are put in a char array, there is also a null terminating character added to the end, "0" <STOP>
11.8 string of characters that is read into a variable of type string includes, <STOP>
11.9 For example we have an array on n elements, the divide and conquer splits up the array into equal halves and repeats this process until each element is by itself <STOP>
11.9 Divide and coquer means dividing a problem into 2 plus problems which are solved and then merged back together for a final solution to the whole problem. <STOP>
11.9 The divide and conquer paradigm divides a problem into smaller and smaller portions that are easier to solve. <STOP>
11.9 Divide elements, recur then conquer, which works in merge sort and quicksort. <STOP>
11.9 To divide and conquer, you divide the program in half once or multiple times to the extent that the program as a whole is easier to work in groups to solve the problem. <STOP>
11.9 to divide one larger string or line of values and sepereate them into smallers lines to easily manipulate them and then replace them in the order in which they should be. <STOP>
11.9 Split the problem into smaller, more manageable parts, and proceed to address the smaller problems. <STOP>
11.9 dived and conquer is the breaking up of a large complex program into small easy to solve components. <STOP>
11.9 Dividing a larger problem into the smallest incident of the problem and solving the smallest incident. <STOP>
11.9 Break up very large data structures into smaller sub-units, that are easier to manipulate. <STOP>
11.9 The divide-and-conquer technique is where it takes the sorting algorithm and breaks up the array into smaller elements of the array to tackle the problem and run the algorithm. <STOP>
11.9 The divide-and-conquer paradigm divides the problem into two pieces and works on each piece separately, allowing for a faster approach to 2 separate smaller problems. <STOP>
11.9 Take a problem and divide it into a smaller problem and solve that smaller problem, or divide it into a smaller problem and solve it, thus solving the whole problem in the process. <STOP>
11.9 The idea is to split the problem into half and solve for the smaller split-problems. <STOP>
11.9 The divide and conquer paradigm, splits a large problem into simpler problems, at which point it solves the simpler problems and merges the simple solutions together to answer the large problem. <STOP>
11.9 Divide-and-conquer refers to abstraction, the act of separating large, complex problems into smaller, easier problems that can be solved by a relatively simple algorithm. <STOP>
11.9 It takes a large problem and splits it into two or more easier or faster solutions, and makes for better readability. <STOP>
11.9 it is the taking of a larger problem and splitting it into simpler smaller problems. <STOP>
11.9 It divides the problem into singular units and works on the problem piece by piece until the problem is solved. <STOP>
11.9 smaller parts are easier to compare than comparing the whole, so it divides the problem down in halves until it can easily compare, then works backwards putting it back together to give the solution. <STOP>
11.9 a divide-and-conquer paradigm. takes some data, divides it into two parts, and works on each part indiviually until the item is found. <STOP>
11.9 The idea of divide and conquer is to take a large problem, split it into n smaller problems, making the program easier to read and modify. <STOP>
11.9 the divide and conquer paradigm is a recursive solution that keeps dividing the problem into halves until a base case is reached. <STOP>
11.9 dividing and conquering means breaking a problem into two smaller problems, solving both of those, and putting the two solutions together. <STOP>
11.9 Divide the big problem into small problem, solve small problem and join small solved elements of the problem. if there is two ore more elements in the array, divide the array into parts and compare the elements, after comperison, conquer the elements. <STOP> If array have n element, first half have n divided by 2 elements <STOP>
11.9 divide the array in half, sort each half, then sort them back in one array <STOP>
11.9 You take a class and break down everything it is supposed to do into easily managed functions. <STOP>
11.9 this is shown by the use of. cpp and header files. by splitting the program up into smaller subsections of individual code, it becomes easier to write and keep up with as opposed to having all of your code in one file <STOP>
11.9 When a problem is too big, split it into smaller problems of the same type, and solve those, then from the solutions of the smaller problem, give the solution to the larger original problem. <STOP>
11.9 it is the separating of large program into smaller classes then until target is reached. <STOP>
11.10 It uses the divide and conqure technique recursively and then when merging back together it compares each element together in a sorted list, this is done by reversing the divide and conquer technique <STOP>
11.10 A merge sort works by removing all items to sepperate memory locations and merging them back together in order. <STOP>
11.10 It divides the array into two halves, sorts each half, then merges the two halves together. <STOP>
11.10 Divide into two sublists and then those sublists break into length 1, then merges the sublists sorted. <STOP>
11.10 Merge sort uses the "divide and conquer" idea where it divides the array in half multiple times and then joins each element of the array back into one sorted array. <STOP> This is one of the best sorting algorithms besides Quicksort. <STOP>
11.10 divides the line in half coninuously until you get to only a single value then recombine the values to form a sorted line. <STOP>
11.10 Continually split array in half, sort each side of the halves, then put them back together once organized. <STOP>
11.10 merge sort splits the array of elements into smaller arrays until the arrays reach size 1 and then the merge sort merges the smaller arrays into arrays of size 2 then it moves to the next step and merges the next arrays. <STOP>
11.10 By divide and conquer. <STOP>
11.10 Break a single array down into many arrays with individual elements, then sort the elements as you reconstruct them back into a single array. <STOP>
11.10 Merge sort breaks the array in half, and continues to do so until it has 2 elements to compare and sorts them, after doing so it "merges" back as it keeps on sorting the algorithm as it does so. <STOP>
11.10 Merge sort divides the problem in half, organizes each half, then brings the two halves together again. <STOP>
11.10 Take an array and split it into two, then solve these simpler problems and merge the two answers in correct order. <STOP>
11.10 A merge sort recursively divides the array into half until only one element remains, then it sorts the data on its way out of the recursive call by merging the cells. <STOP>
11.10 Merge sort recursively divides an array into two arrays until all arrays have 1 element, at which point it merges the 1 element arrays into larger sorted arrays, the final returned array being the sorted version of the initial array. <STOP>
11.10 Merge sort continuously breaks an array in half then sorts the arrays as it concatenates them back together into one sorted array. <STOP>
11.10 It takes an array, splits itself in half, sorts the two halves -LRB- either by recursion or iteration -RRB- and compares them together giving a third array a full sorted list with both halves rejoined. <STOP>
11.10 it splits a large array into small arrays and recurs until the array is a size of 1, and then merges all of the arrays back together until the source array is completely sourted. <STOP>
11.10 Mergesort divides the array into smaller halves and then combines the sorted subarrays into one sorted array. <STOP>
11.10 merge sort breaks the array down in halves until it is comparing two values, sorts those two values, then merges that back with the other broken down parts that it sorted, each level merging more sets together till you return back to your whole array in order. <STOP>
11.10 Divides the data into twor separate arrays, sorts the two arrays and merges them back to back together recursively. <STOP>
11.10 Take the initial array and split it into two, temporary, smaller arrays, sort the two smaller arrays, and merge them back into a single array. <STOP>
11.10 merge sort divides the data into halves until data of one element is reached and then merges each element together according to its placement in comparison to the rest of the data <STOP>
11.10 merge sort uses the divide and conquer strategy, sorting an array in parts, then merging the sorted parts back together. <STOP>
11.10 Divide recursuivly big array into two arrays, sort two array and merge them togather recuruivly. <STOP>
11.10 divides an array in half and sorts each half by calling its self, thus dividing each half again and again and sorting it until the array is sorted. then putting the elements back in the original array sorted. <STOP>
11.10 Merge sort takes an array and splits it in half and sends each half back to itself recursively and merges and sorts the two halves when it starts going back up. <STOP>
11.10 merge sort splits an array into two halves and then sorts the two smaller arrays, and then merges them back together to form a sorted array <STOP>
11.10 the merge sort continually divides the array -LRB- or set of containers -RRB- into halves, until it reaches the point where there is just one element left, then merges each of the sets of two sorted arrays -LRB- containers -RRB- . <STOP>
11.10 merge sort splits an array of elements into smaller and smaller array 's till the value of 1 is reached. <STOP>
12.1 A variable in memory that hold the address of another memory location to which it points too <STOP>
12.1 A pointer is a variable that contains the memory address of a given value. <STOP>
12.1 A pointer is a variable that stores the address of another variable. <STOP>
12.1 A pointer is a variable that holds a memory address or location of another variable. <STOP>
12.1 A data type that points to an address in memory which contains certain information. <STOP> Used for pass-by-reference to save memory. <STOP>
12.1 a pointer points to a location in memory of a certain data type <STOP>
12.1 A pointer is a variable that points to the address location of another variable. <STOP> Represented by -LRB- STAR -RRB- . <STOP>
12.1 A pointer is a variable that holds the address of a given variable -LRB- and of a given data type -RRB- <STOP>
12.1 pointer is a programming data type whose value points to another value stored in computer memory by its address. <STOP>
12.1 A data type that points to a specific memory address. <STOP>
12.1 Its like a variable except it only holds the address in memory of the variable not the physical information. <STOP>
12.1 a pointer is a reference to a memory location. <STOP>
12.1 A pointer is an alias to an object in memory. <STOP>
12.1 A pointer is a variable that contains a memory address for something that you can use, such as a value, array, or even a function. <STOP>
12.1 its a data type with a memory address and a value <STOP>
12.1 a form of storing data that keeps the location in memory of an data type or object. <STOP>
12.1 it contains a object 's memory address <STOP>
12.1 variable that contains the memory address of a data object. <STOP>
12.1 A pointer is an element that references a memory location. <STOP>
12.1 an object that points to a specific place in memory, where a variable or value is stored. <STOP>
12.1 a variable that stores the address of a memory location <STOP>
12.1 A pointer is a variable that points to an address in memory, which contains some data. <STOP> The pointer does not contain or point to any data, only a memory address. <STOP>
12.1 Pointer is a variable which have a memory address of a variable. <STOP>
12.1 a pointer points to a location in memory where data is stored <STOP>
12.1 a variable that holds the address of another variable and can access the contents of the variable. <STOP>
12.1 a pointer is a memory address that points to a data member <STOP>
12.1 A data type that stores the memory address of another variable. <STOP>
12.1 its like a variable but only holds an address in meomrry not the physical address. <STOP>
12.2 Try several sets of data on an algorithm that includes worst case, best case, and random cases. <STOP> Also try and run the same program on a different computer with the same specs <STOP>
12.2 not answered <STOP>
12.2 time complexity using big O logarthmic O -LRB- log n -RRB- linear O -LRB- n -RRB- exponential O -LRB- n to the power of 2 -RRB- quadratic O -LRB- n to the power of k -RRB- k is greater than or equal to 1 <STOP> Polynomial O -LRB- a to the power of n -RRB- n is greater than 1 <STOP>
12.2 Using some sort of counting principle of the number of operations performed in an algorithm. <STOP>
12.2 Experimental means you would actually write a prototype of the algorithm and measure the time it takes to run given certain parameters. <STOP>
12.2 measuring the relationship of running an algorithm with different input sizes. <STOP>
12.2 Oposite of a theoretical assessment of the algorithm to determine runtime, but to run the code first to determine the the runtime. <STOP> This is not recommended because it is a limited test. <STOP> It does not include all possibilities of the data, nor the hardware used to process the data. <STOP>
12.2 not answered <STOP>
12.2 The experimental approach for measuring the running time is by using the Big O equation which tells you the running time. <STOP>
12.2 You create and run the algorithm multiple times, while measuring the amount of time it takes, you then average the results. <STOP>
12.2 keep a value of how many operations it takes and add to this value each time a function is called. <STOP>
12.2 BIG-OH <STOP>
12.2 Running the program with various input data and measuring the running time with system time. <STOP>
12.2 You run a program with different data sizes, like 10 to the power of x. As you increase x and measure the completion speeds for the program, you can find patterns and attempt the measure the running time. <STOP> It is very important to keep the same software and hardware however, which makes experimental testing inferior to theoretical in the eyes of most. <STOP>
12.2 to run the program through and see how many times each thing is called and the runtime of each function is based on that. <STOP>
12.2 the number of times a specific segments get called per unit work. <STOP>
12.2 For every call into memory, add or multiply it into an equation of type O -LRB- n -RRB- <STOP>
12.2 adding a time marker at the before the algorithm is called and another time marker immediately after so that you have the change in time, then you can calculate the efficiency by the speed of the computers cpu. <STOP>
12.2 Big O -LRB- h -RRB- notation <STOP>
12.2 the experimental approach measures actual running time in t. t equals seconds. <STOP>
12.2 running an algorithm on a specific set of data <STOP>
12.2 In experimental terms, the running time of an algorithm is measured by the number of operations required to complete the function. <STOP> This number can usually be expressed in big-O notation. <STOP>
12.2 run the code for n-times and get average values, drop the constant and lowest number. for example if f -LRB- x -RRB- equals 3n plus 1 the running time will bef f -LRB- x -RRB- equals O -LRB- n -RRB- <STOP>
12.2 to measure the actual time of the program to run. and calculate the running time using the input and operations done <STOP>
12.2 adding up the number of operations performed based on the worst case possible. <STOP>
12.2 the experimental approach would be to run through the algorithm and see how long it takes <STOP>
12.2 trying it with different sets of inputs, and measuring the amount of time that the algorithm actually takes. <STOP>
12.2 running the input with various inputs measuring the running time with system time <STOP>
12.3 log -LRB- log n -RRB- , 2 to the power of -LRB- log n -RRB- , n to the power of 2, n to the power of 3, n! <STOP>
12.3 log -LRB- log n -RRB- , n to the power of 2, n to the power of 3, 2 to the power of -LRB- log n -RRB- , n! <STOP>
12.3 log -LRB- logn -RRB- 2 to the power of -LRB- log n -RRB- n to the power of 2 n to the power of 3 n! <STOP>
12.3 log -LRB- log n -RRB- , 2 to the power of -LRB- log n -RRB- , n to the power of 2, n to the power of 3, n! <STOP>
12.3 log -LRB- log n -RRB- , 2 to the power of -LRB- log n -RRB- , n to the power of 2, n to the power of 3, n! <STOP>
12.3 log -LRB- log -LRB- n -RRB- -RRB- , n to the power of 2, n to the power of 3, 2 to the power of log -LRB- n -RRB- , n! <STOP>
12.3 log -LRB- logn -RRB- <STOP> 2 to the power of -LRB- logn -RRB- n! n to the power of 3 n to the power of 2 <STOP>
12.3 log -LRB- log n -RRB- ; 2 to the power of -LRB- log n -RRB- ; n!; n to the power of 2; n to the power of 3; <STOP>
12.3 this goes from largest to smallest: n!, n to the power of 3, n to the power of 2, 2 to the power of -LRB- log n -RRB- , log -LRB- log n -RRB- <STOP>
12.3 log -LRB- log n -RRB- ; 2 to the power of -LRB- log n -RRB- ; n to the power of 2; n to the power of 3; n! <STOP>
12.3 2 to the power of -LRB- log n -RRB- , log -LRB- log n -RRB- , n!, n to the power of 2, n to the power of 3 <STOP>
12.3 log -LRB- log n -RRB- ; n!; n to the power of 2; n to the power of 3; n to the power of -LRB- log n -RRB- <STOP>
12.3 From least to greatest: log -LRB- log n -RRB- , 2 to the power of -LRB- log n -RRB- , n to the power of 2, n to the power of 3, n! <STOP>
12.3 log -LRB- log n -RRB- <STOP> 2 to the power of -LRB- log n -RRB- , is just n n to the power of 2 n to the power of 3 n! <STOP>
12.3 2 to the power of -LRB- log n -RRB- log -LRB- log n -RRB- n to the power of 2 n to the power of 3 n! <STOP>
12.3 from lowest to longest. log -LRB- log n -RRB- ; 2 to the power of -LRB- log n -RRB- ; n!; n to the power of 2; n to the power of 3; <STOP>
12.3 log -LRB- log -LRB- n -RRB- -RRB- <STOP> 2 to the power of log -LRB- n -RRB- n to the power of 2 n to the power of 3 n! <STOP>
12.3 log -LRB- log n -RRB- , 2 to the power of -LRB- log n -RRB- , n to the power of 2, n to the power of 3, n! <STOP>
12.3 2 to the power of -LRB- log n -RRB- , n to the power of 3, n to the power of 2, log -LRB- log n -RRB- , n! <STOP>
12.3 linear, logarithmic, exponential, linear, linear <STOP>
12.3 quickest at top, slowest at bottom log -LRB- log n -RRB- n to the power of 2 n to the power of 3 2 to the power of -LRB- log n -RRB- n! <STOP>
12.3 longest to shortest: n to the power of 3; n!; n to the power of 2; 2 to the power of -LRB- log n -RRB- ; log -LRB- log n -RRB- <STOP>
12.3 2 to the power of -LRB- log n -RRB- n to the power of 2 to the power of 3 log -LRB- long n -RRB- n! <STOP>
12.3 from lowest to highest <STOP> 1-long -LRB- long n -RRB- <STOP> 2 minus 2 to the power of log -LRB- n -RRB- <STOP> 3 minus n to the power of 2 4 minus N to the power of 3 5 minus n! <STOP>
12.3 log -LRB- log n -RRB- ; n to the power of 2; n to the power of 3; n!; 2 to the power of -LRB- log n -RRB- <STOP>
12.3 n to the power of 2; n!; n to the power of 3; 2 to the power of -LRB- log n -RRB- ; log -LRB- log n -RRB- <STOP>
12.3 worst to best: n!, n to the power of 3, n to the power of 2, 2 to the power of -LRB- log n -RRB- , log -LRB- log n -RRB- <STOP>
12.3 log -LRB- long n -RRB- , 2 to the power of -LRB- log n -RRB- ; n to the power of 2, n to the power of 3; <STOP>
12.4 it scans the list and selects the smallest -LRB- largest -RRB- element and places it in the front, increment the curPtr by one, scan the list again for the next smallest -LRB- largest -RRB- element and place it in with respect with the other sorted elements. <STOP>
12.4 Selection sort searches the array for the lowest value and swaps it with the first value in the array. <STOP> Then searches for the next lowest value and swaps it with the second item in the array, and so on. <STOP>
12.4 Compare the largest element to the front element and swap data according to value if needed. <STOP>
12.4 Selection sort is a sorting algorithm that divides a list in half and has two lists. <STOP> It then compares the first elements in both these lists and puts these elements in another list, having the smaller element before the bigger one. <STOP>
12.4 Iterate through the list -LRB- assume list of integers -RRB- , find the smallest one, and put it in a separate "sorted" list ... then traverse again and find the next smallest, and move it to the sorted section ... and repeat until you run out of elements to sort. <STOP>
12.4 selection sort selects the smallest element out of the list then the second smallest ... and sorts them acordingly. <STOP>
12.4 You select the smallest element and place it on the left. <STOP> You select the smallest element and sort it with respect the the item already on the left. <STOP> You continue this till the end of the collection of items. <STOP>
12.4 A selection sort scrolls through the data structure looking for the lowest -LRB- or highest -RRB- unsorted piece of data, moves it to the held spot, increments that spot by one, and starts the process over. <STOP>
12.4 Selection sort works by finding the smallest element and then compares it with the largest and sorts the elements. <STOP>
12.4 Selection sort is usually a recursive sorting method where you divide the elements to be sorted in half repeatedly. <STOP> You then sort the smallest case, then work your way up, sorting each until they are all sorted. <STOP>
12.4 goes to the middle of the list, checks to see if it is greater or less then the value given and moves through the list accordingly to add the value into the proper place. <STOP>
12.4 selection sort finds the lowest element in the data set and places it behind the pivot point. <STOP>
12.4 Selection sort iterates through the array one element at a time, seeking the least value from the right and replacing the current value with it. <STOP>
12.4 Selection sort traverses an unsorted array looking for the smallest value, when it is found it is put at the beginning of the unsorted array. <STOP> Performed several times, this will output a sorted array. <STOP>
12.4 it runs through the list and finds the smallest -LRB- or largest -RRB- value and puts it at the appropriate position <STOP>
12.4 pick a number, and set all values less than that number to the left, while all numbers on the right of that number is larger. <STOP>
12.4 It takes the largest item in the unsorted array and swaps it with last item in the unsorted array. <STOP>
12.4 by selecting the first object and comparing it with the next objects to find one that is smaller, if it does it switches the two. then it comes back the other way and sees if the objects previous to the last one is greater, if it does it switches them. it does this while decreasing the range it looks at until it finishes in the middle. <STOP>
12.4 Selection sorts works by going through a certain list. <STOP> Goes through the unsorted list and selecting the largest item in the list and placing it in a sorted array. <STOP> There are two arrays, unsorted and sorted. <STOP> Complete these steps until the list is sorted. <STOP>
12.4 selection sort works by pulling all of the values off to the side, leaving one value in the list. <STOP> It will then insert a value into the list. if the value is bigger it will go to the right, if smaller if will go to the left. <STOP>
12.4 selection sort searches for the smallest element of the remaining data organization and places it at the largest point of the new data organization <STOP>
12.4 Selection sort sorts an array one element at at time. <STOP> It first finds the element with the smallest key and puts it into the first location within its array or list, then finds the next smallest and puts it in the second location, and so on. <STOP>
12.4 select an element compare it with 2nd element if it is greater, swap it <STOP>
12.4 it selects the smallest element in a list and switches it with the element in its correct position, then it selects the next smallest and does the same ... <STOP>
12.4 It starts at the first element and replaces it with the smallest element found to the right. <STOP> It then repeats with the next element in the list. <STOP>
12.4 selection sort is when you pick a data member and put it in a new array, then you pick another data member and put it in order with the new array, then pick another and insert it in the correct place in the new array, etc etc <STOP>
12.4 it searches through the entire data set for the best element to go in the current position, then it moves up a position and searches through the remainder of the set for the best element for the new position. <STOP>
12.4 selection sort iterates through the array one element a time searching for the right and replacing current value with it. <STOP>
12.5 A link list can grow to a infinite size as a array has a fixes size. <STOP>
12.5 The advantage of linked lists is that they are not limited in size like arrays. <STOP>
12.5 link lists dont have a fixed size <STOP>
12.5 Linked Lists can be of variable size, where arrays have fixed size. <STOP>
12.5 Linked lists do not have a definite size. <STOP> They can be as big or as small as needed, and they do not have to allocate extra memory for elements you do not need. <STOP> Arrays size must be defined. <STOP>
12.5 a linked list has a dynamic size, but an array only has a fixed size and takes allot of extra operations to increase its size. <STOP>
12.5 You do not have to predetermine your list size as you do with arrays. <STOP> Linked list have the ability to be as large as you want them adding memory as needed. <STOP>
12.5 The main advantage to a linked list is that it can have it is size adjusted during runtime. <STOP>
12.5 Linked lists are able to grow in size. <STOP> So elements can be added to the list. <STOP>
12.5 Linked lists are not confined to a specific size, and can have elements added and removed far easier. <STOP> They are also easier to traverse. <STOP>
12.5 There is no predetermined length <STOP>
12.5 Inserts into a linked list are far cheaper than an insert into an array. <STOP> With an array, all items after the one being inserted must me shifted, with a linked list, only the pointers are replaced. <STOP>
12.5 Linked lists may be dynamically grown. <STOP>
12.5 Linked lists are very dynamic in that they can change and be added or subtracted to very easily because they are not linear in memory. <STOP> Arrays are pre-specified in size to be cast over a certain amount of disk space. <STOP> This makes insertion into Arrays difficult because all elements must be shifted, and if you reach the end of the array, you are done even if you have more data to input. <STOP> Linked Lists do not run into these problems. <STOP>
12.5 linked lists have an indefinite size, whereas arrays are a specific size. <STOP>
12.5 Linked lists have no predefined length, and thus you can have virtually unlimited items in that list. <STOP>
12.5 They grow dynamically, unlike the fixed size array <STOP>
12.5 you can add as many nodes as you like without having to specify a list size, if an array gets too big you have to copy its entire contents to another larger array to get more room <STOP>
12.5 Linkded list does not have a fixed size. <STOP> Arrays have a fixed size. <STOP>
12.5 Linked lists have a dynamic size, where as arrays have a static size. <STOP>
12.5 linked lists do not have a memory constraint other than total memory <STOP>
12.5 The primary advantage of linked lists over arrays is their ability to become larger or smaller as data is added and removed from the list, whereas arrays may waste memory for small data sets, and run out of space for large data sets. <STOP>
12.5 Array have fixed size, in Link List are flexible for adding or deleting an element. <STOP>
12.5 they are resizeable <STOP>
12.5 Linked lists can be dynamically allocated and their size can change as needed. <STOP>
12.5 linked lists do not have to have a specified size, they are easier to add to and remove from <STOP>
12.5 they dont have a fixed size, no shiftnig needs to be done for insertion or deletion. <STOP>
12.5 linked list many be dynamically grown. <STOP> It has not limit <STOP>
12.6 A data structure in C plus plus where the the first element in the queue is the first element taken out of the queue. <STOP>
12.6 A queue is an abstract data type that performs operations on both ends of the list and exhibits first-in first-out behavior. <STOP>
12.6 First in first out. <STOP>
12.6 A queue is an abstract data type that involves putting an element at the back of the list. <STOP> Queues use the FIFO, first in first out, idea where the first element in the list is the first that comes out. <STOP>
12.6 A data structure that implements first in, first out. <STOP> The element that has been there the longest is the first to get served. <STOP>
12.6 a data structure that inserts elements at the end of it and removes elements from the front. <STOP>
12.6 A queue is a collection of elements with the characteristics of first in first out -LRB- FIFO -RRB- . <STOP> The first item in is the first item out. <STOP> All additional items are added to the end of the list. <STOP>
12.6 A queue is a data structure that inserts data into a FIFO configuration, that is, data input to the structure is always at it is end, and data taken is always from the beginning. <STOP>
12.6 It is a particular set of entities that are put in to a certain order by the enqueue and the dequeue functions. <STOP>
12.6 A queue is a data type that operates under a FILO -LRB- First In Last Out -RRB- method. <STOP> This means that the first element inserted into the queue is the first element removed. <STOP>
12.6 like a linked list except it is first in last out <STOP>
12.6 A queue is like a stack except it follows FIFO -LRB- First in first out -RRB- . <STOP>
12.6 A queue is a data structure where the first node in is the first node out. <STOP>
12.6 A queue is a First in First out data structure much like a line for a movie theatre. <STOP> The first object in line is the first object to be handled or enacted upon. <STOP>
12.6 its a lot like a stack, except that the first item put into the list is the first item to be taken from the list. <STOP>
12.6 a first in first out list of items, like if you put 5, 4, 3, 2, and 1 in the queue it will when you dequeue items remove the items in the same order as put in, so thus it will put out, 5, 4, 3, 2, and 1 in that exact order. <STOP>
12.6 A linked list with a First In, Out structure dequeue at the head of the list enqueue at the end of the list <STOP>
12.6 a list of objects that follow the rule first in first out, essentially a linked list that goes in order of the first object in the list is the first to be taken off. <STOP>
12.6 A queue is an abstract data type that is based off of the priniple of first in first out. <STOP> FIFO. <STOP> The first item inserted into the list will the first item taken out. <STOP>
12.6 It is a "first in first out" data structure. <STOP> It can be implemented with either a linked list or an array. <STOP>
12.6 an ordered list that performs task in the order of first in first out. adding items to the queue places items behind the rest of them. taking items off the queue takes the one that has waited the longest. <STOP>
12.6 A queue is a linear, first-in first-out data structure. <STOP> Data must be accessed in the same order it was put into the queue, so only the oldest item in the queue is accessible at any time. <STOP> Main functions defined are enqueue and dequeue. <STOP>
12.6 Queue is a buffer, it follows the rule of First In and First out. <STOP> Queue is very useful in computer science for scheduleing. <STOP>
12.6 a queue is a set of elements where the first element inserted is the first element to be removed <STOP>
12.6 Is a list of items where the the user only has access to the first element and each new element is added at the end. <STOP>
12.6 a queue is a list of data that follows the fifo principle, an example of this would be when you get into a line at a movie theater ... the first one there gets to buy a ticket first <STOP>
12.6 A queue is a data structure that holds a set of objects, which has a FIFO -LRB- first in first out -RRB- priority. <STOP>
12.6 like a linked list expect first in last out <STOP>
12.7 push and pop <STOP>
12.7 Pop, which removes the head, or least recently inserted node from the stack. <STOP> Push, which inserts a new node at the head of the stack. <STOP>
12.7 Push and pop <STOP>
12.7 The Push function and the Pop function. <STOP>
12.7 push and pop <STOP>
12.7 push puts an element on the stack pop-takes an element off the stack <STOP>
12.7 Push and pop. <STOP>
12.7 Push and Pop <STOP>
12.7 push and pop. <STOP>
12.7 Push and Pop. <STOP> Push adds an element to the stack, while Pop removes the top element from a stack. <STOP>
12.7 pop and push <STOP>
12.7 push, pop, search, isEmpty <STOP>
12.7 push and pop <STOP>
12.7 Push, Pop, isEmpty, isFull <STOP> Maybe List to show all elements or an operation to count how many elements in the stack. <STOP>
12.7 pop, push <STOP>
12.7 isempty, push and pop, along with usually, <STOP>
12.7 push and pop <STOP>
12.7 push and pop. push puts objects into the stack and pop takes them out following the first in last out rule. <STOP>
12.7 The main operations in a stack are push and pop. <STOP> Push adds an item to the top of the stack, pop removes the top item from the stack. <STOP>
12.7 push and pop <STOP>
12.7 push, which adds an item to the top of the stack, and pop, which takes the first item off the top to the stack <STOP>
12.7 the main functions defined for a stack are push, which puts an element on the top of the stack, and pop, which removes an item from the top. <STOP>
12.7 Push -LRB- -RRB- <STOP> Pop -LRB- -RRB- <STOP> Full -LRB- -RRB- <STOP> IsEmpty -LRB- -RRB- <STOP>
12.7 pop and push to remove an element and to insert an element <STOP>
12.7 Push, Pop <STOP>
12.7 push and pop <STOP>
12.7 push Add an element to the top of the stack pop remove the top element from the stack <STOP>
12.7 push and pop <STOP>
12.8 When you traverse a tree of any size you will visit each node three times. <STOP> Its on the order of 3n or O -LRB- n -RRB- running time. <STOP>
12.8 The Euler tour traversal of a tree begins at the root and visits each node in the tree from the left, then bottom, then right sides. <STOP>
12.8 Where you visit the in order according to its data value. <STOP>
12.8 It is a tree that shows how it functions. <STOP> It contains parents, children, siblings, ancestors and descendents. <STOP> The use of tree type algorithm is also an alternative sorting algorithm. <STOP>
12.8 Start from the root, circle around the whole "tree", naming each node as you see it. <STOP>
12.8 it is where you visit the parent then you vistit the children <STOP>
12.8 To start from the root, traveling left and visiting ever child along the way till you return to the root from the right. <STOP>
12.8 Traversing a tree down to it is terminal child and then all of it is siblings, then it traverses up the terminal child 's parent and all of it is siblings -LRB- repeating the first step if those siblings have children -RRB- until the root node has been visited. <STOP>
12.8 The Euler tour traversal of a tree the function that iteratively keeps track of the pointer on each node. <STOP>
12.8 You travel the outside edge of the tree, clockwise, while naming each node. <STOP>
12.8 children to root <STOP>
12.8 go to the bottom of the left sub tree and visit the parent and then its children <STOP>
12.8 The Euler tour traverses through the tree in a rubber-band style shape. <STOP>
12.8 The Euler tour traversal of a tree is a specific way of navigating a tree that involves following the tree starting at the very top and moving along the left side of the tree first, cupping in to visit the parents of children nodes. <STOP> It allows for each node to be visited from the left, the right and the bottom. <STOP> The Euler tour first progresses to a left child if there is one, then progresses to it is parent, then it is next child, then it is parent 's parent. <STOP>
12.8 it runs through the parents and the children in order <STOP>
12.8 it starts node on the left of the root and then proceeds to visits each node in a left to right order, visits the root, and then proceeds to repeat the previous step on the right side of the tree. <STOP>
12.8 Travel from the root to the farthest left child <STOP> Backup, travel the leftmost children in the right side repeat until reaching the rightmost child. <STOP>
12.8 has preorder, in order, and postorder of a tree. preorder equals puts the parent node in front of the child node -LRB- s -RRB- . in order equals puts the parent node between the left child and right child node -LRB- s -RRB- . postorder equals puts the parent node after the child node -LRB- s -RRB- . <STOP>
12.8 The Euler traveral is when you go through a tree looking for nodes to put in the order of left, root, right. <STOP> Like inOrder traversal. <STOP>
12.8 An Euler traversal is a traversal that begins with the root, and travels around the outside of the tree. <STOP> Each element in the tree is visited 3 times. <STOP> From the left, from the bottom and from the right. <STOP>
12.8 Euler tour traversal of a tree traverses down each branch straight to one leaf then starts again at the root and repeats until all elements have been traversed. <STOP>
12.8 The Euler tour visits every node in a tree, starting with the root and working around the tree counterclockwise. in-order, post-order, and pre-order traversals can be seen as variations of the Euler tour traversal. <STOP>
12.8 not answered <STOP>
12.8 to traverse going down to the left then go to the right of last children and back to the top .. kind of like going around the tree <STOP>
12.8 You recursively visit every node on the list. <STOP> You visit the node from the left, the bottom, and from the right. <STOP>
12.8 the euler tour is a way to traverse a tree where you come into contact with each node three times, from the left, from the right, and from the bottom <STOP>
12.8 traversing a tree level by level <STOP>
12.8 The Euler traversal through the tree in a rubber band style shape. <STOP>
12.9 if root, set root to NULL else if deleting right leaf, set rightPtr of parent node to NULL else if deleting left leaf, set leftPtr of parent node to NULL else if deleting a left or right subtree child node, set the max leaf child in the left subtree as the new child node. <STOP>
12.9 Traverse the tree and find the node, if the node has no children, simply delete it; otherwise set the node 's data equal to the data of one of its children then set the pointer for that child to NULL. <STOP>
12.9 first attaching the elements from the node to be deleting to alternate nodes and then deleting that node. delete node; <STOP>
12.9 If you delete a node from a tree, you have to link that nodes parents to the children of that node. <STOP>
12.9 Must delete the information that the node contains -LRB- to free up memory or "garbage collect" <STOP> -RRB- and also delete the pointer -LRB- in that node 's "parent" <STOP> -RRB- that points to the node you wish to delete. <STOP>
12.9 you replace the node with the largest element of its left subtree or replace it with the smallest element of the right subtree. <STOP>
12.9 You traverse the tree till you find the node you are wanting to delete. <STOP> If the node has no children you delete it. <STOP> If the node has children, before you delete, you find the left-most of its children and attach it to the root then you can delete the node. <STOP>
12.9 Link the to-be-deleted 's left child to the to-be-deleted 's parent 's left child pointer. <STOP>
12.9 The way you delete a node from a binary search tree is first you have take the root and then see the nodes that are coming from the root. <STOP> And delete the nodes and set the root to NULL. <STOP>
12.9 You remove the element from the tree and move the next highest element from the left into its place. <STOP>
12.9 delete node; <STOP>
12.9 the deletion of a node depends upon if it has children and if it is an AVL binary search tree. <STOP> Assuming it is not an AVL tree, and the node being deleted has no children, you just set its pointer to null. <STOP> If it has a left child or a right child exclusively, that child replaces the deleted node, if it has two children, the left most child of the right sub tree -LRB- or right most child of the left subtree -RRB- will replace it <STOP>
12.9 If the node is a leaf, just set it is parent 's pointer to null and delete it, if it has a single child, set the parent 's pointer to the child and delete; if it has two children, set the node to one of the middle children and remove that child from its previous position as a leaf -LRB- rightmost child of the left subtree or leftmost child of the right subtree -RRB- . <STOP>
12.9 In a binary search tree, you must first establish a proper replacement for the node you are about to delete, usually a child from the soon to be deleted node. <STOP> Once that replacement node has been found, you simply reassign it to where the node that is going to be deleted is. <STOP> After the deleted node has been usurped, you remove the deleted node from memory so it may be used again. <STOP>
12.9 It all depends on where the node is located. <STOP> If its a child it can just be deleted but for a node inside the tree it must be replaced with another node that works in its place. <STOP>
12.9 if the node has no children, delete it right away, otherwise, put either the furthest right node on the left side or the furthest left node on the right side in that place and perform a the above on that node to guarantee that it is children get handled properly. <STOP>
12.9 Create a temp Node <STOP> Set temp 's values to the Node after head or NULL in the case of only head Node in the list. <STOP> Set head equal to temp. <STOP> Delete temp <STOP>
12.9 by searching down the tree until you find the node, and replacing the link to that node with the greatest child node on the left subtree or the least child node on the right subtree. <STOP>
12.9 Set the nodes to NULL, where that it does not point to anything, and the use the DELETE opertator to clear space from memory. <STOP>
12.9 You must first traverse the tree to find the appropriate value. <STOP> Then you must make sure that the node is a leaf node. <STOP> If it is, then you can delete the pointer to that specific node. <STOP>
12.9 if the node is a leaf, you set it is parent 's pointer to null. if the node is in the tree you must replace the node with one in the tree: either the largest in the left of the tree or the smallest in the right of the tree. this can be done recursively if needed. <STOP>
12.9 if the node is a leaf it can simply be deallocated or deleted from memory, and its parent 's reference to it changed to NULL. <STOP> If the node has a single child, the pointer to it should be made to point to its child before deleting the node. <STOP> Should the node have two children, the easiest solution may be to copy the node 's entire subtree to a new array or tree, delete the node and all descendants, then add the elements taken from the subtree back into the main tree. <STOP>
12.9 not answered <STOP>
12.9 you cannot delete a node because that can cause a node to have more than 2 children <STOP>
12.9 You search the tree for the node using recursion. <STOP> When you find the node, you determine whether it is a leaf or a internal node. <STOP> If it is a leaf, you just delete it and set the parent pointer to that node to NULL. <STOP> If it is a node, you replace the node with either of the children nodes. <STOP>
12.9 to delete the node, you would have to link the children nodes that are connected to the node to be deleted to the remaining nodes of the tree in such a way that nodes on the right of the parent node are larger than the parent and nodes on the left of the parent node are smaller <STOP>
12.9 if it has no children, you just delete it. if it only has one child, just replace the node with whichever child it has. if it has both children, replace it with one of its children, and send the other child down along the other side of the new node. <STOP>
12.9 pointer to the child and delete it has 2 children set the node to the child and delete it. the node to th middle will then take its place <STOP>
12.10 Log -LRB- n -RRB- where n is the number of nodes. <STOP>
12.10 log -LRB- n -RRB- steps <STOP>
12.10 The number of levels and the height of the tree <STOP>
12.10 It is the same as the height of the tree. <STOP>
12.10 Given n elements, it would take n divided by 2 steps to find the search criteria. <STOP>
12.10 log n <STOP>
12.10 Depends on the location of the node you are looking for. <STOP> If it is the root it is one step. else <STOP> If it is smaller than the current you are on node you go to the left. <STOP> If it is larger than the current node you are on go to the right. <STOP>
12.10 2 to the power of n where n is the of levels the binary tree has <STOP>
12.10 The number of steps to search a node is the function n minus 1. <STOP>
12.10 It would take n divided by 2 elements, given n. <STOP>
12.10 log -LRB- n -RRB- <STOP>
12.10 O -LRB- log n -RRB- <STOP>
12.10 O -LRB- Log -LRB- n -RRB- -RRB- <STOP>
12.10 If the binary search tree is constructed efficiently, best case scenario is O -LRB- log n -RRB- time. <STOP> Where n is the number of items in the tree. <STOP> If the binary search tree is constructed poorly, with for instance the root of the tree being 1, and progressing downwards and to the right its children are each more than the last: you have a one-way linear linked list. <STOP> That worse case scenario would be a full traversal at O -LRB- n -RRB- time. <STOP> Where n is the number of items in the tree. <STOP>
12.10 N, n being the number of nodes. <STOP>
12.10 depending on the way that the tree is ordered, it could be anywhere between log -LRB- n -RRB- and N steps. <STOP>
12.10 log -LRB- n -RRB- <STOP>
12.10 worst case scenario equals the number of levels of the tree, ie: the node at the farthest position from the root node. best case equals 1 step if its the root node. <STOP>
12.10 3 steps at most. <STOP> There are 3 cases. <STOP>
12.10 log -LRB- n -RRB- where n equals the total number of nodes in the tree. <STOP>
12.10 the same number of steps as the number of levels or generations in the tree <STOP>
12.10 to find a node in a binary search tree takes at most the same number of steps as there are levels of the tree. <STOP>
12.10 three steps visit the root node, then go to right subtree, after visiting right subtree visit left subtree <STOP>
12.10 log n <STOP>
12.10 -LRB- n -LRB- n minus 1 -RRB- -RRB- divided by 2 <STOP>
12.10 2n-1 <STOP>
12.10 it takes at most h steps, where h is the height of the tree. <STOP>
12.10 it depends on the install search tree then from there for whatever the case is the it repeats it back along the case of the primary node <STOP>
