DataStructures

What are Hash Tables and how do they work?

refikh — Thu, 01 Mar 2007 09:27:58 +0000

As we saw with binary search, certain data structures such as a binary search tree can help improve the efficiency of searches. From linear search to binary search, we improved our search efficiency from O(n) to O(logn). We now present a new data structure, called a hash table, that will increase our efficiency to O(1), or constant time.

In computer science, a hash table, or a hash map, is a data structure that associates keys with values. The primary operation it supports efficiently is a lookup: given a key (e.g. a person’s name), find the corresponding value (e.g. that person’s telephone number). It works by transforming the key using a hash function into a hash, a number that is used to index into an array to locate the desired location (”bucket”) where the values should be.

Hash tables are often used to implement associative arrays, sets and caches. Like arrays, hash tables provide constant-time O(1) lookup on average, regardless of the number of items in the table. (O(1) means that it takes a constant amount of time independent of the number of items involved.) However, the rare worst-case lookup time can be as bad as O(n). Compared to other associative array data structures, hash tables are most useful when large numbers of records are to be stored, especially if the size of the data set can be predicted.

Hash tables may be used as in-memory data structures. Hash tables may also be adopted for use with persistent data structures; database indexes sometimes use disk-based data structures based on hash tables, although balanced trees are more popular.

//this program creates a hash table as a set of linked lists
// here 10 pointers are used to address 10 linked lists which form a hash tablw
#include
#include

int main()
{
int i,k,num;
struct node
{
int n;
struct node* next;
};

struct node *temp,*p1,*AOP[10];

for(i=0;i<10;i++)
AOP[i]= NULL;
for( i=0;i<20;i++)
{
scanf(“%d”, &num);
k=num%10;
p1=( struct node*) malloc ( sizeof(struct node));

p1->n=num;
p1->next=NULL;

if(AOP[k]==NULL)
AOP[k]=p1;
else
{
p1->next=AOP[k];
AOP[k]=p1;
}
}

for(i=0;i<10;i++)
{
temp=AOP[i];
printf(“List number %d :”, i);
while(temp!=NULL)
{
printf(“%5d”,temp->n);
temp=temp->next;
}
printf(“\n“);
}
}

What is a Binary seach algorithm and how does it work?

refikh — Thu, 25 Jan 2007 12:39:36 +0000

A binary search algorithm (or binary chop) is a technique for finding a particular value in a linear array, by ruling out half of the data at each step, widely but not exclusively used in computer science.

A binary search finds the median, makes a comparison to determine whether the desired value comes before or after it, and then searches the remaining half in the same manner. Another explanation would be: Search a sorted array by repeatedly dividing the search interval in half. Begin with an interval covering the whole array. If the value of the search key is less than the item in the middle of the interval, narrow the interval to the lower half. Otherwise narrow it to the upper half.
Its running time is O(logn).

#include
using namespace std;

//Divide and conquer strategy - Binary Search
/*This algorithm is the simplest application of divide and conquer.
It finds a particular value in a linear array by ruling out half
of the data at each step.A binary search finds the median, makes
a comparision to determine whether the desired value comes before or
after it, and then searches the remaining half in the same manner.
However, the binary search algorithm applies only to sorted arrays.*/

int sorted_array[100];
int i=0;

int binary_search(int target)
{
int first = 0;
int last = i-1;
int mid;
while(first<=last) //while we haven’t reached the end of
{
mid = (first+last)/2; //rule out half of the data by spliting the array
if(sorted_array[mid]==target) //if we have found the target
return mid;
else if(sorted_array[mid]>target)
last = mid-1; //the desired value is in the lower part of the array
else
first = mid+1;//the desired value is in the upper part of the array
}
return -1; //there is no such element in the array
}

int main()
{
int j, n;
while(cin>>j)
sorted_array[i++]=j;
while(cin>>n) //search for an element n in the array
{
int result = binary_search(n); //position of the element n in the array
cout< }
}

Huffman encoding algorithm

refikh — Wed, 24 Jan 2007 13:38:43 +0000

Data transmission and storage cost money. The more information being dealt with, the more it costs. In spite of this, most digital data are not stored in the most compact form. Rather, they are stored in whatever way makes them easiest to use, such as: ASCII text from word processors, binary code that can be executed on a computer, individual samples from a data acquisition system, etc.

