Garden City College of Scine ce & Management Studies

III SEM BCA

Data structures Using C

Introduction to Data Structures Using C

A data structure is an arrangement of data in a computer's memory or even disk storage. An example of several common data structures are arrays, linked lists, queues, stacks, binary trees, and hash tables.

Algorithms, on the other hand, are used to manipulate the data contained in these data structures as in searching and sorting .

Name Position

Aaron Manager

Charles VP

George Employee

Jack Employee

Janet VP

John President

Kim Manager

Larry Manager

Martha Employee

Patricia Employee

Rick Secretary

Sarah VP

But only one view of the company is shown by the above list. You also want the database to represent the relationships between employees and management at ABC. It does not tell you which managers are responsible for which workers and so on, although your list contains both name and position. After thinking about the problem for a while. You decide that the tree diagram is much better structure for showing the work relationships at the ABC company.

These two above diagrams are examples of the different data structures. Your data is organized into a list, in one of the data structures which is above. The employees name can be stored in alphabetical order so that we can locate the employee's record very quickly. For showing the relationships between employees these structure is not very useful. The tree structure is a much better suited for this purpose.

The data structures are an important way of organizing information in a computers. There are many different data structures that programmers use to organize data in computers, just like the above illustrated diagrams. Some of the data structures are similar to the tree diagram because they are good for representing the relationships between different data. Other structures are good for ordering the data in a particular way like the list of employees which is shown above. Each data structure has their own unique properties that make it well suited to give a certain view of the data.

Primitive and nonprimitive structures

Data can be structured at the most primitive level, where they are directly operated upon by machine-level instructions. At this level, data may be character or numeric, and numeric data may consist of integers or real numbers.

Nonprimitive data structures can be classified as arrays, lists, and files. An array is an ordered set which contains a fixed number of objects. No deletions or insertions are performed on arrays. At best, elements may be changed. A list, by contrast, is an ordered set consisting of a variable number of elements to which insertions and deletions can be made, and on which other operations can be performed. When a list displays the relationship of adjacency between elements, it is said to be linear; otherwise it is said to be nonlinear. A file is typically a large list that is stored in the external memory of a computer. Additionally, a file may be used as a repository for list items (records) that are accessed infrequently.

DATA: appearing in our data structure is processed by means of certain operations. Infect, the particular data structure that one chooses for a given situation depends largely on the frequency with which specific operations are performed.The following four operations play a major role:

TransversingAccessing each record exactly once so that certain items in the record may be processed.(This accessing or processing is sometimes called 'visiting" the records.)

SearchingFinding the location of the record with a given key value, or finding the locations of all records, which satisfy one or more conditions.

InsertingAdding new records to the structure.

DeletingRemoving a record from the structure.

Sometimes two or more data structure of operations may be used in a given situation; e.g., we may want to delete the record with a given key, which may mean we first need to search for the location of the record.

Memory Allocation

In this chapter, we'll meet malloc, C's dynamic memory allocation function, and we'll cover dynamic memory allocation in some detail.

As we begin doing dynamic memory allocation, we'll begin to see (if we haven't seen it already) what pointers can really be good for. Many of the pointer examples in the previous chapter (those which used pointers to access arrays) didn't do all that much for us that we couldn't have done using arrays. However, when we begin doing dynamic memory allocation, pointers are the only way to go, because what malloc returns is a pointer to the memory it gives us. (Due to the equivalence between pointers and arrays, though, we will still be able to think of dynamically allocated regions of storage as if they were arrays, and even to use array-like subscripting notation on them.)

You have to be careful with dynamic memory allocation. malloc operates at a pretty ``low level''; you will often find yourself having to do a certain amount of work to manage the memory it gives you. If you don't keep accurate track of the memory which malloc has given you, and the pointers of yours which point to it, it's all too easy to accidentally use a pointer which points ``nowhere'', with generally unpleasant results. (The basic problem is that if you assign a value to the location pointed to by a pointer:

*p = 0;

and if the pointer p points ``nowhere'', well actually it can be construed to point somewhere, just not where you wanted it to, and that ``somewhere'' is where the 0 gets written. If the ``somewhere'' is memory which is in use by some other part of your program, or even worse, if the operating system has not protected itself from you and ``somewhere'' is in fact in use by the operating system, things could get ugly.)

Dynamic Memory Allocation

An Introduction to Dynamic Memory Allocation

Up until this time, we have used what is referred to as static memory. Static memory means we reserve a certain amount of memory by default inside our program to use for variables and such. While there is nothing wrong with this, it means that once we reserve this memory, no other program can use it, even if we are not using it at the time. So, if we have two programs that reserve 1000 bytes of memory each, but neither program is running, then we have 2000 bytes of memory that is being completely wasted. Suppose we only have 3000 bytes of memory, but we already have our two programs that take 1000 bytes each. Now we want to load a program that needs 1500 bytes of memory. Well, we just hit a wall, because we only have 3000 bytes of memory and 2000 bytes are already reserved. We can't load our third program even though we have 2000 bytes of memory that isn't even being used. How could we possibly remedy this situation?

If you said Dynamic Memory Allocation, then you must have read the title of this lesson. That's right. We are going to use dynamic memory to share the memory among all three programs.

Dynamic memory won't fix everything. We will always need an amount of finite static memory, but this amount is usually much less than we need. This is why we still have static memory.

So, let us imagine a new scenario. We have changed our first two programs to use dynamic memory allocation. Now they only need to reserve 100 bytes of memory each. This means we are now only using 200 bytes of our 3000 total memory bytes available. Our third program, which requires 1500 bytes of memory can now run fine.

Static memory allocation refers to the process of allocating memory at compile-time before the associated program is executed, unlike dynamic memory allocation or automatic memory allocation where memory is allocated as required at run-time.

An application of this technique involves a program module (e.g. function)claring static data locally, such that these data are inaccessible in other modules unless references to it are passed as parameters or returned. A single copy of static data is retained and accessible through many calls to the function in which it is declared. Static memory allocation therefore has the advantage of modularising data within a program design in the situation where these data must be retained through the runtime of the program.

The use of static variables within a class in object oriented programming enables a single copy of such data to be shared between all the objects of that class.

Object constants known at compile-time, like string literals, are usually allocated statically. In object-oriented programming, the virtual method tables of classes are usually allocated statically. A statically defined value can also be global in its scope ensuring the same immutable value is used throughout a run for consistency.

In computer science, dynamic memory allocation (also known as heap-based memory allocation) is the allocation of memory storage for use in a computer program during the runtime of that program. It can be seen also as a way of distributing ownership of limited memory resources among many pieces of data and code.

Dynamically allocated memory exists until it is released either explicitly by the programmer, or by the garbage collector. This is in contrast to static memory allocation, which has a fixed duration. It is said that an object so allocated has a dynamic lifetime.

The Basics of Dynamic Memory Allocation

Now that we have covered why we would want to use dynamic memory allocation, how do we go about doing it? Well, that's easy! We have predefined functions that let us perform these tasks.

The two functions we will be employing in our dynamic memory allocation tasks are malloc() and free(). malloc() meaning memory allocation, and free, well, that should be obvious. Our malloc() function returns a pointer to the memory block we requested. Remember pointers from the last lesson? I told you we weren't done with them yet.

Let's discuss the syntax of malloc(). It takes a single argument, a long integer representing the number of bytes we want to allocate from the heap. (Note: the heap is what we call all the memory we don't reserve by default) So, for example, to allocate memory for an array of characters for a 40 character string, we would do malloc(40); There's more to it, obviously, but we'll cover that.

To allocate memory though, we must have a pointer so we can know where the memory will be at when it gets allocated. Let's look at a small code example:

char *str = (char *)malloc(40); // allocate memory for a 40 character string

This may look a little weird, because it uses a concept we haven't worked with before called "type casting". C has the ability to convert from one type of variable to another by using what are called type cast operators. The syntax is simple, put the variable type you want to convert to inside parentheses. See, it's easy. So, because we want to convert the memory into a character pointer, which is specified by the type char *, we put char * in parentheses. Then C will give us a character pointer to the memory. This is very easy to do when a character pointer is involved. The important thing to note here is what

malloc() returns to us. Because malloc() doesn't care how the memory we allocate will be used, malloc() just returns a pointer to a series of bytes. It does this by using a void pointer. Void pointers are just like character pointers, or integer pointers, or any other kind of pointer with one special difference: we do not know what the size of the void pointer is. There is no way to increment or decrement a void pointer. In fact, we can't do much of anything with a void pointer except acknowledge its existence until we convert (type cast) it to another variable type.

Characters are by definition 1 byte, and malloc always allocates in multiples of a single byte. Other types are more than 1 byte. Rather than remembering how many bytes an int variable takes on a system, we can use the sizeof operator. Let's see an example.

char *str = (char *)malloc(40 * sizeof(char)); // allocate memory for a 40 character string

This looks very similar to what we had above, with one important exception, the sizeof(char) multiplier. This is a new operator, and another very important one in C. The sizeof() operator will tell us the size of any variable or structure in our program. The one thing to keep in mind when using sizeof() is that the size of a pointer is how many bytes it takes to store the pointer, not the size of the memory block the pointer is pointing at. There is no need to know that information. In allocating memory like this, we know we have 40 characters instead of 40 bytes (even though they are technically the same). There is a difference between 40 integers and 40 bytes, and 40 long integers especially.

Now that we have taken a look at how the malloc() function works, let's take a look at its companion function, free(). The free() function is basically the exact opposite of malloc(). So, instead of assigning a pointer the value returned, we give the function the pointer we got from malloc(). So, if we have the *str pointer we allocated above, to free that memory, we just need to call free with the pointer as an argument.

free(str); // free the memory allocated by malloc()

