C-C++ Programming Encyclopedia » Sample C Programs for Beginners

Heap Sort in C: Basics & Code Snippet

admin — Thu, 25 Aug 2011 17:21:59 +0000

Few of the sorting techniques like the bubble sort, selection or the insertion sort are good enough for sorting small number of element, while heap sort is used to large number of elements, in a faster way. It’s simple as well, but all it consumes is the additional memory.

Before we get into heap sort technique, let us learn something about the heap data structure, which is used in heap sort. Top element that is present in the heap indicates the next in the line as in the order either it may be highest or the lowest.

Firstly, we will have to create a heap and then go on adding elements to the heap and once you want to delete it then you can easily remove from the heap and in a sorted order as such.

There are two things here one has to worry about –

a. that is the time taken to create the heap, and
b. the time taken to add and remove the element from the heap.

Well, this is quite faster when compared to any of the other sorting techniques.

One of the major disadvantages associated with this technique is that it’s not stable for equal elements, as in it does not preserve the original order. F

or instance if we consider having a list of messages in your inbox then, then you would want the sort by both time and date as well as in an alphabetical order. Then in such cases, you can first sort it as per the date and time and then sort as per the alphabetical order.

Let us illustrate the above scenario with an example:

From: a@qwerty.com sent: 1/1/2011
From: b@qwerty.com sent: 1/1/2011
From: c@qwerty.com sent: 2/9/2009
After sorting using heap sort
From: c@qwerty.com sent: 2/9/2009
From: b@qwerty.com sent: 1/1/2011
From: a@qwerty.com sent: 1/1/2011

As we can see that “b” is ahead of “a” which does not happen in any other sorting techniques as such which indicates that the sort is unstable. A stable sort should look like:

From: c@qwerty.com sent: 2/9/2009
From: a@qwerty.com sent: 1/1/2011
From: b@qwerty.com sent: 1/1/2011

Code Snippet to Implement Heap Sort in C Programming Language

void HSort(int num[], int size)
{
int j, temp;
for (j = (size / 2); j >= 0; j–)
shift(num, j, size – 1);
for (j = size-1; j >= 1; j–)
{
temp = num[0];
num[0] = num[i];
num[i] = temp;
shift(num, 0, i-1);
}
}
void shift(int num [], int head, int tail)
{
int ok, max, temp;
ok = 0;
while ((head*2 <= tail) && (!ok))
{
if (head*2 == tail)
max = head * 2;
else if (num [head * 2] > num [head * 2 + 1])
max= head * 2;
else
max = head * 2 + 1;

if (num [head] < num[max])
{
temp = num[head];
num[head] = num [max];
num[max] = temp;
head = max;
}
else
ok = 1;
}
}

So, that was a simple illustration of heap sort in c – stay tuned for more useful code snippets!

Fundamentals of Programming Data Structures in C

admin — Thu, 07 Apr 2011 11:00:09 +0000

Data Structures in C programming language is one of the most important and interesting part. Let us compute the In-Degree and Out-Degree of a node ‘n’ of a Graph using adjacency matrix representation.

Computation of In-Degree of a node ‘n’ can be done by using the adjacency matrix representation of a graph. The node number ‘n’ can be used as a column index in the adjacency matrix and then you have to count the number of 1’s in that particular column of the adjacency matrix. This constitutes the In-Degree of the node ‘n’.

The Out-Degree can be computed in a similar manner, where we have to use the node number ‘n’ as the index of row of the same adjacency matrix and then we have to count the number of 1’s in that particular row. This is the way which we can use to compute the In-Degree and Out-Degree of a graph.

Here’s a simple code snippet illustrating usage of data structures in c programming language.

#include < stdio.h >

#define MAXIMUM 10