Data compression is the general term for the various algorithms and programs developed to address this problem. A compression program is used to convert data from an easy-to-use format to one optimized for compactness. Likewise, an uncompression program returns the information to its original form.

There are many different reasons for and ways of encoding data, and one of these ways is Huffman coding. This is used as a compression method in digital imaging and video as well as in other areas. The idea behind Huffman coding is simply to use shorter bit patterns for more common characters, and longer bit patterns for less common characters.

Huffman coding is based on the frequency of occurance of a data item (pixel in images). The principle is to use a lower number of bits to encode the data that occurs more frequently.

The first version of Huffman encoding

#include
#include // a multimap will be used so we have to include it

using namespace std;

void binary(int number) { //thise procedure is used to convert a
int remainder; //number into a binary number

if(number <= 1) {
cout << number;
return;
}

remainder = number%2;
binary(number >> 1);
cout << remainder;
}

int main()
{
char ch, alphabet[31]; //store each char in ch, 31 chars used because of 26 alphabet, dot, comma, space
typedef multimap huffman; //make a multimap that will be sorted by integers, we use a multimap
huffman sentence; //because some characters may have the same number of occurences

int i=0,j=0;

for(int j=0; j<31; j++) //alphabet[0..30] = 0;
alphabet[j]=0;

while((ch=getchar())!=‘\n‘) //insert chars into ch until enter(return) is pressed
{
if(ch==‘ ‘)
alphabet[28]++;     //increment number of spaces
else if(ch==‘,’)
alphabet[29]++;     //increment number of commas
else if(ch==‘.’)
alphabet[30]++;     //increment number of dots
else{
ch = toupper(ch);    //convert all chars to upper case
alphabet[(static_cast(ch))-65]++;//increment (char ASCII value) - 65 (this is the index number)
}
}

for(int j=0; j<31; j++)
{
if(alphabet[j]>0) //check if char occured in the text
{
i++; //count the number of found chars, commas, dots, spaces
if(j==28)
sentence.insert(make_pair(alphabet[j],‘ ‘)); //make the pair from space and its occurences
else if(j==29)
sentence.insert(make_pair(alphabet[j],‘,’)); //make the part from comma and its occurences
else if(j==30)
sentence.insert(make_pair(alphabet[j],‘.’)); //make the pair from dot and its occurences
else
sentence.insert(make_pair(alphabet[j],static_cast(65+j))); //make the pair from chars and its occurences
}
}

huffman::iterator pos; //make an iterator for the multimap
for(pos = sentence.begin(); pos!=sentence.end(); ++pos)
{
j++; //number of different chars
cout << “Letter “ << pos->second << ” “; //print out the letter and then its occurence code
binary(i-j); //convert the number to binary
cout << endl;
}
return 0;
}

The second version of Huffman encoding by Una Benlic

#include
#include
#include
#include

using namespace std;

char ch[100]; //the characters in the text
string binary[100]; //binary representation of each character
int c=0; //number of distinct characters

string reverse(string line) //procedure that reverses a line
{
string result=“”;
for(int i=line.size()-1; i>=0; i–)
result+=line[i];
return result;
}
string to_binary(int num) //procedure that converts a number to it’s binary representaion
{
string result=“”;
while(num/2!=0)
{
result+=(num%2)+‘0′;
num/=2;
}
result+=(num%2)+‘0′;
return reverse(result);
}

//Once a Huffman code has been generated, data may be encoded simply by
//replacing each symbol with it’s code
string *encode(string text)
{
string* array= new string[text.size()]; //array that stores a binary number associated
//with each character of the text
for(int i=0; isize(); i++) //for each character of the text
{ //find its binary representation
for(int j=0; j)
{
if(text[i]==ch[j]) //if that binary number matches the specified character in text
array[i]=binary[j]; //put the binary number in the array
}
}
return array; //return the array of encoded text
}
string decode(string array[], int len)//this procedure decodes the Huffman’s encoding
{
string result=“”;
for(int i=0; i) //for each binary number find a matching character
{
for(int j=0; j)
{
if(binary[j]==array[i])
result+=ch[j];
}
}
return result; //return the decoded text
}
int main()
{
string line=“”;
string text=“”;
int occurence[100],i,j;
mapcounter; //holds thee character and the number of their occurence
while(getline(cin, line) and line.size()>0)
text+=line;
for(i=0; isize(); i++)
counter[text[i]]++; //counts the number of occurences of each character
for(map::const_iterator iter = counter.begin(); iter!=counter.end(); iter++)
{
ch[c]=iter->first;
occurence[c]=iter->second;
c++;
}
for(i=0; i) //bubble sort of characters according to the number of their occurences
{
for(j=1; j)
{
if(occurence[j-1][j])
{
swap(occurence[j-1], occurence[j]);
swap(ch[j-1], ch[j]);
}
}
}
for(i=0; i) //assign a binary value to each character
binary[i]=to_binary(i);

string *encoded = encode(text);//encode the text into Huffman’s representation
for(i=0; isize(); i++)//print the encoded text
cout<[i];
cout< string decoded = decode(encoded, text.size());//decoded the text
cout< }