You may be wondering how the free() function knows how much memory to free up, since we didn't tell it how much memory we allocated. Well, the short answer is: you don't need to worry about that. The system will take care of such minutia for us. The long answer is, well, long, and complicated, so I don't want to talk about it.

Most modern systems will free allocated memory at the completion of the program. The AMS is not one of these systems. If you don't free the memory you allocate, your calculator will lose memory until it is reset

RECURSION:

in computer science is a method where the solution to a problem depends on solutions to smaller instances of the same problem.[1] The approach can be applied to many types of problems, and is one of the central ideas of computer science.[2]

"The power of recursion evidently lies in the possibility of defining an infinite set of objects by a finite statement. In the same manner, an infinite number of computations can be described by a finite recursive program, even if this program contains no explicit repetitions." [3]

Most high-level computer programming languages support recursion by allowing a function to call itself within the program text. Imperative languages define looping constructs like “while” and “for” loops that are used to perform repetitive actions. Some functional programming languages do not define any looping constructs but rely solely on recursion to repeatedly call code. Computability theory has proven that these recursive-only languages are mathematically equivalent to the imperative languages, meaning they can solve the same kinds of problems even without the typical control structures like “while” and “for”.

Greatest common divisor

Another famous recursive function is the Euclidean algorithm, used to compute the greatest common divisor of two integers. Function definition:

Pseudocode (recursive):

function gcd is:

input: integer x, integer y such that x >= y and y >= 0

1. if y is 0, return x

2. otherwise, return [ gcd( y, (remainder of x/y) ) ]

end gcd

Recurrence relation for greatest common divisor, where x%y expresses the remainder of x / y:

gcd(x,y) = gcd(y,x%y)

gcd(x,0) = x

Computing the recurrence relation for x = 27 and y = 9:

gcd(27, 9) = gcd(9, 27 % 9)

= gcd(9, 0)

= 9

Computing the recurrence relation for x = 259 and y = 111:

gcd(259, 111) = gcd(111, 259 % 111)

= gcd(111, 37)

= gcd(37, 0)

= 37

The recursive program above is tail-recursive; it is equivalent to an iterative algorithm, and the computation shown above shows the steps of evaluation that would be performed by a language that eliminates tail calls. Below is a version of the same algorithm using explicit iteration, suitable for a language that does not eliminate tail calls. By maintaining its state entirely in the variables x and y and using a looping construct, the program avoids making recursive calls and growing the call stack.

Pseudocode (iterative):

function gcd is:input: integer x, integer y such that x >= y and y >= 0

1. create new variable called remainder

2. begin loop

1. if y is zero, exit loop

2. set remainder to the remainder of x/y

3. set x to y

4. set y to remainder

5. repeat loop

3. return x

end gcd

The iterative algorithm requires a temporary variable, and even given knowledge of the Euclidean algorithm it is more difficult to understand the process by simple inspection, although the two algorithms are very similar in their steps.

Towers of Hanoi

For a full discussion of this problem's description, history and solution see the main article or one of the many references. Simply put the problem is this: given three pegs, one with a set of N disks of increasing size, determine the minimum (optimal) number of steps it takes to move all the disks from their initial position to another peg without placing a larger disk on top of a smaller one.

Function definition:

Recurrence relation for hanoi:

hn = 2hn − 1 + 1

h1 = 1

Computing the recurrence relation for n = 4:

hanoi(4) = 2*hanoi(3) + 1

= 2*(2*hanoi(2) + 1) + 1

= 2*(2*(2*hanoi(1) + 1) + 1) + 1

= 2*(2*(2*1 + 1) + 1) + 1

= 2*(2*(3) + 1) + 1

= 2*(7) + 1

= 15

Example Implementations:

Pseudocode (recursive):

function hanoi is:input: integer n, such that n >= 1

1. if n is 1 then return 1

2. return [2 * [call hanoi(n-1)] + 1]

end hanoi

Although not all recursive functions have an explicit solution, the Tower of Hanoi sequence can be reduced to an explicit formula.

An explicit formula for Towers of Hanoi:

h1 = 1 = 21 - 1

h2 = 3 = 22 - 1

h3 = 7 = 23 - 1

h4 = 15 = 24 - 1

h5 = 31 = 25 - 1

h6 = 63 = 26 - 1

h7 = 127 = 27 - 1

In general:

hn = 2n - 1, for all n >= 1

Fibonacci

Another well known mathematical recursive function is one that computes the Fibonacci numbers:

Pseudocode

function fib is:

input: integer n such that n >= 0

1. if n is 0, return 0

2. if n is 1, return 1

3. otherwise, return [ fib(n-1) + fib(n-2) ]

end fib

*

* @param k indicates which Fibonacci number to compute.

* @return the kth Fibonacci number.

*/

private static int fib(int k) {

// Base Case:

// If k <= 2 then fib(k) = 1.

if (k <= 2) {

return 1;

}

// Recursive Case:

// If k > 2 then fib(k) = fib(k-1) + fib(k-2).

else {

return fib(k-1) + fib(k-2);

}

}

Recurrence relation for Fibonacci:bn = bn-1 + bn-2

b1 = 1, b0 = 0

Computing the recurrence relation for n = 4:

b4 = b3 + b2

= b2 + b1 + b1 + b0

= b1 + b0 + 1 + 1 + 0

= 1 + 0 + 1 + 1 + 0

= 3

This Fibonacci algorithm is a particularly poor example of recursion, because each time the function is executed on a number greater than one, it makes two function calls to itself, leading to an exponential number of calls (and thus exponential time complexity) in total. The following alternative approach uses two accumulator variables TwoBack and OneBack to "remember" the previous two Fibonacci numbers constructed, and so avoids the exponential time cost:

#include<stdio.h>

#include<conio.h>

long int fact(int x); // function prototype

void main()

{

int n,r,bino_cof;

clrscr();

printf("Enter the numbers n,r");

scanf("%d%d",&n,&r);

bino_cof= (fact(n)/(fact(n-r)*fact(r)));

printf("Binomial coefficient is %d ",bino_cof);

getch();

}

long int fact(int x)

{

int i,f=1;

for (i=1; i<=x; i++)

{

f= f*i;

}

return f;

}

Recursion versus iteration

Most programming languages in use today allow the direct specification of recursive functions and procedures. When such a function is called, the program's runtime environment keeps track of the various instances of the function (often using a call stack, although other methods may be used). Every recursive function can be transformed into an iterative function by replacing recursive calls with iterative control constructs and simulating the call stack with a stack explicitly managed by the program. Conversely, all iterative functions and procedures that can be evaluated by a computer (see Turing completeness) can be expressed in terms of recursive functions; iterative control constructs such as while loops and do loops routinely are rewritten in recursive form in functional languages. However, in practice this rewriting depends on tail call elimination, which is not a feature of all languages. C, Java, and Python are notable mainstream languages in which all function calls, including tail calls, cause stack allocation that would not occur with the use of looping constructs; in these languages, a working iterative program rewritten in recursive form may overflow the call stack.

Performance issues

In languages (such as C and Java) that favor iterative looping constructs, there is usually significant time and space cost associated with recursive programs, due to the overhead required to manage the stack and the relative slowness of function calls; in functional languages, a function call (particularly a tail call) is typically a very fast operation, and the difference is usually less noticeable.

As a concrete example, the difference in performance between recursive and iterative implementations of the "factorial" example above depends highly on the language used. In languages where looping constructs are preferred, the iterative version may be as much as several orders of magnitude faster than the recursive one. In functional languages, the overall time difference of the two implementations may be negligible; in fact, the cost of multiplying the larger numbers first rather than the smaller numbers (which the iterative version given here happens to do) may overwhelm any time saved by choosing iteration.

Other considerations

In some programming languages, the stack space available to a thread is much less than the space available in the heap, and recursive algorithms tend to require more stack space than iterative algorithms. Consequently, these languages sometimes place a limit on the depth of recursion to avoid stack overflows. (Python is one such language.) Note the caveat below regarding the special case of tail recursion.

There are some types of problems whose solutions are inherently recursive, because of prior state they need to track. One example is tree traversal; others include the Ackermann function, depth-first search, and divide-and-conquer algorithms such as Quicksort. All of these algorithms can be implemented iteratively with the help of an explicit stack, but the programmer effort involved in managing the stack, and the complexity of the resulting program, arguably outweigh any advantages of the iterative solution

Bubble sort

A bubble sort, a sorting algorithm that continuously steps through a list, swapping items until they appear in the correct order.

Bubble sort is a straightforward and simplistic method of sorting data that is used in computer science education. The algorithm starts at the beginning of the data set. It compares the first two elements, and if the first is greater than the second, then it swaps them. It continues doing this for each pair of adjacent elements to the end of the data set. It then starts again with the first two elements, repeating until no swaps have occurred on the last pass. This algorithm is highly inefficient, and is rarely used except as a simplistic example. For example, if we have 100 elements then the total number of comparisons will be 10000. A slightly better variant, cocktail sort, works by inverting the ordering criteria and the pass direction on alternating passes. The modified Bubble sort will stop 1 shorter each time through the loop, so the total number of comparisons for 100 elements will be 4950.

Bubble sort average case and worst case are both O(n²).

Insertion sort

Insertion sort is a simple sorting algorithm that is relatively efficient for small lists and mostly-sorted lists, and often is used as part of more sophisticated algorithms. It works by taking elements from the list one by one and inserting them in their correct position into a new sorted list. In arrays, the new list and the remaining elements can share the array's space, but insertion is expensive, requiring shifting all following elements over by one. Shell sort (see below) is a variant of insertion sort that is more efficient for larger lists.

Shell sort

