Scribd
Upload
7 views9 pages

DS Practical 1

The document contains a series of C programming assignments related to binary tree operations, including pre-order, post-order, leaf count, and in-order traversals. Each section provides code examples for constructing binary trees and performing the specified traversals, along with the expected output. The assignments demonstrate fundamental concepts of data structures and memory management in C.

Uploaded by

Sahil Mahakal
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
7 views9 pages

DS Practical 1

The document contains a series of C programming assignments related to binary tree operations, including pre-order, post-order, leaf count, and in-order traversals. Each section provides code examples for constructing binary trees and performing the specified traversals, along with the expected output. The assignments demonstrate fundamental concepts of data structures and memory management in C.

Uploaded by

Sahil Mahakal
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 9

Name:

class: SYBCS
Roll.no:
DSA II Assignment No.1

********************************************************
Q.1) Write a c program for pre_order Traversal
#include<stdio.h>
#include<malloc.h>

struct node{
int data;
struct node* left;
struct node* right;
};

struct node* createNode(int data){


struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the
heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
}
void preOrder(struct node* root){
if(root!=NULL){
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
}
}

int main(){

// Constructing the root node - Using Function (Recommended)


struct node *p = createNode(4);
struct node *p1 = createNode(1);
struct node *p2 = createNode(6);
struct node *p3 = createNode(5);
struct node *p4 = createNode(2);
// Finally The tree looks like this:
// 4
// /\
// 1 6
// / \
// 5 2

// Linking the root node with left and right children


p->left = p1;
p->right = p2;
p1->left = p3;
p1->right = p4;

preOrder(p);
return 0;
}
OUTPUT:
41526

Q.2) Write C program for the PrePost_order Traversal.


#include<stdio.h>
#include<malloc.h>

struct node{
int data;
struct node* left;
struct node* right;
};

struct node* createNode(int data){


struct node *n; // creating a node pointer
n = (struct node *) malloc(sizeof(struct node)); // Allocating memory in the
heap
n->data = data; // Setting the data
n->left = NULL; // Setting the left and right children to NULL
n->right = NULL; // Setting the left and right children to NULL
return n; // Finally returning the created node
}

void preOrder(struct node* root){


if(root!=NULL){
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
}
}

void postOrder(struct node* root){


if(root!=NULL){
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->data);
}
}
int main(){

// Constructing the root node - Using Function (Recommended)


struct node *p = createNode(4);
struct node *p1 = createNode(1);
struct node *p2 = createNode(6);
struct node *p3 = createNode(5);
struct node *p4 = createNode(2);
// Finally The tree looks like this:
// 4
// /\
// 1 6
// / \
// 5 2

// Linking the root node with left and right children


p->left = p1;
p->right = p2;
p1->left = p3;
p1->right = p4;

preOrder(p);
printf("\n");
postOrder(p);
return 0;
}
OUTPUT:
41526
52164

Q.3) Write Program for implementation to find leaf count of a given Binary tree
#include <stdio.h>
#include <stdlib.h>

/* A binary tree node has data, pointer to left child


and a pointer to right child */
struct node
{
int data;
struct node* left;
struct node* right;
};

/* Function to get the count of leaf nodes in a binary tree*/


unsigned int getLeafCount(struct node* node)
{
if(node == NULL)
return 0;
if(node->left == NULL && node->right==NULL)
return 1;
else
return getLeafCount(node->left)+
getLeafCount(node->right);
}

/* Helper function that allocates a new node with the


given data and NULL left and right pointers. */
struct node* newNode(int data)
{
struct node* node = (struct node*)
malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;

return(node);
}

/*Driver program to test above functions*/


int main()
{
/*create a tree*/
struct node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
/*get leaf count of the above created tree*/
printf("Leaf count of the tree is %d", getLeafCount(root));

getchar();
return 0;
}
OUTPUT:
Leaf count of the tree is 3

Q.4) C program for Inorder_traversal


#include <stdio.h>
#include <stdlib.h>
struct node {
int element;
struct node* left;
struct node* right;
};
/*To create a new node*/
struct node* createNode(int val)
{
struct node* Node = (struct node*)malloc(sizeof(struct node));
Node->element = val;
Node->left = NULL;
Node->right = NULL;
return (Node);
}
/*function to traverse the nodes of binary tree in Inorder*/
void traverseInorder(struct node* root)
{
if (root == NULL)
return;
traverseInorder(root->left);
printf(" %d ", root->element);
traverseInorder(root->right);
}
int main()
{
struct node* root = createNode(40);
root->left = createNode(30);
root->right = createNode(50);
root->left->left = createNode(25);
root->left->right = createNode(35);
root->left->left->left = createNode(15);
root->left->left->right = createNode(28);
root->right->left = createNode(45);
root->right->right = createNode(60);
root->right->right->left = createNode(55);
root->right->right->right = createNode(70);
printf("\n The Inorder traversal of given binary tree is -\n");
traverseInorder(root);
return 0;
}
OUTPUT:
The inorder traversal of given binary tree is –
15 25 28 30 35 40 45 50 55 60 70

You might also like