What is Heap sort and how does it work? Heap sort algorithm

refikh — Wed, 17 Jan 2007 16:47:00 +0000

Heapsort is one of the best general-purpose sorting algorithms, a comparison sort and part of the selection sort family.

Although somewhat slower in practice on most machines than a good implementation of quicksort, it has the advantages of worst-case O(n log n) runtime. The primary advantage of the heap sort is its efficiency. The execution time efficiency of the heap sort is O(n log n). The memory efficiency of the heap sort, unlike the other O(nlogn) sorts, is constant, O(1), because the heap sort algorithm is not recursive. Heapsort is an in-place algorithm and is not a stable sort.

#include
using namespace std;

int main()
{
int A[11],j,item,temp;
for(int i=1;i<=10;i++)
cin >> A[i];

for(int k=10;k>0;k–)
{
for(int i=1;i<=k;i++)
{
item=A[i];
j=i/2;
while(j>0 && A[j])
{
A[i]=A[j];
i=j;
j=j/2;
}
A[i]=item;
}

temp=A[1];
A[1]=A[k];
A[k]=temp;
}

for(int i=1;i<=10;i++)
cout << A[i] << endl;
}

What is QuickSort and how does it work? Video of cards sorted by Quick sort

refikh — Wed, 17 Jan 2007 12:00:09 +0000

Pick an element from the array (the pivot), partition the remaining elements into those greater than and less than this pivot, and recursively sort the partitions. There are many variants of the basic scheme above: to select the pivot, to partition the array, to stop the recursion on small partitions, etc.

Quick-sort is a randomized sorting algorithm based on the divide-and-conquer method.

The worst-case efficiency of the quick sort, O(n2), occurs when the list is sorted and the left-most element is chosen. Randomly choosing a pivot point rather than using the left-most element is recommended if the data to be sorted isn’t random. As long as the pivot point is chosen randomly, the quick sort has an algorithmic complexity of O(nlogn).

Video of how quick sort works with cards:

View This Video on You Tube

The quick sort is by far the fastest of the common sorting algorithms. It’s possible to write a special-purpose sorting algorithm that can beat the quick sort for some data sets, but for general-case sorting there isn’t anything faster. Quick sort is not stable. The worst-case space-complexity is O(N), but it can be limited to O(log(N)) if the code is modified.

#include
using namespace std;

int a[10];
int partition(int left, int right);
void swap(int i, int j);
void sort(int i, int j);

int main()
{
int i,j=0,k=9;
for(i=0;i<10;i++)
cin >> a[i];

sort(j,k);
for(i=0;i<10;i++)
cout << a[i] << endl;
}

void sort(int left, int right)
{
int p;
if(left>=right)
return;
p = partition(left, right);

sort(left,p-1);
sort(p+1,right);
}

int partition(int left, int right)
{
int first=left, pivot=right–;
while(left<=right)
{
while(a[left][pivot])
left++;
while((right>=first)&&(a[right]>=a[pivot]))
right–;
if(left)
{
swap(left,right);
left++;
}
}
if(left!=pivot)
swap(left,pivot);

return left;
}

void swap(int i, int j)
{
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}

What is Selection sort and how does it work? Selection sort algorithm

refikh — Tue, 16 Jan 2007 21:13:31 +0000

Selection sort performs sorting by repeatedly putting the largest element in the unprocessed portion of the array to the end of the this unprocessed portion until the whole array is sorted.

In a loop, the highest element from the unsorted zone is selected (hence the name Selection Sort) and placed at the end of the unsorted zone. We begin by selecting the largest element and moving it to the highest index position. We can do this by swapping the element at the highest index and the largest element.