Shell sort was invented by Donald Shell in 1959. It improves upon bubble sort and insertion sort by moving out of order elements more than one position at a time. One implementation can be described as arranging the data sequence in a two-dimensional array and then sorting the columns of the array using insertion sort.

Merge sort

Merge sort takes advantage of the ease of merging already sorted lists into a new sorted list. It starts by comparing every two elements (i.e., 1 with 2, then 3 with 4...) and swapping them if the first should come after the second. It then merges each of the resulting lists of two into lists of four, then merges those lists of four, and so on; until at last two lists are merged into the final sorted list. Of the algorithms described here, this is the first that scales well to very large lists, because its worst-case running time is O(n log n). Merge sort has seen a relatively recent surge in popularity for practical implementations, being used for the standard sort routine in the programming languages Perl, Python and Java (also uses timsort as of JDK7, among others. Merge sort has been used in Java at least since 2000 in JDK1.3.

Heapsort

Heapsort is a much more efficient version of selection sort. It also works by determining the largest (or smallest) element of the list, placing that at the end (or beginning) of the list, then continuing with the rest of the list, but accomplishes this task efficiently by using a data structure called a heap, a special type of binary tree. Once the data list has been made into a heap, the root node is guaranteed to be the largest(or smallest) element. When it is removed and placed at the end of the list, the heap is rearranged so the largest element remaining moves to the root. Using the heap, finding the next largest element takes O(log n) time, instead of O(n) for a linear scan as in simple selection sort. This allows Heapsort to run in O(n log n) time.

Quicksort

Quicksort is a divide and conquer algorithm which relies on a partition operation: to partition an array, we choose an element, called a pivot, move all smaller elements before the pivot, and move all greater elements after it. This can be done efficiently in linear time and in-place. We then recursively sort the lesser and greater sublists. Efficient implementations of quicksort (with in-place partitioning) are typically unstable sorts and somewhat complex, but are among the fastest sorting algorithms in practice. Together with its modest O(log n) space usage, this makes quicksort one of the most popular sorting algorithms, available in many standard libraries. The most complex issue in quicksort is choosing a good pivot element; consistently poor choices of pivots can result in drastically slower O(n²) performance, but if at each step we choose the median as the pivot then it works in O(n log n). Finding the median, however, is an O(n) operation on unsorted lists, and therefore exacts its own penalty.

Radix sort

Radix sort is an algorithm that sorts a list of fixed-size numbers of length k in O(n · k) time by treating them as bit strings. We first sort the list by the least significant bit while preserving their relative order using a stable sort. Then we sort them by the next bit, and so on from right to left, and the list will end up sorted. Most often, the counting sort algorithm is used to accomplish the bitwise sorting, since the number of values a bit can have is minimal - only '1' or '0'.

Sorting Algorithm Examples

This is a collection of programs implementing a wide variety of sorting algorithms. The code has been optimized for speed instead of readability. You will find them to perform better than the perspective standard algorithms. The Combo Sort should be suitable for production usages.

Bubble Sort

Exchange two adjacent elements if they are out of order. Repeat until array is sorted. This is a slow algorithm.

#include <stdlib.h>

#include <stdio.h>

#define uint32 unsigned int

typedef int (*CMPFUN)(int, int);

void ArraySort(int This[], CMPFUN fun_ptr, uint32 ub)

{

/* bubble sort */

uint32 indx;

uint32 indx2;

int temp;

int temp2;

int flipped;

if (ub <= 1)

return;

indx = 1;

do

{

flipped = 0;

for (indx2 = ub - 1; indx2 >= indx; --indx2)

{

temp = This[indx2];

temp2 = This[indx2 - 1];

if ((*fun_ptr)(temp2, temp) > 0)

{

This[indx2 - 1] = temp;

This[indx2] = temp2;

flipped = 1;

}

}

} while ((++indx < ub) && flipped);

}

#define ARRAY_SIZE 14

int my_array[ARRAY_SIZE];

void fill_array()

{

int indx;

for (indx=0; indx < ARRAY_SIZE; ++indx)

{

my_array[indx] = rand();

}

/* my_array[ARRAY_SIZE - 1] = ARRAY_SIZE / 3; */

}

int cmpfun(int a, int b)

{

if (a > b)

return 1;

else if (a < b)

return -1;

else

return 0;

}

int main()

{

int indx;

int indx2;

for (indx2 = 0; indx2 < 80000; ++indx2)

{

fill_array();

ArraySort(my_array, cmpfun, ARRAY_SIZE);

for (indx=1; indx < ARRAY_SIZE; ++indx)

{

if (my_array[indx - 1] > my_array[indx])

{ printf("bad sort\n");

return(1);

}

}

}

return(0);

}

Selection Sort

Find the largest element in the array, and put it in the proper place. Repeat until array is sorted. This is also slow.

#include <stdlib.h>

#include <stdio.h>

#define uint32 unsigned int

typedef int (*CMPFUN)(int, int);

void ArraySort(int This[], CMPFUN fun_ptr, uint32 the_len)

{

/* selection sort */

uint32 indx;

uint32 indx2;

uint32 large_pos

int temp;

int large;

if (the_len <= 1)

return;

for (indx = the_len - 1; indx > 0; --indx)

{

/* find the largest number, then put it at the end of the array */

large = This[0];

large_pos = 0;

for (indx2 = 1; indx2 <= indx; ++indx2)

{

temp = This[indx2];

if ((*fun_ptr)(temp ,large) > 0)

{

large = temp;

large_pos = indx2;

}

}

This[large_pos] = This[indx];

This[indx] = large;

}

}

#define ARRAY_SIZE 14

int my_array[ARRAY_SIZE];

void fill_array()

{

int indx;

for (indx=0; indx < ARRAY_SIZE; ++indx)

{

my_array[indx] = rand();

}

/* my_array[ARRAY_SIZE - 1] = ARRAY_SIZE / 3; */

}

int cmpfun(int a, int b)

{

if (a > b)

return 1;

else if (a < b)

return -1;

else

return 0;

}

int main()

{

int indx;

int indx2;

for (indx2 = 0; indx2 < 80000; ++indx2)

{

fill_array();

ArraySort(my_array, cmpfun, ARRAY_SIZE);

for (indx=1; indx < ARRAY_SIZE; ++indx)

{

if (my_array[indx - 1] > my_array[indx])

{

printf("bad sort\n");

return(1);

}

}

}

return(0);

}

Insertion Sort

Scan successive elements for out of order item, then insert the item in the proper place. Sort small array fast, big array very slowly.

#include <stdlib.h>

#include <stdio.h>

#define uint32 unsigned int

typedef int (*CMPFUN)(int, int);

void ArraySort(int This[], CMPFUN fun_ptr, uint32 the_len)

{

/* insertion sort */

uint32 indx;

int cur_val;

int prev_val;

if (the_len <= 1)

return;

prev_val = This[0];

for (indx = 1; indx < the_len; ++indx)

{

cur_val = This[indx];

if ((*fun_ptr)(prev_val, cur_val) > 0)

{

/* out of order: array[indx-1] > array[indx] */

uint32 indx2;

This[indx] = prev_val; /* move up the larger item first */

/* find the insertion point for the smaller item */

for (indx2 = indx - 1; indx2 > 0;)

{

int temp_val = This[indx2 - 1];

if ((*fun_ptr)(temp_val, cur_val) > 0)

{

This[indx2--] = temp_val;

/* still out of order, move up 1 slot to make room */

}

else

break;

}

This[indx2] = cur_val; /* insert the smaller item right here */

}

else

{

/* in order, advance to next element */

prev_val = cur_val;

}

}

}

#define ARRAY_SIZE 14

int my_array[ARRAY_SIZE];

uint32 fill_array()

{

int indx;

uint32 checksum = 0;

for (indx=0; indx < ARRAY_SIZE; ++indx)

{

checksum += my_array[indx] = rand();

}

return checksum;

}

int cmpfun(int a, int b)

{

if (a > b)

return 1;

else if (a < b)

return -1;

else

return 0;

}

int main()

{

int indx;

int indx2;

uint32 checksum1;

uint32 checksum2;

for (indx2 = 0; indx2 < 80000; ++indx2)

{

checksum1 = fill_array();

ArraySort(my_array, cmpfun, ARRAY_SIZE);

for (indx=1; indx < ARRAY_SIZE; ++indx)

{

if (my_array[indx - 1] > my_array[indx])

{

printf("bad sort\n");

return(1);

}

}

checksum2 = 0;

for (indx=0; indx < ARRAY_SIZE; ++indx)

{

checksum2 += my_array[indx];

}

if (checksum1 != checksum2)

{

printf("bad checksum %d %d\n", checksum1, checksum2);

}

}

return(0);

}

Quicksort

Partition array into two segments. The first segment all elements are less than or equal to the pivot value. The second segment all elements are greater or equal to the pivot value. Sort the two segments recursively. Quicksort is fastest on average, but sometimes unbalanced partitions can lead to very slow sorting.

#include <stdlib.h>

#include <stdio.h>

#define INSERTION_SORT_BOUND 16 /* boundary point to use insertion sort */

#define uint32 unsigned int

typedef int (*CMPFUN)(int, int);

/* explain function

* Description:

* fixarray::Qsort() is an internal subroutine that implements quick sort.

* Return Value: none */

void Qsort(int This[], CMPFUN fun_ptr, uint32 first, uint32 last)

{

uint32 stack_pointer = 0;

int first_stack[32];

int last_stack[32];

for (;;) {

if (last - first <= INSERTION_SORT_BOUND)

{

/* for small sort, use insertion sort */

uint32 indx;

int prev_val = This[first];

int cur_val;

for (indx = first + 1; indx <= last; ++indx)

{

cur_val = This[indx];

if ((*fun_ptr)(prev_val, cur_val) > 0)

{ /* out of order: array[indx-1] > array[indx] */

uint32 indx2;

This[indx] = prev_val; /* move up the larger item first */

/* find the insertion point for the smaller item */

for (indx2 = indx - 1; indx2 > first; )

{

int temp_val = This[indx2 - 1];

if ((*fun_ptr)(temp_val, cur_val) > 0)

{

This[indx2--] = temp_val;

/* still out of order, move up 1 slot to make room */

}

else

break;

}

This[indx2] = cur_val; /* insert the smaller item right here */

}

else

{

/* in order, advance to next element */

prev_val = cur_val;

}

}

}

else

{

int pivot;

/* try quick sort */

{

int temp;

uint32 med = (first + last) >> 1;

/* Choose pivot from first, last, and median position. */

/* Sort the three elements. */

temp = This[first];

if ((*fun_ptr)(temp, This[last]) > 0)

{

This[first] = This[last]; This[last] = temp;

}

temp = This[med];

if ((*fun_ptr)(This[first], temp) > 0)

{

This[med] = This[first]; This[first] = temp;

}

temp = This[last];

if ((*fun_ptr)(This[med], temp) > 0)

{

This[last] = This[med]; This[med] = temp;

}

pivot = This[med];

}

{

uint32 up;

{

uint32 down;

/* First and last element will be loop stopper. */

/* Split array into two partitions. */

down = first;

up = last;

for (;;)

{

do

{

++down;

} while ((*fun_ptr)(pivot, This[down]) > 0);

do {

--up;

} while ((*fun_ptr)(This[up], pivot) > 0);

if (up > down)

{

int temp;

/* interchange L[down] and L[up] */

temp = This[down]; This[down]= This[up]; This[up] = temp;

}

else

break;

}

}

{

uint32 len1; /* length of first segment */

uint32 len2; /* length of second segment */

len1 = up - first + 1;

len2 = last - up;

/* stack the partition that is larger */

if (len1 >= len2)

{

first_stack[stack_pointer] = first;

last_stack[stack_pointer++] = up;

first = up + 1;

/* tail recursion elimination of

* Qsort(This,fun_ptr,up + 1,last)

*/ }

else

{ first_stack[stack_pointer] = up + 1;

last_stack[stack_pointer++] = last;

` last = up;

/* tail recursion elimination of

* Qsort(This,fun_ptr,first,up) */

} }

continue; }

/* end of quick sort */ }

if (stack_pointer > 0)

{ /* Sort segment from stack. */

first = first_stack[--stack_pointer];

last = last_stack[stack_pointer];

} else

break;

} /* end for */}

void ArraySort(int This[], CMPFUN fun_ptr, uint32 the_len)

{ Qsort(This, fun_ptr, 0, the_len - 1);}

#define ARRAY_SIZE 250000

int my_array[ARRAY_SIZE];

uint32 fill_array()

{ int indx;

uint32 checksum = 0;

for (indx=0; indx < ARRAY_SIZE; ++indx)

{ checksum += my_array[indx] = rand(); }

return checksum;}

int cmpfun(int a, int b)

{ if (a > b)

return 1;

else if (a < b)

return -1;

else

return 0;}

int main()

{ int indx;

uint32 checksum1;

uint32 checksum2 = 0;

checksum1 = fill_array();

ArraySort(my_array, cmpfun, ARRAY_SIZE);

for (indx=1; indx < ARRAY_SIZE; ++indx)

{ if (my_array[indx - 1] > my_array[indx])

{ printf("bad sort\n");

return(1); } }

for (indx=0; indx < ARRAY_SIZE; ++indx)

{ checksum2 += my_array[indx]; }

if (checksum1 != checksum2)

{ printf("bad checksum %d %d\n", checksum1, checksum2);

return(1); }

return(0);}

Mergesort

Start from two sorted runs of length 1, merge into a single run of twice the length. Repeat until a single sorted run is left. Mergesort needs N/2 extra buffer. Performance is second place on average, with quite good speed on nearly sorted array. Mergesort is stable in that two elements that are equally ranked in the array will not have their relative positions flipped.

#include <stdlib.h>

#include <stdio.h>

#define uint32 unsigned int

typedef int (*CMPFUN)(int, int);

#define INSERTION_SORT_BOUND 8 /* boundary point to use insertion sort */

void ArraySort(int This[], CMPFUN fun_ptr, uint32 the_len)

{ uint32 span;

uint32 lb;

uint32 ub;

uint32 indx;

uint32 indx2;

if (the_len <= 1)

return;

span = INSERTION_SORT_BOUND;

/* insertion sort the first pass */

{ int prev_val;

int cur_val;

int temp_val;

for (lb = 0; lb < the_len; lb += span)

{ if ((ub = lb + span) > the_len) ub = the_len;

prev_val = This[lb];

for (indx = lb + 1; indx < ub; ++indx)

{ cur_val = This[indx];

if ((*fun_ptr)(prev_val, cur_val) > 0)

{ /* out of order: array[indx-1] > array[indx] */

This[indx] = prev_val; /* move up the larger item first */

/* find the insertion point for the smaller item */

for (indx2 = indx - 1; indx2 > lb;)

{ temp_val = This[indx2 - 1];

if ((*fun_ptr)(temp_val, cur_val) > 0)

{ This[indx2--] = temp_val;

/* still out of order, move up 1 slot to make room */ }

else

break; }

This[indx2] = cur_val; /* insert the smaller item right here */ }

else { /* in order, advance to next element */

prev_val = cur_val; } } } }

/* second pass merge sort */

{ uint32 median;

int* aux;

aux = (int*) malloc(sizeof(int) * the_len / 2);

while (span < the_len)

{ /* median is the start of second file */

for (median = span; median < the_len;)

{ indx2 = median - 1;

if ((*fun_ptr)(This[indx2], This[median]) > 0)

{ /* the two files are not yet sorted */

if ((ub = median + span) > the_len)

{ ub = the_len; }

/* skip over the already sorted largest elements */

while ((*fun_ptr)(This[--ub], This[indx2]) >= 0)

{

}

/* copy second file into buffer */

for (indx = 0; indx2 < ub; ++indx)

{

*(aux + indx) = This[++indx2];

}

--indx;

indx2 = median - 1;

lb = median - span;

/* merge two files into one */

for (;;)

{

if ((*fun_ptr)(*(aux + indx), This[indx2]) >= 0)

{

This[ub--] = *(aux + indx);

if (indx > 0) --indx;

else

{

/* second file exhausted */

for (;;)

{

This[ub--] = This[indx2];

if (indx2 > lb) --indx2;

else goto mydone; /* done */

}

}

}

else

{

This[ub--] = This[indx2];

if (indx2 > lb) --indx2;

else

{

/* first file exhausted */

for (;;)

{

This[ub--] = *(aux + indx);

if (indx > 0) --indx;

else goto mydone; /* done */

}

}

}

}

}

mydone:

median += span + span;

}

span += span;

}

free(aux);

}

}

#define ARRAY_SIZE 250000

int my_array[ARRAY_SIZE];

uint32 fill_array()

{

int indx;

uint32 sum = 0;

for (indx=0; indx < ARRAY_SIZE; ++indx)

{

sum += my_array[indx] = rand();

}

return sum;

}

int cmpfun(int a, int b)

{

if (a > b)

return 1;

else if (a < b)

return -1;

else

return 0;

}

int main()

{

int indx;

uint32 checksum, checksum2;

checksum = fill_array();

ArraySort(my_array, cmpfun, ARRAY_SIZE);

checksum2 = my_array[0];

for (indx=1; indx < ARRAY_SIZE; ++indx)

{

checksum2 += my_array[indx];

if (my_array[indx - 1] > my_array[indx])

{

printf("bad sort\n");

return(1);

}

}

if (checksum != checksum2)

{

printf("bad checksum %d %d\n", checksum, checksum2);

return(1);

}

return(0);

}

Heapsort

Form a tree with parent of the tree being larger than its children. Remove the parent from the tree successively. On average, Heapsort is third place in speed. Heapsort does not need extra buffer, and performance is not sensitive to initial distributions.

#include <stdlib.h>

#include <stdio.h>

#define uint32 unsigned int

typedef int (*CMPFUN)(int, int);

void ArraySort(int This[], CMPFUN fun_ptr, uint32 the_len)

{

/* heap sort */

uint32 half;

uint32 parent;

if (the_len <= 1)

return;

half = the_len >> 1;

for (parent = half; parent >= 1; --parent)

{

int temp;

int level = 0;

uint32 child;

child = parent;

/* bottom-up downheap */

/* leaf-search for largest child path */

while (child <= half)

{

++level;

child += child;

if ((child < the_len) &&

((*fun_ptr)(This[child], This[child - 1]) > 0))

++child;

}

/* bottom-up-search for rotation point */

temp = This[parent - 1];

for (;;)

{

if (parent == child)

break;

if ((*fun_ptr)(temp, This[child - 1]) <= 0)

break;

child >>= 1;

--level;

}

/* rotate nodes from parent to rotation point */

for (;level > 0; --level)

{

This[(child >> level) - 1] =

This[(child >> (level - 1)) - 1];

}

This[child - 1] = temp;

}

--the_len;

do

{

int temp;

int level = 0;

uint32 child;

/* move max element to back of array */

temp = This[the_len];

This[the_len] = This[0];

This[0] = temp;

child = parent = 1;

half = the_len >> 1;

/* bottom-up downheap */

/* leaf-search for largest child path */

while (child <= half)

{

++level;

child += child;

if ((child < the_len) &&

((*fun_ptr)(This[child], This[child - 1]) > 0))

++child;

}

/* bottom-up-search for rotation point */

for (;;)

{

if (parent == child)

break;

if ((*fun_ptr)(temp, This[child - 1]) <= 0)

break;

child >>= 1;

--level;

}

/* rotate nodes from parent to rotation point */

for (;level > 0; --level)

{

This[(child >> level) - 1] =

This[(child >> (level - 1)) - 1];

}

This[child - 1] = temp;

} while (--the_len >= 1);

}

#define ARRAY_SIZE 250000

int my_array[ARRAY_SIZE];

void fill_array()

{

int indx;

for (indx=0; indx < ARRAY_SIZE; ++indx)

{

my_array[indx] = rand();

}

}

int cmpfun(int a, int b)

{

if (a > b)

return 1;

else if (a < b)

return -1;

else

return 0;

}

int main()

{

int indx;

fill_array();

ArraySort(my_array, cmpfun, ARRAY_SIZE);

for (indx=1; indx < ARRAY_SIZE; ++indx)

{

if (my_array[indx - 1] > my_array[indx])

{

printf("bad sort\n");

return(1);

}

}

return(0);

}

Time

Sort Average Best Worst Space Stability Remarks

Bubble sort O(n^2) O(n^2) O(n^2) Constant Stable Always use a modified bubble sort

Modified Bubble sort O(n^2) O(n) O(n^2) Constant Stable Stops after reaching a sorted array

Selection Sort O(n^2) O(n^2) O(n^2) Constant Stable Even a perfectly sorted input requires

scanning the entire array

Insertion Sort O(n^2) O(n) O(n^2) Constant Stable In the best case (already sorted),

every insert requires constant time

Heap Sort O(n*log(n)) O(n*log(n)) O(n*log(n)) Constant InstableBy using input array as storage for the heap, it is possible to achieve constant space

Merge Sort O(n*log(n)) O(n*log(n)) O(n*log(n)) Depends StableOn arrays, merge sort requires O(n) space; on linked lists, merge sort requires constant space

Quicksort O(n*log(n)) O(n*log(n)) O(n^2) Constant StableRandomly picking a pivot value (or shuffling the array prior to sorting) can help avoid worst case scenarios such as a perfectly sorted array.

SEARCHING:

linear search or sequential search is a method for finding a particular value in a list, that consists of checking every one of its elements, one at a time and in sequence, until the desired one is found. Linear search is the simplest search algorithm; it is a special case of brute-force search. Its worst case cost is proportional to the number of elements in the list; and so is its expected cost, if all list elements are equally likely to be searched for. Therefore, if the list has more than a few elements, other methods (such as binary search or hashing) may be much more efficient

#include<stdio.h> #include<conio.h> #include<stdlib.h>void main(){ int arr[100],i,element,no; clrscr(); printf("\nEnter the no of Elements: "); scanf("%d", &no); for(i=0;i<no;i++){ printf("\n Enter Element %d: ", i+1); scanf("%d",&arr[i]); } printf("\nEnter the element to be searched: "); scanf("%d", &element); for(i=0;i<no;i++){ if(arr[i] == element){ printf("\nElement found at position %d",i+1); getch(); exit(1); } } printf("\nElement not found"); getch(); } Output:

Enter the no of Elements: 5 Enter Element 1: 12 Enter Element 2: 23 Enter Element 3: 52 Enter Element 4: 23 Enter Element 5: 10 Enter the element to be searched: 23 Element found at position 2

binary search is an algorithm for locating the position of an element in a sorted list. It inspects the middle element of the sorted list: if equal to the sought value, then the position has been found; otherwise, the upper half or lower half is chosen for further searching based on whether the sought value is greater than or less than the middle element. The method reduces the number of elements needed to be checked by a factor of two each time, and finds the sought value if it exists in the list or if not determines "not present", in logarithmic time. A binary search is a dichotomic divide and conquer search algorithm.

Viewing the comparison as a subtraction of the sought value from the middle element, only the sign of the difference is inspected: there is no attempt at an interpolation search based on the size of the difference.

void main(){int array[10];int i, j, N, temp, keynum;int low,mid,high;

clrscr();

printf("Enter the value of N\n");scanf("%d",&N);

printf("Enter the elements one by one\n");for(i=0; i{scanf("%d",&array[i]);}printf("Input array elements\n");for(i=0; i

{printf("%d\n",array[i]);}/* Bubble sorting begins */for(i=0; i< N ; i++){for(j=0; j< (N-i-1) ; j++){if(array[j] > array[j+1]){temp = array[j];array[j] = array[j+1];array[j+1] = temp;}}}printf("Sorted array is...\n");for(i=0; i{printf("%d\n",array[i]);}

printf("Enter the element to be searched\n");scanf("%d", &keynum);

/* Binary searching begins */

low=1;high=N;

do{mid= (low + high) / 2;if ( keynum < array[mid] )high = mid - 1;else if ( keynum > array[mid])low = mid + 1;} while( keynum!=array[mid] && low <= high); /* End of do- while */

if( keynum == array[mid] ){printf("SUCCESSFUL SEARCH\n");}else{printf("Search is FAILED\n");}

} /* End of main*/

Stacks and Queues

Two of the more common data objects found in computer algorithms are stacks and queues. Both of these objects are special cases of the more general data object, an ordered list.

A stack is an ordered list in which all insertions and deletions are made at one end, called the top. A queue is an ordered list in which all insertions take place at one end, the rear, while all deletions take place at the other end, the front. Given a stack S=(a[1],a[2],.......a[n]) then we say that a1 is the bottommost element and element a[i]) is on top of element a[i-1], 1<i<=n. When viewed as a queue with a[n] as the rear element one says that a[i+1] is behind a[i], 1<i<=n.

The restrictions on a stack imply that if the elements A,B,C,D,E are added to the stack, n that order, then th efirst element to be removed/deleted must be E. Equivalently we say that the last element to be inserted into the stack will be the first to be removed. For this reason stacks are sometimes referred to as Last In First Out (LIFO) lists. The restrictions on queue imply that the first element which is inserted into the queue will be the first one to be removed. Thus A is the first letter to be removed, and queues are known as First In First Out (FIFO) lists. Note that the data object queue as defined here need not necessarily correspond to the mathemathical concept of queue in which the insert/delete rules may be different.

Adding an element into a stack.

Deleting an element from a stack.

Adding an element into a queue.

Deleting an element from a queue

Adding into stack

procedure add(item : items); {add item to the global stack stack; top is the current top of stack and n is its maximum size} begin if top = n then stackfull; top := top+1;

stack(top) := item; end: {of add}

Deletion in stack

procedure delete(var item : items); {remove top element from the stack stack and put it in the item} begin if top = 0 then stackempty; item := stack(top); top := top-1; end; {of delete}

These two procedures are so simple that they perhaps need no more explanation. Procedure delete actually combines the functions TOP and DELETE, stackfull and stackempty are procedures which are left unspecified since they will depend upon the particular application. Often a stackfull condition will signal that more storage needs to be allocated and the program re-run. Stackempty is often a meaningful condition.

Addition into a queue

procedure addq (item : items); {add item to the queue q} begin if rear=n then queuefull else begin rear :=rear+1; q[rear]:=item; end; end;{of addq}

Deletion in a queue

procedure deleteq (var item : items); {delete from the front of q and put into item} begin if front = rear then queueempty else begin front := front+1 item := q[front]; end; end; {of deleteq}

/* Program of stack using array*/#include#define MAX 5

int top = -1;int stack_arr[MAX];

main(){int choice;while(1){printf("1.Push\n");printf("2.Pop\n");printf("3.Display\n");printf("4.Quit\n");printf("Enter your choice : ");scanf("%d",&choice);switch(choice){case 1 :push();break;case 2:pop();break;case 3:display();break;case 4:exit(1);default:printf("Wrong choice\n");}/*End of switch*/}/*End of while*/}/*End of main()*/

push(){int pushed_item;if(top == (MAX-1))printf("Stack Overflow\n");else{printf("Enter the item to be pushed in stack : ");scanf("%d",&pushed_item);top=top+1;stack_arr[top] = pushed_item;}}/*End of push()*/

pop(){if(top == -1)printf("Stack Underflow\n");else{printf("Popped element is : %d\n",stack_arr[top]);top=top-1;}}/*End of pop()*/

display(){int i;if(top == -1)printf("Stack is empty\n");else{printf("Stack elements :\n");for(i = top; i >=0; i--)printf("%d\n", stack_arr[i] );}}/*End of display()*/

Applications:

As I already said - Stacks help computers in unfolding their recursive jobs; used in converting an expression to its postfix form; used in Graphs to find their traversals (we have seen that); helps in non-recursive traversal of binary trees (we'll see this) and so on....

Well, we'll see here, its role in converting an infix to a postfix expression. The rest of them I've some how covered in other parts of my tutorial. So here we go....

An INFIX expression is nothing but any regular expression having operators in between operands; and obviously, the POSTFIX is the one with operands followed by their respective operators. I'll take an example...

If a/b-c*d is your infix expression then ab/cd*- will be its postfix form. How ?...Let's see.

First step is to apply brackets to the expression following the BODMAS rule; then just move the operators to their respective closing brackets. The resultant is your Postfix expression. Remember, this is the manual way of doing it.

((a/b)-(c*d))  ==> ==> ab/cd*-

Now, where does Stack figure out in between? Well, when the computer has to do this conversion, it makes use of Stack. See how..

Algorithm:-Step-1: Check whether the current element in the expression is an operator or operand. If its an operand then go to step-2 or else step-3Step-2: Put the element in the Postfix output stream and go for the next element in the expression, if any

Step-3: a. find the priority of that operator            b. if the operator's priority > priority of Stack's top then push that operator inside the                 stack and go for the next element; or else pop the stack, write that value to the                 Postfix output stream and go to start of this step Step-4: Empty the Stack and put the popped values to the output stream directly

C implementation:-/*This is just a broad outline of the exact implementation. The actual implementation is downloadable*/char[] infix_to_postfix(char *expr){ static char out[], i; while(*expr != NULL) { if(*expr == OPERAND) /*step-1*/      { out[i] = *expr; i = i+1;}    /*step-2*/   else      { /*step-3*/       while(priority(*expr) <=  priority(stack[top]))        {         out[i] = pop( );         i = i + 1;        }        push(*expr);      } expr++; } while( top != -1) /*step-4*/   { out[i] = pop( ); i++;} return(out);

A queue (pronounced /kjuː/) is a particular kind of collection in which the entities in the collection are kept in order and the principal (or only) operations on the collection are the addition of entities to the rear terminal position and removal of entities from the front terminal position. This makes the queue a First-In-First-Out (FIFO) data structure. In a FIFO data structure, the first element added to the queue will be the first one to be removed. This is equivalent to the requirement that whenever an element is added, all elements that were added before have to be removed before the new element can be invoked. A queue is an example of a linear data structure.

Queues provide services in computer science, transport and operations research where various entities such as data, objects, persons, or events are stored and held to be processed later. In these contexts, the queue performs the function of a buffer.

Queues are common in computer programs, where they are implemented as data structures coupled with access routines, as an abstract data structure or in object-oriented languages as classes. Common implementations are circular buffers and linked lists.

A queue (pronounced /kjuː/) is a particular kind of collection in which the entities in the collection are kept in order and the principal (or only) operations on the collection are the addition of entities to the rear terminal position and removal of entities from the front terminal position. This makes the queue a First-In-First-Out (FIFO) data structure. In a FIFO data structure, the first element added to the queue

will be the first one to be removed. This is equivalent to the requirement that whenever an element is added, all elements that were added before have to be removed before the new element can be invoked. A queue is an example of a linear data structure.

Queues provide services in computer science, transport and operations research where various entities such as data, objects, persons, or events are stored and held to be processed later. In these contexts, the queue performs the function of a buffer.

Queues are common in computer programs, where they are implemented as data structures coupled with access routines, as an abstract data structure or in object-oriented languages as classes. Common implementations are circular buffers and linked lists.

/*Program of queue using array*/# include# define MAX 5

int queue_arr[MAX];int rear = -1;int front = -1;

main(){int choice;while(1){printf("1.Insert\n");printf("2.Delete\n");printf("3.Display\n");printf("4.Quit\n");printf("Enter your choice : ");scanf("%d",&choice);

switch(choice){case 1 :insert();break;case 2 :del();break;case 3:display();break;case 4:exit(1);default:printf("Wrong choice\n");}/*End of switch*/}/*End of while*/}/*End of main()*/

insert(){int added_item;if (rear==MAX-1)printf("Queue Overflow\n");else{if (front==-1) /*If queue is initially empty */front=0;printf("Input the element for adding in queue : ");scanf("%d", &added_item);rear=rear+1;queue_arr[rear] = added_item ;}}/*End of insert()*/

del(){if (front == -1 || front > rear){printf("Queue Underflow\n");return ;}else{printf("Element deleted from queue is : %d\n", queue_arr[front]);front=front+1;}}/*End of del() */

display(){int i;if (front == -1)printf("Queue is empty\n");else{printf("Queue is :\n");for(i=front;i<= rear;i++)printf("%d ",queue_arr[i]);printf("\n");}}/*End of display() */

A priority queue is an abstract data type in computer programming that supports the following three operations:

insertWithPriority: add an element to the queue with an associated priority

getNext: remove the element from the queue that has the highest priority, and return it (also known as "PopElement(Off)", or "GetMinimum")

peekAtNext (optional): look at the element with highest priority without removing it

a double-ended queue (often abbreviated to deque, pronounced deck) is an abstract data structure that implements a queue for which elements can only be added to or removed from the front (head) or back (tail). It is also often called a head-tail linked list.

A linked list is called so because each of items in the list is a part of a structure, which is linked to the structure containing the next item. This type of list is called a linked list since it can be considered as a list whose order is given by links from one item to the next.

Structure

Item ®

Each item has a node consisting two fields one containing the variable and another consisting of address of the next item(i.e., pointer to the next item) in the list. A linked list is therefore a collection of structures ordered by logical links that are stored as the part of data.

Consider the following example to illustrator the concept of linking. Suppose we define a structure as follows

struct linked_list { float age; struct linked_list *next; } struct Linked_list node1,node2;

this statement creates space for nodes each containing 2 empty fields node1

node1.age

node1.next

node2

node2.age

node2.next

The next pointer of node1 can be made to point to the node 2 by the same statement. node1.next=&node2;

This statement stores the address of node 2 into the field node1.next and this establishes a link between node1 and node2 similarly we can combine the process to create a special pointer value called null that can be stored in the next field of the last node

Advantages of Linked List:

A linked list is a dynamic data structure and therefore the size of the linked list can grow or shrink in size during execution of the program. A linked list does not require any extra space therefore it does not waste extra memory. It provides flexibility in rearranging the items efficiently.

The limitation of linked list is that it consumes extra space when compared to a array since each node must also contain the address of the next item in the list to search for a single item in a linked list is cumbersome and time consuming.

Types of linked list:

There are different kinds of linked lists they are Linear singly linked list Circular singly linked list Two way or doubly linked list Circular doubly linked list.

Applications of linked lists:

Linked lists concepts are useful to model many different abstract data types such as queues stacks and trees. If we restrict the process of insertions to one end of the list and deletions to the other en

Linear and circular lists

In the last node of a list, the link field often contains a null reference, a special value that is interpreted by programs as meaning "there is no such node". A less common convention is to make it point to the first node of the list; in that case the list is said to be circular or circularly linked; otherwise it is said to be open or linear.

Singly-, doubly-, and multiply-linked lists

Singly-linked lists contain nodes which have a data field as well as a next field, which points to the next node in the linked list.

In a doubly-linked list, each node contains, besides the next-node link, a second link field pointing to the previous node in the sequence. The two links may be called forward(s) and backwards, or next and prev(ious).

A doubly-linked list whose nodes contain three fields: an integer value, the link forward to the next node, and the link backward to the previous node

The technique known as XOR-linking allows a doubly-linked list to be implemented using a single link field in each node. However, this technique requires the ability to do bit operations on addresses, and therefore may not be available in some high-level languages.

In a multiply-linked list, each node contains two or more link fields, each field being used to connect the same set of data records in a different order (e.g., by name, by department, by date of birth, etc.). (While doubly-linked lists can be seen as special cases of multiply-linked list, the fact that the two orders are opposite to each other leads to simpler and more efficient algorithms, so they are usually treated as a separate case.)

In the case of a doubly circular linked list, the only change that occurs is the end, or "tail" of the said list is linked back to the front, "head", of the list and vice versa.

TREES:

In computer science, a tree is a widely-used data structure that emulates a hierarchical tree structure with a set of linked nodes.

Mathematically, it is a tree, more specifically an arborescence: an acyclic connected graph where each node has zero or more children nodes and at most one parent node. Furthermore, the children of each node have a specific order.

Binary TreesThe simplest form of tree is a binary tree. A binary tree consists of

a. a node (called the root node) and b. left and right sub-trees.

Both the sub-trees are themselves binary trees.

A binary tree

The nodes at the lowest levels of the tree (the ones with no sub-trees) are called leaves.

In an ordered binary tree,

1. the keys of all the nodes in the left sub-tree are less than that of the root, 2. the keys of all the nodes in the right sub-tree are greater than that of the root,

3. the left and right sub-trees are themselves ordered binary trees.

Data StructureThe data structure for the tree implementation simply adds left and right pointers in place of the next pointer of the linked list implementation.

Complete TreesBefore we look at more general cases, let's make the optimistic assumption that we've managed to fill our tree neatly, ie that each leaf is the same 'distance' from the root.

This forms a complete tree, whose height is defined as the number of links from the root to the deepest leaf.

A complete tree

First, we need to work out how many nodes, n, we have in such a tree of height, h.

Now,

n = 1 + 21 + 22 + .... + 2h

From which we have,

n = 2h+1 - 1

and

h = floor( log2n )

Examination of the Find method shows that in the worst case, h+1 or ceiling( log2n ) comparisons are needed to find an item. This is the same as for binary search.

However, Add also requires ceiling( log2n ) comparisons to determine where to add an item. Actually adding the item takes a constant number of operations, so we say that a binary tree requires O(logn) operations for both adding and finding an item - a considerable improvement over binary search for a dynamic structure which often requires addition of new items.

Deletion is also an O(logn) operation.

General binary treesHowever, in general addition of items to an ordered tree will not produce a complete tree. The worst case occurs if we add an ordered list of items to a tree.

This problem is readily overcome: we use a structure known as a heap. However, before looking at heaps, we should formalise our ideas about the complexity of algorithms by defining carefully what O(f(n)) means.

Root Node

Node at the "top" of a tree - the one from which all operations on the tree commence. The root node may not exist (a NULL tree with no nodes in it) or have 0, 1 or 2 children in a binary tree.

Leaf Node

Node at the "bottom" of a tree - farthest from the root. Leaf nodes have no children.

Complete Tree

Tree in which each leaf is at the same distance from the root. A more precise and formal definition of a complete tree is set out later.

Height

Number of nodes which must be traversed from the root to reach a leaf of a tree.

Binary search tree

In computer science, a binary search tree (BST) or ordered binary tree is a node-based binary tree data structure which has the following properties: The left subtree of a node contains only nodes with keys less than the node's key.

The right subtree of a node contains only nodes with keys greater than or equal to the node's key.

Both the left and right subtrees must also be binary search trees.

From the above properties it naturally follows that:

Each node (item in the tree) has a distinct key.

Generally, the information represented by each node is a record rather than a single data element. However, for sequencing purposes, nodes are compared according to their keys rather than any part of their associated records.

The major advantage of binary search trees over other data structures is that the related sorting algorithms and search algorithms such as in-order traversal can be very efficient.

Binary search trees are a fundamental data structure used to construct more abstract data structures such as sets, multisets, and associative arrays.

operations on a binary tree require comparisons between nodes. These comparisons are made with calls to a comparator, which is a subroutine that computes the total order (linear order) on any two values. This comparator can be explicitly or implicitly defined, depending on the language in which the BST is implemented.

Searching

Searching a binary tree for a specific value can be a recursive or iterative process. This explanation covers a recursive method.

We begin by examining the root node. If the tree is null, the value we are searching for does not exist in the tree. Otherwise, if the value equals the root, the search is successful. If the value is less than the root, search the left subtree. Similarly, if it is greater than the root, search the right subtree. This process is repeated until the value is found or the indicated subtree is null. If the

searched value is not found before a null subtree is reached, then the item must not be present in the tree.

Here is the search algorithm in the Python programming language:

# 'node' refers to the parent-node in this case def search_binary_tree(node, key): if node is None: return None # key not found if key < node.key: return search_binary_tree(node.leftChild, key) elif key > node.key: return search_binary_tree(node.rightChild, key) else: # key is equal to node key return node.value # found key

… or equivalent Haskell:

searchBinaryTree _ NullNode = Nothing searchBinaryTree key (Node nodeKey nodeValue (leftChild, rightChild)) = case compare key nodeKey of LT -> searchBinaryTree key leftChild GT -> searchBinaryTree key rightChild EQ -> Just nodeValue

This operation requires O(log n) time in the average case, but needs O(n) time in the worst case, when the unbalanced tree resembles a linked list (degenerate tree).

Assuming that BinarySearchTree is a class with a member function "search(int)" and a pointer to the root node, the algorithm is also easily implemented in terms of an iterative approach. The algorithm enters a loop, and decides whether to branch left or right depending on the value of the node at each parent node.

bool BinarySearchTree::search(int val){ Node* next = this->root(); while (next != 0) { if (val == next->value()) { return true; } else if (val < next->value()) { next = next->left(); } else if (val > next->value()) { next = next->right(); } }

//not found return false;}

Here is the search algorithm in the Java programming language:

public boolean search(TreeNode node, int data) {if (node == null) {

return false;}if (node.getData() == data) {

return true;} else if (data < node.getData()) {

// data must be in left subtreereturn search(node.getLeft(), data);

} else {// data must be in right subtreereturn search(node.getRight(), data);

}}

Insertion

Insertion begins as a search would begin; if the root is not equal to the value, we search the left or right subtrees as before. Eventually, we will reach an external node and add the value as its right or left child, depending on the node's value. In other words, we examine the root and recursively insert the new node to the left subtree if the new value is less than the root, or the right subtree if the new value is greater than or equal to the root.

Here's how a typical binary search tree insertion might be performed in C++:

/* Inserts the node pointed to by "newNode" into the subtree rooted at "treeNode" */ void InsertNode(Node* &treeNode, Node *newNode) { if (treeNode == NULL) treeNode = newNode; else if (newNode->key < treeNode->key) InsertNode(treeNode->left, newNode); else InsertNode(treeNode->right, newNode); }

The above "destructive" procedural variant modifies the tree in place. It uses only constant space, but the previous version of the tree is lost. Alternatively, as in the following Python example, we can reconstruct all ancestors of the inserted node; any reference to the original tree root remains valid, making the tree a persistent data structure:

def binary_tree_insert(node, key, value): if node is None: return TreeNode(None, key, value, None)

if key == node.key: return TreeNode(node.left, key, value, node.right) if key < node.key: return TreeNode(binary_tree_insert(node.left, key, value), node.key, node.value, node.right) else: return TreeNode(node.left, node.key, node.value, binary_tree_insert(node.right, key, value))

The part that is rebuilt uses Θ(log n) space in the average case and Ω(n) in the worst case (see big-O notation).

In either version, this operation requires time proportional to the height of the tree in the worst case, which is O(log n) time in the average case over all trees, but Ω(n) time in the worst case.

Another way to explain insertion is that in order to insert a new node in the tree, its value is first compared with the value of the root. If its value is less than the root's, it is then compared with the value of the root's left child. If its value is greater, it is compared with the root's right child. This process continues, until the new node is compared with a leaf node, and then it is added as this node's right or left child, depending on its value.

There are other ways of inserting nodes into a binary tree, but this is the only way of inserting nodes at the leaves and at the same time preserving the BST structure.

Here is an iterative approach to inserting into a binary search tree

public void insert(int data) {if (root == null) {

root = new TreeNode(data, null, null);} else {

TreeNode current = root;while (current != null) {

if (data < current.getData()) {// insert leftif (current.getLeft() == null) {

current.setLeft(new TreeNode(data, null, null));

return;} else {

current = current.getLeft();}

} else {

// insert rightif (current.getRight() == null) {

current.setRight(new TreeNode(data, null, null));

return;} else {

current = current.getRight();}

}}

}}

Below is a recursive approach to the insertion method. As pointers are not available ,we must return a new node pointer to the caller as indicated by the final line in the method.

public TreeNode insert(TreeNode node, int data) {if (node == null) {

node = new TreeNode(data, null, null);} else {

if (data < node.getData()) {// insert leftnode.left = insert(node.getLeft(), data);

} else {// insert rightnode.right = insert(node.getRight(), data);

}}return node;

}

Deletion

There are three possible cases to consider:

Deleting a leaf (node with no children): Deleting a leaf is easy, as we can simply remove it from the tree.

Deleting a node with one child: Delete the node and replace it with its child.

Deleting a node with two children: Call the node to be deleted "N". Do not delete N. Instead, choose either its in-order successor node or its in-order predecessor node, "R". Replace the value of N with the value of R, then delete R. (Note: R itself has up to one child.)

As with all binary trees, a node's in-order successor is the left-most child of its right subtree, and a node's in-order predecessor is the right-most child of its left subtree. In either case, this node will have zero or one children. Delete it according to one of the two simpler cases above.

Consistently using the in-order successor or the in-order predecessor for every instance of the two-child case can lead to an unbalanced tree, so good implementations add inconsistency to this selection.

Running Time Analysis: Although this operation does not always traverse the tree down to a leaf, this is always a possibility; thus in the worst case it requires time proportional to the height of the tree. It does not require more even when the node has two children, since it still follows a single path and does not visit any node twice.

Here is the code in Python:

def findMin(self): '''

Finds the smallest element that is a child of *self* ''' current_node = self while current_node.left_child: current_node = current_node.left_child return current_node def replace_node_in_parent(self, new_value=None): ''' Removes the reference to *self* from *self.parent* and replaces it with *new_value*. ''' if self == self.parent.left_child: self.parent.left_child = new_value else: self.parent.right_child = new_value if new_value: new_value.parent = self.parent def binary_tree_delete(self, key): if key < self.key: self.left_child.binary_tree_delete(key) elif key > self.key: self.right_child.binary_tree_delete(key) else: # delete the key here if self.left_child and self.right_child: # if both children are present # get the smallest node that's bigger than *self* successor = self.right_child.findMin() self.key = successor.key # if *successor* has a child, replace it with that # at this point, it can only have a *right_child* # if it has no children, *right_child* will be "None" successor.replace_node_in_parent(successor.right_child) elif self.left_child or self.right_child: # if the node has only one child if self.left_child: self.replace_node_in_parent(self.left_child) else: self.replace_node_in_parent(self.right_child) else: # this node has no children self.replace_node_in_parent(None)

Traversal

Once the binary search tree has been created, its elements can be retrieved in-order by recursively traversing the left subtree of the root node, accessing the node itself, then recursively traversing the right subtree of the node, continuing this pattern with each node in the tree as it's recursively accessed. As with all binary trees, one may conduct a pre-order traversal or a post-order traversal, but neither are likely to be useful for binary search trees.

The code for in-order traversal in Python is given below. It will call callback for every node in the tree.

def traverse_binary_tree(node, callback): if node is None: return traverse_binary_tree(node.leftChild, callback) callback(node.value) traverse_binary_tree(node.rightChild, callback)

Traversal requires Ω(n) time, since it must visit every node. This algorithm is also O(n), so it is asymptotically optimal.

Sort

A binary search tree can be used to implement a simple but efficient sorting algorithm. Similar to heapsort, we insert all the values we wish to sort into a new ordered data structure—in this case a binary search tree—and then traverse it in order, building our result:

def build_binary_tree(values): tree = None for v in values: tree = binary_tree_insert(tree, v) return tree def get_inorder_traversal(root): ''' Returns a list containing all the values in the tree, starting at *root*. Traverses the tree in-order(leftChild, root, rightChild). ''' result = [] traverse_binary_tree(root, lambda element: result.append(element)) return result

The worst-case time of build_binary_tree is Θ(n2)—if you feed it a sorted list of values, it chains them into a linked list with no left subtrees. For example, traverse_binary_tree([1, 2, 3, 4, 5]) yields the tree (1 (2 (3 (4 (5))))).

There are several schemes for overcoming this flaw with simple binary trees; the most common is the self-balancing binary search tree. If this same procedure is done using such a tree, the overall worst-case time is O(nlog n), which is asymptotically optimal for a comparison sort. In practice, the poor cache performance and added overhead in time and space for a tree-based sort (particularly for node allocation) make it inferior to other asymptotically optimal sorts such as heapsort for static list sorting. On the other hand, it is one of the most efficient methods of incremental sorting, adding items to a list over time while keeping the list sorted at all times.

TypesThere are many types of binary search trees. AVL trees and red-black trees are both forms of self-balancing binary search trees. A splay tree is a binary search tree that automatically moves frequently accessed elements nearer to the root. In a treap ("tree heap"), each node also holds a priority and the parent node has higher priority than its children.

Two other titles describing binary search trees are that of a complete and degenerate tree.

A complete tree is a tree with n levels, where for each level d <= n - 1, the number of existing nodes at level d is equal to 2d. This means all possible nodes exist at these levels. An additional requirement for a complete binary tree is that for the nth level, while every node does not have to exist, the nodes that do exist must fill from left to right.

A degenerate tree is a tree where for each parent node, there is only one associated child node. What this means is that in a performance measurement, the tree will essentially behave like a linked list data structure.

Performance comparisons

Optimal binary search trees

If we don't plan on modifying a search tree, and we know exactly how often each item will be accessed, we can construct an optimal binary search tree, which is a search tree where the average cost of looking up an item (the expected search cost) is minimized.

Even if we only have estimates of the search costs, such a system can considerably speed up lookups on average. For example, if you have a BST of English words used in a spell checker, you might balance the tree based on word frequency in text corpora, placing words like "the" near the root and words like "agerasia" near the leaves. Such a tree might be compared with Huffman trees, which similarly seek to place frequently-used items near the root in order to produce a dense information encoding; however, Huffman trees only store data elements in leaves and these elements need not be ordered.

If we do not know the sequence in which the elements in the tree will be accessed in advance, we can use splay trees which are asymptotically as good as any static search tree we can construct for any particular sequence of lookup operations.

Alphabetic trees are Huffman trees with the additional constraint on order, or, equivalently, search trees with the modification that all elements are stored in the leaves. Faster algorithms exist for optimal alphabetic binary trees (OABTs).

Tree traversal

In computer science, tree-traversal refers to the process of visiting (examining and/or updating) each node in a tree data structure, exactly once, in a systematic way. Such traversals are classified by the order in which the nodes are visited. The following algorithms are described for a binary tree, but they may be generalized to other trees as well.

Traversal

Compared to linear data structures like linked lists and one dimensional arrays, which have only one logical means of traversal, tree structures can be traversed in many different ways. Starting at the root of a binary tree, there are three main steps that can be performed and the order in which they are performed defines the traversal type. These steps (in no particular order) are: performing an action on the current node (referred to as "visiting" the node), traversing to the left child node, and traversing to the right child node. Thus the process is most easily described through recursion. The names given for particular style of traversal came from the position of root element with regard to the left and right nodes. Imagine that the left and right nodes are constant in space, then the root node could be placed to the left of the left node (pre-order), between the left and right node (in-order), or to the right of the right node (post-order).

Depth-first Traversal

To traverse a non-empty binary tree in preorder, perform the following operations recursively at each node, starting with the root node:

1. Visit the root. 2. Traverse the left subtree.

3. Traverse the right subtree.

To traverse a non-empty binary tree in inorder (symmetric), perform the following operations recursively at each node:

1. Traverse the left subtree. 2. Visit the root.

3. Traverse the right subtree.

To traverse a non-empty binary tree in postorder, perform the following operations recursively at each node:

1. Traverse the left subtree. 2. Traverse the right subtree.

3. Visit the root.

Breadth-first Traversal

Finally, trees can also be traversed in level-order, where we visit every node on a level before going to a lower level. This is also called Breadth-first traversal.

ExampleIn this binary search tree

Preorder traversal sequence: F, B, A, D, C, E, G, I, H (root, left, right) Inorder traversal sequence: A, B, C, D, E, F, G, H, I (left, root, right); note how this produces a

sorted sequence

Postorder traversal sequence: A, C, E, D, B, H, I, G, F (left, right, root)

Level-order traversal sequence: F, B, G, A, D, I, C, E, H pre-order in-order post-order level-order

push Fpop Fpush G Bpop Bpush D Apop Apop Dpush E Cpop Cpop Epop Gpush Ipop Ipush Hpop H

push F B Apop Apop Bpush D Cpop Cpop Dpush Epop Epop Fpush Gpop Gpush I Hpop Hpop I

push F B Apop Apush D Cpop Cpush Epop Epop Dpop Bpush G I Hpop Hpop Ipop Gpop F

push F B Gpop Fpush A Dpop Bpush Ipop Gpop Apush C Epop Dpush Hpop Ipop Cpop Epop H

Sample implementationspreorder(node) print node.value if node.left ≠ null then preorder(node.left) if node.right ≠ null then preorder(node.right)inorder(node) if node.left ≠ null then inorder(node.left) print node.value if node.right ≠ null then inorder(node.right)postorder(node) if node.left ≠ null then postorder(node.left) if node.right ≠ null then postorder(node.right) print node.value

All sample implementations will require call stack space proportional to the height of the tree. In a poorly balanced tree, this can be quite considerable.

We can remove the stack requirement by maintaining parent pointers in each node, or by threading the tree. In the case of using threads, this will allow for greatly improved inorder traversal, although retrieving the parent node required for preorder and postorder traversal will be slower than a simple stack based algorithm.

To traverse a threaded tree inorder, we could do something like this:

inorder(node) while hasleftchild(node) do node = node.left do visit(node) if (hasrightchild(node)) then

node = node.right while hasleftchild(node) do node = node.left else while node.parent ≠ null and node = node.parent.right node = node.parent node = node.parent while node ≠ null

Note that a threaded binary tree will provide a means of determining whether a pointer is a child, or a thread. See threaded binary trees for more information.

Inorder traversal

It is particularly common to use an inorder traversal on a binary search tree because this will return values from the underlying set in order, according to the comparator that set up the binary search tree (hence the name).

To see why this is the case, note that if n is a node in a binary search tree, then everything in n 's left subtree is less than n, and everything in n 's right subtree is greater than or equal to n. Thus, if we visit the left subtree in order, using a recursive call, and then visit n, and then visit the right subtree in order, we have visited the entire subtree rooted at n in order. We can assume the recursive calls correctly visit the subtrees in order using the mathematical principle of structural induction. Traversing in reverse inorder similarly gives the values in decreasing order.

Preorder traversal

Traversing a tree in preorder while inserting the values into a new tree is common way of making a complete copy of a binary search tree.

One can also use preorder traversals to get a prefix expression (Polish notation) from expression trees: traverse the expression tree preorderly. To calculate the value of such an expression: scan from right to left, placing the elements in a stack. Each time we find an operator, we replace the two top symbols of the stack with the result of applying the operator to those elements. For instance, the expression ∗ + 2 3 4, which in infix notation is (2 + 3) ∗ 4, would be evaluated like this:

Using prefix traversal to evaluate an expression tree

Expression (remaining) Stack

∗ + 2 3 4 <empty>

∗ + 2 3 4

∗ + 2 3 4

∗ + 2 3 4

∗ 5 4

Answer 20

MaxHeapify

template<class T> voidmaxHeapify(  T* vals

int n

int root  )

The function maxHeapify accepts a heap, defined by a pointer to its data and a total node count. It performs the heapify operation on the given root different to the actual root of the heap which resides in position 0 of the data array. A heap is a very important data structure in computing. It can be described as a nearly-complete binary tree. In more simple terms, a heap is a pyramidal data structure which grows downwards from a root node. Each level in the heap has to be complete before the next level begins. Each element in the heap has zero, one or two children. The (max) heap property is that a given node has a value which is greater than or equal to the values held by its children. Heaps are useful because they are very efficiently represented as an array. In the array representation, the following equations are necessary to calculate the indices of the left and right children:

(1)

(2)

(3)

The heapify operation works by assuming that each binary subtree at Left(i) and Right(i) is a heap, but A[i] may be smaller than its children, thus violating the heap property. The value

at A[i] is compared with its children and recursively propagated down the heap if necessary until the heap property is restored.

Note:

the root node index starts at 1 rather than 0

Parameters:vals the array of values

n the number of items in the array

root the root node for the heapify operation

HeapSort

template<class T> voidheapSort(  T* vals

int n  )

Heap sort permutes an array of values to lie in ascending numerical order. The code for heap sort is fairly compact, making it a good all round choice. The complexity of heap sort is:

(4)

Heap sort is best applied to very large data sets, of over a million items. The algorithm sorts in-place and therefore does not require the creation of auxiliary arrays (such as Array/Sort/bucket_Sort ). The algorithm is also non-recursive, so can never cause a stack overflow in the case of large data arrays. Heap sort is beaten by Array/Sort/quick_Sort in terms of speed, however, with large data sets the recursive nature of quick sort can become a limiting factor.

Heap sort works by firstly transforming the array of values into a max-heap using the maxHeapify function. The maximum values are then read out from the top of the heap one at a time, shrinking the heap by one iteratively. A index moves from the end of the array backwards. Here the maximum values are stored, creating the ascending sorted list.

Example 1:

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

 

#include <codecogs/array/sort/heap_sort.h>

 

int main()

{

double vals[25];

int n=25;

 

for (int i=0; i<n; i++) vals[i]=((double) n*rand())/RAND_MAX;

 

printf("\nArray to be sorted:\n");

for (int i=0; i<n; i++) printf("%3.0f ", vals[i]);

 

Array::Sort::heapSort(vals, n);

 

printf("\nSorted array:\n");

for (int i=0; i<n; i++) printf("%3.0f ", vals[i]);

printf("\n");

return 0;

}

Output:

Array to be sorted:

23 6 6 13 11 10 13 4 9 4

17 14 7 5 16 7 21 7 17 17

23 6 16 9 18

Sorted array:

4 4 5 6 6 6 7 7 7 9

9 10 11 13 13 14 16 16 17 17

17 18 21 23 23

Parameters:

vals the array of values to be sorted

n the number of items in the array