void main()
{
int adjacency[ MAXIMUM ] [ MAXIMUM ], node, m, i;
printf(“Enter the number of nodes in graph maximum = %d\n”, MAXIMUM);
scanf(“%d”, &m);
build_adj_matrix(adjacency, m);

for(i=0; i {
printf("The indegree of the node %d is %d\n", i, in_degree(adjacency, i, m));
printf("The outdegree of the node %d is %d\n", i, out_degree(adjacency, i, m));
}
}

void build_adj_matrix( int adjacency[ ] [ MAXIMUM ], int n)
{
int x, y;
for(x=0; x < n; x++)
for(y=0; y < n; y++)
{
printf("Enter 1 if there is an edge from %d to %d, otherwise enter 0 \n", x, y );
scanf("%d", & adjacency[ x ] [ y ]);
}
}

int out_degree(int adjacency[ ] [ MAXIMUM ], int i, int m)

{
int x, count =0;
for(x=0; x < m; x++)
if(adjacency[ i ] [ x ] ==1) count++;
return( count );
}

int in_degree(int adjacency [ ] [ MAXIMUM ], int i, int m)

{
int x, count =0;
for(x=0; x < m; x++)
if(adjacency[ x ] [ i ] ==1) count++;
return(count);
}

Biggest C Programming Applications

admin — Thu, 10 Mar 2011 03:07:51 +0000

C programming language is a very powerful programming language. It is very much compatible with all the hardware types and can manipulate any hardware function in a very easy and efficient way.

After Assembly language, the C programming language is the fastest and most powerful programming language known to man.

There are various applications of C programming language in either of the scientific or great system applications, and also in programming the drivers for the new hardware releases. Let us discuss some of the greatest applications programmed in C thus far, which you might be even shocked to hear about.

Adobe Systems

Most of the big projects of Adobe Systems like the Photoshop, Dreamweaver, InDesign and various others are programmed using C programming language.

Google

Google is very much keen on using C or C++ as their primary application programming language. You’d be amazed to know Google Files System and the Google Chrome software are programmed using C programming language as well.

Mozilla

Mozilla uses C programming language in most of their projects like Firefox and Thunderbird.

MySQL

MySQL uses C programming language in most of their applications along with the C++ programming language for their world’s most powerful database software.

Autodesk Maya

Maya is one resource hog program and it needs immense speed for it to process graphics and that is only possible if they use either the C programming language or C++ programming language.

Winamp Media Player

Winamp media player is the most used player around the globe and the sole reason for its popularity is the faster, efficient and responsive user interface even at the time of high sound quality playback. All the credit goes to the C programming language for its faster and more powerful approach.

Some of the other software made using C programming language include –

• 12D Solutions,
• Bloomberg,
• Callas Software,
• Apple OS X,
• Windows, and
• Symbian OS.

Binary Tree Sorting in C

Nanya — Sat, 19 Jun 2010 10:04:35 +0000

Here’s the example of Binary Tree Sorting using c.

#include < stdio.h >
#include < conio.h >
#include < alloc.h >

struct btreenode
{
struct btreenode *leftchild ;

int data ;

struct btreenode *rightchild ;
} ;

void insert ( struct btreenode **, int ) ;

void inorder ( struct btreenode * ) ;

void main( )
{
struct btreenode *bt ;

int arr[10] = { 11, 2, 9, 13, 57, 25, 17, 1, 90, 3 } ;

int i ;

bt = NULL ;

clrscr( ) ;

printf ( “Binary tree sort.\n” ) ;

printf ( “\nArray:\n” ) ;

for ( i = 0 ; i < = 9 ; i++ )

printf ( "%d\t", arr[i] ) ;

for ( i = 0 ; i < = 9 ; i++ )

insert ( &bt, arr[i] ) ;

printf ( "\nIn-order traversal of binary tree:\n" ) ;

inorder ( bt ) ;

getch( ) ;
}

void insert ( struct btreenode **sr, int num )
{
if ( *sr == NULL )
{
*sr = malloc ( sizeof ( struct btreenode ) ) ;

( *sr ) - > leftchild = NULL ;

( *sr ) – > data = num ;

( *sr ) – > rightchild = NULL ;
}
else
{
if ( num < ( *sr ) - > data )

insert ( &( ( *sr ) – > leftchild ), num ) ;
else
insert ( &( ( *sr ) – > rightchild ), num ) ;
}
}

void inorder ( struct btreenode *sr )
{
if ( sr != NULL )
{
inorder ( sr – > leftchild ) ;

printf ( “%d\t”, sr – > data ) ;

inorder ( sr – > rightchild ) ;
}
}

Insertion Sort in C

Nanya — Sat, 19 Jun 2010 10:00:19 +0000

Let take look of Insertion sort in c.

#include < stdio.h >
#include < conio.h >

void main( )
{
int arr[5] = { 25, 17, 31, 13, 2 } ;

int i, j, k, temp ;

clrscr( ) ;

printf ( “Insertion sort.\n” ) ;

printf ( “\nArray before sorting:\n”) ;

for ( i = 0 ; i < = 4 ; i++ )

printf ( "%d\t", arr[i] ) ;

for ( i = 1 ; i < = 4 ; i++ )
{
for ( j = 0 ; j < i ; j++ )
{
if ( arr[j] > arr[i] )
{
temp = arr[j] ;

arr[j] = arr[i] ;

for ( k = i ; k > j ; k– )

arr[k] = arr[k - 1] ;

arr[k + 1] = temp ;
}
}
}

printf ( “\n\nArray after sorting:\n”) ;

for ( i = 0 ; i < = 4 ; i++ )

printf ( “%d\t”, arr[i] ) ;

getch( ) ;
}

Quick Sort in C

Nanya — Fri, 18 Jun 2010 10:04:48 +0000

Here’s the example of Quick sort in c.

#include < stdio.h >
#include < conio.h >

int split ( int*, int, int ) ;

void main( )
{
int arr[10] = { 11, 2, 9, 13, 57, 25, 17, 1, 90, 3 } ;
int i ;

void quicksort ( int *, int, int ) ;

clrscr( ) ;

printf ( “Quick sort.\n” ) ;

printf ( “\nArray before sorting:\n”) ;

for ( i = 0 ; i < = 9 ; i++ )

printf ( "%d\t", arr[i] ) ;

quicksort ( arr, 0, 9 ) ;

printf ( "\nArray after sorting:\n") ;

for ( i = 0 ; i < = 9 ; i++ )

printf ( "%d\t", arr[i] ) ;

getch( ) ;
}

void quicksort ( int a[ ], int lower, int upper )
{
int i ;

if ( upper > lower )
{
i = split ( a, lower, upper ) ;

quicksort ( a, lower, i – 1 ) ;

quicksort ( a, i + 1, upper ) ;
}
}

int split ( int a[ ], int lower, int upper )
{
int i, p, q, t ;

p = lower + 1 ;

q = upper ;

i = a[lower] ;

while ( q > = p )
{
while ( a[p] < i )

p++ ;

while ( a[q] > i )

q– ;

if ( q > p )
{
t = a[p] ;

a[p] = a[q] ;

a[q] = t ;
}
}

t = a[lower] ;

a[lower] = a[q] ;

a[q] = t ;

return q ;
}

How to Maintain an AVL tree

Nanya — Wed, 16 Jun 2010 10:02:23 +0000

Here’s C program to maintain an AVL tree.

#include < stdio.h >
#include < conio.h >
#include < alloc.h >

#define FALSE 0
#define TRUE 1

struct AVLNode
{
int data ;
int balfact ;
struct AVLNode *left ;
struct AVLNode *right ;
} ;

struct AVLNode * buildtree ( struct AVLNode *, int, int * ) ;
struct AVLNode * deldata ( struct AVLNode *, int, int * ) ;
struct AVLNode * del ( struct AVLNode *, struct AVLNode *, int * ) ;
struct AVLNode * balright ( struct AVLNode *, int * ) ;
struct AVLNode * balleft ( struct AVLNode *, int * ) ;
void display ( struct AVLNode * ) ;
void deltree ( struct AVLNode * ) ;

void main( )
{
struct AVLNode *avl = NULL ;
int h ;

clrscr( ) ;

avl = buildtree ( avl, 20, &h ) ;
avl = buildtree ( avl, 6, &h ) ;
avl = buildtree ( avl, 29, &h ) ;
avl = buildtree ( avl, 5, &h ) ;
avl = buildtree ( avl, 12, &h ) ;
avl = buildtree ( avl, 25, &h ) ;
avl = buildtree ( avl, 32, &h ) ;
avl = buildtree ( avl, 10, &h ) ;
avl = buildtree ( avl, 15, &h ) ;
avl = buildtree ( avl, 27, &h ) ;
avl = buildtree ( avl, 13, &h ) ;

printf ( “\nAVL tree:\n” ) ;
display ( avl ) ;

avl = deldata ( avl, 20, &h ) ;
avl = deldata ( avl, 12, &h ) ;

printf ( “\nAVL tree after deletion of a node:\n” ) ;
display ( avl ) ;

deltree ( avl ) ;

getch( ) ;
}

/* inserts an element into tree */
struct AVLNode * buildtree ( struct AVLNode *root, int data, int *h )
{
struct AVLNode *node1, *node2 ;

if ( !root )
{
root = ( struct AVLNode * ) malloc ( sizeof ( struct AVLNode ) ) ;
root – > data = data ;
root – > left = NULL ;
root – > right = NULL ;
root – > balfact = 0 ;
*h = TRUE ;
return ( root ) ;
}

if ( data < root - > data )
{
root – > left = buildtree ( root – > left, data, h ) ;
/* If left subtree is higher */
if ( *h )
{
switch ( root – > balfact )
{
case 1:
node1 = root – > left ;
if ( node1 – > balfact == 1 )
{
printf ( “\nRight rotation along %d.”, root – > data ) ;
root – > left = node1 – > right ;
node1 – > right = root ;
root – > balfact = 0 ;
root = node1 ;
}
else
{
printf ( “\nDouble rotation, left along %d”,
node1 – > data ) ;
node2 = node1 – > right ;
node1 – > right = node2 – > left ;
printf ( ” then right along %d.\n”, root – > data ) ;
node2 – > left = node1 ;
root – > left = node2 – > right ;
node2 – > right = root ;
if ( node2 – > balfact == 1 )
root – > balfact = -1 ;
else
root – > balfact = 0 ;
if ( node2 – > balfact == -1 )
node1 – > balfact = 1 ;
else
node1 – > balfact = 0 ;
root = node2 ;
}
root – > balfact = 0 ;
*h = FALSE ;
break ;

case 0:
root – > balfact = 1 ;
break ;

case -1:
root – > balfact = 0 ;
*h = FALSE ;
}
}
}

if ( data > root – > data )
{
root – > right = buildtree ( root – > right, data, h ) ;
/* If the right subtree is higher */
if ( *h )
{
switch ( root – > balfact )
{
case 1:
root – > balfact = 0 ;
*h = FALSE ;
break ;

case 0:
root – > balfact = -1 ;
break;

case -1:
node1 = root – > right ;
if ( node1 – > balfact == -1 )
{
printf ( “\nLeft rotation along %d.”, root – > data ) ;
root – > right = node1 – > left ;
node1 – > left = root ;
root – > balfact = 0 ;
root = node1 ;
}
else
{
printf ( “\nDouble rotation, right along %d”,
node1 – > data ) ;
node2 = node1 – > left ;
node1 – > left = node2 – > right ;
node2 – > right = node1 ;
printf ( ” then left along %d.\n”, root – > data ) ;
root – > right = node2 – > left ;
node2 – > left = root ;

if ( node2 – > balfact == -1 )
root – > balfact = 1 ;
else
root – > balfact = 0 ;
if ( node2 – > balfact == 1 )
node1 – > balfact = -1 ;
else
node1 – > balfact = 0 ;
root = node2 ;
}
root – > balfact = 0 ;
*h = FALSE ;
}
}
}
return ( root ) ;
}

/* deletes an item from the tree */
struct AVLNode * deldata ( struct AVLNode *root, int data, int *h )
{
struct AVLNode *node ;

if ( !root )
{
printf ( “\nNo such data.” ) ;
return ( root ) ;
}
else
{
if ( data < root - > data )
{
root – > left = deldata ( root – > left, data, h ) ;
if ( *h )
root = balright ( root, h ) ;
}
else
{
if ( data > root – > data )
{
root – > right = deldata ( root – > right, data, h ) ;
if ( *h )
root = balleft ( root, h ) ;
}
else
{
node = root ;
if ( node – > right == NULL )
{
root = node – > left ;
*h = TRUE ;
free ( node ) ;
}
else
{
if ( node – > left == NULL )
{
root = node – > right ;
*h = TRUE ;
free ( node ) ;
}
else
{
node – > right = del ( node – > right, node, h ) ;
if ( *h )
root = balleft ( root, h ) ;
}
}
}
}
}
return ( root ) ;
}

struct AVLNode * del ( struct AVLNode *succ, struct AVLNode *node, int *h )
{
struct AVLNode *temp = succ ;
if ( succ – > left != NULL )
{
succ – > left = del ( succ – > left, node, h ) ;
if ( *h )
succ = balright ( succ, h ) ;
}
else
{
temp = succ ;
node – > data = succ – > data ;
succ = succ – > right ;
free ( temp ) ;
*h = TRUE ;
}
return ( succ ) ;
}

/* balances the tree, if right sub-tree is higher */
struct AVLNode * balright ( struct AVLNode *root, int *h )
{
struct AVLNode *node1, *node2 ;

switch ( root – > balfact )
{
case 1:
root – > balfact = 0 ;
break;

case 0:
root – > balfact = -1 ;
*h = FALSE ;
break;

case -1:
node1 = root – > right ;
if ( node1 – > balfact < = 0 )
{
printf ( "\nLeft rotation along %d.", root - > data ) ;
root – > right = node1 – > left ;
node1 – > left = root ;
if ( node1 – > balfact == 0 )
{
root – > balfact = -1 ;
node1 – > balfact = 1 ;
*h = FALSE ;
}
else
{
root – > balfact = node1 – > balfact = 0 ;
}
root = node1 ;
}
else
{
printf ( “\nDouble rotation, right along %d”, node1 – > data );
node2 = node1 – > left ;
node1 – > left = node2 – > right ;
node2 – > right = node1 ;
printf ( ” then left along %d.\n”, root – > data );
root – > right = node2 – > left ;
node2 – > left = root ;

if ( node2 – > balfact == -1 )
root – > balfact = 1 ;
else
root – > balfact = 0 ;
if ( node2 – > balfact == 1 )
node1 – > balfact = -1 ;
else
node1 – > balfact = 0 ;
root = node2 ;
node2 – > balfact = 0 ;
}
}
return ( root ) ;
}

/* balances the tree, if left sub-tree is higher */
struct AVLNode * balleft ( struct AVLNode *root, int *h )
{
struct AVLNode *node1, *node2 ;

switch ( root – > balfact )
{
case -1:
root – > balfact = 0 ;
break ;

case 0:
root – > balfact = 1 ;
*h = FALSE ;
break ;

case 1:
node1 = root – > left ;
if ( node1 – > balfact > = 0 )
{
printf ( “\nRight rotation along %d.”, root – > data ) ;
root – > left = node1 – > right ;
node1 – > right = root ;
if ( node1 – > balfact == 0 )
{
root – > balfact = 1 ;
node1 – > balfact = -1 ;
*h = FALSE ;
}
else
{
root – > balfact = node1 – > balfact = 0 ;
}
root = node1 ;
}
else
{
printf ( “\nDouble rotation, left along %d”, node1 – > data ) ;
node2 = node1 – > right ;
node1 – > right = node2 – > left ;
node2 – > left = node1 ;
printf ( ” then right along %d.\n”, root – > data ) ;
root – > left = node2 – > right ;
node2 – > right = root ;

if ( node2 – > balfact == 1 )
root – > balfact = -1 ;
else
root – > balfact = 0 ;
if ( node2- > balfact == -1 )
node1 – > balfact = 1 ;
else
node1 – > balfact = 0 ;
root = node2 ;
node2 – > balfact = 0 ;
}
}
return ( root ) ;
}

/* displays the tree in-order */
void display ( struct AVLNode *root )
{
if ( root != NULL )
{
display ( root – > left ) ;
printf ( “%d\t”, root – > data ) ;
display ( root – > right ) ;
}
}

/* deletes the tree */
void deltree ( struct AVLNode *root )
{
if ( root != NULL )
{
deltree ( root – > left ) ;
deltree ( root – > right ) ;
}
free ( root ) ;
}

C Program to Perform Basic Matrix Operations

Nanya — Wed, 16 Sep 2009 11:04:27 +0000

Here’s a tested C program to perform basic matrix operations like Addition, Multiplication etc.

#include < stdio.h >

#include < conio.h >

# define MAX 3

void create ( int [3][3] ) ;

void display ( int [3][3] ) ;

void matadd ( int [3][3], int [3][3], int [3][3] ) ;

void matmul ( int [3][3], int [3][3], int [3][3] ) ;

void transpose ( int [3][3], int [3][3] ) ;

void main( )

{
int mat1[3][3], mat2[3][3], mat3[3][3], mat4[3][3], mat5[3][3] ;

clrscr( ) ;

printf ( “\nEnter elements for first array: \n\n” ) ;

create ( mat1 ) ;

printf ( “\nEnter elements for second array: \n\n” ) ;

create ( mat2 ) ;

printf ( “\nFirst Array: \n” ) ;

display ( mat1 ) ;

printf ( “\nSecond Array:\n” ) ;

display ( mat2 ) ;

matadd ( mat1, mat2, mat3 ) ;

printf ( “\nAfter Addition: \n” ) ;

display ( mat3 ) ;

matmul ( mat1, mat2, mat4 ) ;

printf ( “\nAfter Multiplication: \n” ) ;

display ( mat4 ) ;

transpose ( mat1, mat5 ) ;

printf ( “\nTranspose of first matrix: \n” ) ;

display ( mat5 ) ;

getch( ) ;
}

/* creates matrix mat */

void create ( int mat[3][3] )

{

int i, j ;

for ( i = 0 ; i < MAX ; i++ )

{

for ( j = 0 ; j < MAX ; j++ )

{
printf ( "Enter the element: " ) ;

scanf ( "%d", &mat[i][j] ) ;
}
}
}

/* displays the contents of matrix */

void display ( int mat[3][3] )

{
int i, j ;

for ( i = 0 ; i < MAX ; i++ )

{
for ( j = 0 ; j < MAX ; j++ )

printf ( "%d\t", mat[i][j] ) ;

printf ( "\n" ) ;
}
}

/* adds two matrices m1 and m2 */

void matadd ( int m1[3][3], int m2[3][3], int m3[3][3] )

{
int i, j ;

for ( i = 0 ; i < MAX ; i++ )

{
for ( j = 0 ; j < MAX ; j++ )

m3[i][j] = m1[i][j] + m2[i][j] ;
}
}

/* multiplies two matrices m1 and m2 */

void matmul ( int m1[3][3], int m2[3][3], int m3[3][3] )

{
int i, j, k ;

for ( k = 0 ; k < MAX ; k++ )

{
for ( i = 0 ; i < MAX ; i++ )

{
m3[k][i] = 0 ;

for ( j = 0 ; j < MAX ; j++ )

m3[k][i] += m1[k][j] * m2[j][i] ;
}
}
}

/* obtains transpose of matrix m1 */

void transpose ( int m1[3][3], int m2[3][3] )

{
int i, j ;

for ( i = 0 ; i < MAX ; i++ )

{
for ( j = 0 ; j < MAX ; j++ )

m2[i][j] = m1[j][i] ;
}
}