The run time is Θ(n²), where n is the number of elements. The number of swaps is O(n).

#include
using namespace std;

int main()
{
int array[9]={4,3,5,1,2,0,7,9,4};
for(int i=0; i<9; i++)
{
int min = i;
for(int j=i; j<9; j++)
if(array[min][j])
min = j;

swap(array[min],array[i]);
}

for(int i=0; i<9;i++)
cout << array[i] << endl;
}

The Towers of Hanoi

refikh — Fri, 12 Jan 2007 15:15:59 +0000

In an ancient city in India, so the legend goes, monks in a temple have to move a pile of 64 sacred disks from one location to another. The disks are fragile; only one can be carried at a time. A disk may not be placed on top of a smaller, less valuable disk.

And, there is only one other location in the temple (besides the original and destination locations) sacred enough that a pile of disks can be placed there. So, the monks start moving disks back and forth, between the original pile, the pile at the new location, and the intermediate location, always keeping the piles in order (largest on the bottom, smallest on the top). The legend is that, before the monks make the final move to complete the new pile in the new location, the temple will turn to dust and the world will end. Is there any truth to this legend?

The Tower of Hanoi puzzle was invented by the French mathematician Edouard Lucas in 1883. The puzzle is well known to students of Computer Science since it appears in virtually any introductory text on data structures or algorithms. The goal is to move all the discs from the left peg to the right one, obeying the following rules:

Only one disk may be moved at a time.
Each move consists of taking the upper disk from one of the pegs and sliding it onto another peg, on top of the other disks that may already be present on that peg.
No disk may be placed on top of a smaller disk.

There are many recursive solutions to this problem, here are two non-recursive solutions. One is by Prasad Krishna and the other one I found somewhere on the web, some time ago (sorry for not crediting you, please leave a comment if it is your code )

#include
using namespace std;
int main()
{
int n, x;

cout << “How many disks?” << endl;
cin >> n;

for (x=1; x < (1 << n); x++)
cout << “Move from pole “ << (x&x-1)%3 << ” to pole “ << (((x|x-1)+1)%3) << endl;
}

#include
using namespace std;

int main()
{
int st[20][4],top,o=1,m=2,d=3,n, i,j,k;
top=0;
cout << “How many disks?” << endl;
cin >> n;
st[top][0]=o;
st[top][1]=d;
st[top][2]=m;
st[top][3]=n;

while(top>=0)
{
i=st[top][0];
j=st[top][1];
k=st[top][2];
n=st[top][3];

top=top-1;

if(n<=1)
cout << “Move “ << i << ” to “ << j << endl;
else if(n>1)
{
top=top+1;
st[top][0]=k;
st[top][1]=j;
st[top][2]=i;
st[top][3]=n-1;

top=top+1;
st[top][0]=i;
st[top][1]=j;
st[top][2]=0;
st[top][3]=0;
top=top+1;
st[top][0]=i;
st[top][1]=k;
st[top][2]=j;
st[top][3]=n-1;
}
}
}

The Insertion sort algorithm

refikh — Thu, 11 Jan 2007 19:19:45 +0000

Sort by repeatedly taking the next item and inserting it into the final data structure in its proper order with respect to items already inserted. It inserts each element of the array into its proper position.

Run time is O(n^2) because of moves. Insertion sort is an example of an incremental algorithm; it builds the sorted sequence one number at a time. Insertion sort is stable, i.e. the relative order of equal keys is not changed, provided that you are careful about scanning the sorted region from right to left.

#include
using namespace std;

int main()
{
int array[9]={4,3,5,1,2,0,7,9,4};

for(int i=1; i<9; i++)
{
int index = array[i];
int dec = i;
while(dec>0 && array[dec-1]>=index)
{
array[dec]=array[dec-1];
–dec;
}
array[dec]=index;
}

for(int i=0; i<9;i++)
cout << array[i] << endl;
}

The Backtracking algorithm/method

refikh — Thu, 11 Jan 2007 15:20:02 +0000

Backtracking method tries to find a solution by trying one of several choices. If the choice proves incorrect, computation backtracks or restarts at the point of choice and tries another choice.

Scope: The most widespread use of backtracking is in the execution of regular expressions. For example, the simple pattern “a*a” will fail to match the sequence “a” without backtracking (because, on the first pass the “a” is eaten by the “a*” leaving nothing behind for the remaining “a” to match.) Another usage of backtracking is in text parsing applications, solving mazes, robotics and etc.

Bicolorable graph: This program will check if a graph is bicolorable in such a way that no two adjacent nodes have the same color.

#include
using namespace std;

int G[50][50]; //adjacency matrix for the graph
int num_edges; //number of edges
int num_nodes; //number of nodes

bool diff_color(int node, int color, int colored[])
{
for(int v = 0; v < node; v++)
if(G[v][node] && colored[v] == color) //check if they have same color and
return false; //if the edge exists between the two nodes.

return true;
}

bool backtracking(int colored[], int node)
{
for(int color = 0; color < 2; color++) //try for both colors
if(diff_color(node, color, colored))
{
colored[node] = color; //set the color to the current vertice
if(node == num_nodes-1) //check if the current node == last node
return true;
else
return backtracking(colored, node+1); //backtrack it again
}
return false;
}

int main()
{
int u, v, counter; //input vertices that are connected
int colored[50]; //colored vertices,
cin >> num_nodes >> num_edges;

for(int i = 0; i < 50; i++) //make all the vertices unconected by
for(int j = 0; j < 50; j++) //setting the matrix G[all][all]=0
G[i][j] = 0;

while(num_edges>0) //loop until all edges are entered
{
num_edges–; //num_edges one less
cin >> u >> v;
G[u][v] = 1; //when an edge exists then put in the
G[v][u] = 1; //adjecency matrix a 1
}
if(backtracking(colored, 0)) //check if the graph is bicolorable
cout << “The graph can be bicolored.” << endl;
else
cout << “The graph can not be bicolored.” << endl;
}

The Las Vegas algorithm/method

refikh — Wed, 10 Jan 2007 13:20:18 +0000

A Las Vegas algorithm is a randomized algorithm that always gives the correct answer. Because of its nondeterministic nature, the run-time of a Las Vegas algorithm is a random variable.

An example of such an algorithm would be the randomized quickSort algorithm, it takes a random pivot point but at the end you get sorted data.

Scope: Las Vegas algorithms are used to solve some of NP Complete problems, Genetic algorithms, Evolution Strategies, Ant Colony Optimization and etc. The time to solve these is random, which means the duration shouldn’t be very big/long so another application of it is Cryptography application, generation of very long prime numbers and etc.

Miller-Rabin Primality test: An algorithm which determines whether a given number is prime, similar to the Fermat primality test and the Solovay-Strassen primality test.

#include
#include
using namespace std;
int RandInt(int Low, int High) //routine to return a random number between
{ //low and high boundaries
return rand( ) % ( High - Low + 1 ) + Low;
}

int Witness(int A, int i, int N)         //if witness does not return 1 then N is
{                                            //definately composite. Fermat’s little
int X, Y;                                 //theorem, says that if n is prime, then
//for all a between 1 and n - 1, an - 1 mod n = 1.
if( i == 0 )                              //the contrapositive is if an - 1 mod n ? 1,
return 1;                              //then n is not prime. Take a randomly!

X = Witness( A, i / 2, N );
if( X == 0 ) // if N is recursively composite, stop
return 0;

Y = ( X * X ) % N; // N is not prime if we find a non-trivial root of 1
if( Y == 1 && X != 1 && X != N - 1 )
return 0;

if( i % 2 != 0 )
Y = ( A * Y ) % N;
return Y;
}

int CheckPrime( int N )                 //repeat this procedure as many times as
{                                           //needed for desired error rate. Test if N >= 3 is
return Witness(RandInt(2, N-2), N-1, N) == 1;    //prime using one value of A
}

int main()
{
srand(time(NULL));                //define random numbers
for(int i = 101; i<200; i+= 2)            //check primality of a few numbers
if(CheckPrime(i))                //if number is prime print it
cout << i << ” is a prime number” << endl;
}

The Dynamic programming method

refikh — Wed, 10 Jan 2007 13:01:33 +0000

It can be described as follows: solve each small problem once, saving their solution; use the solutions of small problems to obtain solutions to larger problems.

The difference between dynamic programming problems and divide and conquer problems is the fact that the sub problems are not independent.

Scope: Dynamic programming algorithms are mostly used for optimization problems. For example the shortest path problem in a directed staged network, Neural networks, some economic applications. To be able to use dynamic programming, the problem must have certain properties:
1) Simple sub problems: There must be a way to break the big problem into smaller sub problems. Sub problems must be identified with just a few indices.
2) Sub problem optimization: An optimal solution to the big problem must always be a combination of optimal solutions to the sub problems.
3) Sub problem overlap: Optimal solutions to unrelated problems can contain sub problems in common.

Calculating Fibonacci numbers: After two starting values,each number is the sum of the two preceding numbers. For example: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657…

#include
using namespace std;

int main()
{
int Fib[1000]; //define array for fib numbers
Fib[0]=0; //define the first two Fibonacci numbers
Fib[1]=1;
for(int i=2;i<1000;i++) //get other Fibonacci numbers by adding the two preceding
Fib[i]=Fib[i-2]+Fib[i-1]; //Fibonacci numbers
}

The Divide and Conquer algorithm/method

refikh — Tue, 09 Jan 2007 21:17:53 +0000

The divide and conquer method works as follows, divide big problem into smaller sub problems; conquer each sub problem separately; merge the solutions of the sub problems into the solution of the big problem.

Usually, better running times are obtained when the size of the subproblems are roughly equal. To write a recursive algorithm, find how the problem can be broken up into smaller problems of the same nature. Remember the base case!

Scope: Divide and conquer is used to solve difficult problems, such as the classic Tower of Hanoi puzzle, sorting, calculation of the FFT(Fast Fourier Transformation), DSP(Digital Signal Processing) where you need parallelism for math calculations, other parallelism applications, to make efficient use of memory caches (the reason is that once a sub-problem is small enough, it and all its sub-problems can, in principle, be solved within the cache, without accessing the slower main memory).

Fast power calculation: For example to calculate the power of some number normally we would multiply it each time with itself, so a^5=a*a*a*a*a. There is a much faster divide-and-conquer method, using the simple formula a^n=a^(n/2) * a^(n/2). What makes this approach more efficient is that once we compute the first factor a^(n/2), we can compute the second factor a^(n/2) using at most one more multiplication.

#include
using namespace std;

int FastPower(int a, int power) //the extra fast power calculation routine
{
if(power==1) //if power equals 1 then return just a
return a;
else
{
int x=FastPower(a,power/2); //else call the same routine, on the divded power by 2
if(power%2) //if it is odd then return x*x*a
return x*x*a;
else //else if it is even then return x*x
return x*x;
}
}

int main()
{
cout<< FastPower(2,11) << endl; //call the routine for the extra fast power
}

The Monte Carlo algorithm/method

refikh — Tue, 09 Jan 2007 20:55:50 +0000

The Monte Carlo method is a way of solving problems using statistical methods; stochastic technique (which means using random numbers) and probability.

Given some probability, P, that an event will occur in certain conditions, a computer can be used to generate those conditions repeatedly. The number of times the event occurs divided by the number of times the conditions are generated should be approximately equal to P.

Scope: The Monte Carlo methods are applied in various fields of mathematics, physics, economics and etc. Monte Carlo simulation methods are especially useful in studying systems with a large number of coupled degrees of freedom, such as liquids, disordered materials, strongly coupled solids, and cellular structures. The Monte Carlo method is often useful for solving problems in physics and mathematics which cannot be solved by analytical means. They are useful for modeling phenomena with significant uncertainty in inputs, such as the calculation of risk in business.

Calculation of Pi: Let’s make a circle inside a square and let’s take a quadrant out of it.

If we take a dice and throw it randomly inside the square, the probability that the dice will end up in the circle area is circle_area/square_area. Now if we replace it with formulas, just for one quadrant, we get: Pi=4*dice_hitting_circle_area/dice_hitting_square_area. So by Pythagoras theorem we just have to take random values for x and y coordinates, square them, sum them up, take the square root out of the sum and if the result is less or equal to 1 then the dice is inside the circle. By repeating this few times we can get the approximation of the number Pi.

#include
#include
#include
using namespace std;

int main()
{
double x, y;            //define x and y coordiantes
int count_inside = 0, till=1000;    //how many tries you want
srand(time(NULL));           //define random values
for(int i=0; i)
{
x=pow(double(rand()%1000)/1000,2);    //square random x, x^2
y=pow(double(rand()%1000)/1000,2);    //square random y, y^2
if(sqrt(x+y)<=1)                //check if square root is equal or less to 1
count_inside++;                //if it is then add 1 to count_inside
}
cout << 4*double(count_inside)/till << endl;    //calculate the pi by the formula given above
}
out << 4*double(count_inside)/till << endl; //calculate the pi by the formula given above
}

The Greedy algorithm/method

refikh — Tue, 09 Jan 2007 19:36:34 +0000

A greedy algorithm repeatedly executes a procedure which tries to maximize the return based on examining local conditions, with the hope that the outcome will lead to a desired outcome for the global problem.

In some cases such a strategy is guaranteed to offer optimal solutions, and in some other cases it may provide a compromise that produces acceptable approximations. Typically, the greedy algorithms employ simple strategies that are simple to implement and require minimal amount of resources. For most optimization problems, greedy algorithms are not optimal. But when they are, they are usually the fastest available.

Scope: Greedy algorithms do not always yield a genuinely optimal solution. In such cases the greedy method is frequently the basis of a heuristic approach. Even for problems which can be solved exactly by a greedy algorithm, establishing the correctness of the method may be a non-trivial process. Greedy approximation algorithms have been frequently used to obtain sparse solutions to learning problems. For example, all known greedy algorithms for the graph coloring problem and all other NP-complete problems do not consistently find optimum solutions. Nevertheless, they are useful because they are quick to think up and often give good approximations to the optimum.

Egyptian fractions: The ancient Egyptians only used fractions of the form ¹/_n so any other fraction had to be represented as a sum of such unit fractions and, furthermore, all the unit fractions were different! An example:

⁶/₇ = ¹/₂ + ¹/₃ + ¹/₄₂

This problem is solved using the greedy method.

#include
using namespace std;

int main()
{
int numerator,denominator, i=1; //define the numerator and denominator
double factor,temp; //define the factor for division num/den
cout << “Enter numerator and then denominator” << endl;
cin>>numerator>>denominator;
factor=double(numerator)/double(denominator); //divide the factor
do //and put it in temp
{
temp=double(1)/double(++i); //result value of the fraction
if(factor>=temp) //if factor is less than temp then subtract
{ //temp from factor and then print the factor
cout << i << ” “;
factor = factor - temp;
}
}while(factor>0 && i<32000); //check for all factors till the denominator is
} //32000 and as long as it is greater than 0

What is Bubble sort and how does it work?

refikh — Sat, 09 Dec 2006 21:49:37 +0000

Bubble sort, sometimes shortened to bubblesort, also known as exchange sort, is a simple sorting algorithm.

It works by repeatedly stepping through the list to be sorted, comparing two items at a time and swapping them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which means the list is sorted. The algorithm gets its name from the way smaller elements “bubble” to the top (i.e. the beginning) of the list via the swaps. Because it only uses comparisons to operate on elements, it is a comparison sort.

Video of how bubble sort works:

View This Video on You Tube

#include
using namespace std;

int main()
{
int array[9]={4,3,5,1,2,0,7,9,4};
for(int i=0; i<9; i++)
for(int j=0; j
if(array[i]
{
int temp = array[j];
array[j]= array[i];
array[i]=temp;
}

for(int i=0; i<9;i++)
cout << array[i] << endl;
}

What is sorting?

refikh — Sat, 09 Dec 2006 21:37:49 +0000

In computer science and mathematics, a sorting algorithm is an algorithm that puts elements of a list in a certain order. The most used orders are numerical order and lexicographical order.

Efficient sorting is important to optimizing the use of other algorithms (such as search and merge algorithms) that require sorted lists to work correctly; it is also often useful for canonicalizing data and for producing human-readable output. More formally, the output must satisfy two conditions:

The output is in nondecreasing order (each element is no smaller than the previous element according to the desired total order);
The output is a permutation, or reordering, of the input.

Since the dawn of computing, the sorting problem has attracted a great deal of research, perhaps due to the complexity of solving it efficiently despite its simple, familiar statement. For example, bubble sort was analyzed as early as 1956. Although many consider it a solved problem, useful new sorting algorithms are still being invented to this day (for example, library sort was first published in 2004). Sorting algorithms are prevalent in introductory computer science classes, where the abundance of algorithms for the problem provides a gentle introduction to a variety of core algorithm concepts, such as big O notation, divide-and-conquer algorithms, data structures, randomized algorithms, best, worst and average case analysis, time-space tradeoffs, and lower bounds.

Taken from Wikipedia