Postfix Calculations In C

#include<stdio.h>
#include<conio.h>
#define STACKSIZE 20
typedef struct{
int top;
int items[STACKSIZE]; /*stack can contain up to 20 integers*/
}STACK;
void push(STACK *, int);
int pop(STACK *);
int calculate(char []);
int main()
{
int result;
char E[50];
printf("Enter your Postfix expression(don't use space character):\n");
scanf("%s",E);
result = calculate(E);
printf("The result of the Postfix expression %s=%d\n",E,result);
return 0;
}
int calculate(char exp[])
{
STACK s;
s.top =-1;/*indicates that the stack is empty at the beginning*/
int i,num1,num2,value;
for(i=0; exp[i]!='\0';i++){
if(exp[i] >='0' && exp[i] <='9') /*checks if exp[i] has a digit*/
push(&s,(int)(exp[i] -'0')); /*converts digit into integer*/
else{
num1=pop(&s);
num2=pop(&s);
switch(exp[i]){
case '+': value=num2+num1;break;
case '-': value=num2-num1;break;
case '*': value=num2*num1;break;
case '/': value=num2/num1;break;
default : printf("Illegal Operator\n");
exit(1);
}
push(&s,value);
}
}
return pop(&s);
}
void push(STACK *Sptr, int ps) /*pushes ps into stack*/
{
if(Sptr->top == STACKSIZE-1){
printf("Stack is full\n");
exit(1); /*exit from the function*/
}
else {
Sptr->top++;
Sptr->items[Sptr->top]= ps;
}
}
int pop(STACK *Sptr)
{
int pp;
if(Sptr->top == -1){
printf("Stack is empty\n");
exit(1); /*exit from the function*/
}
else {
pp = Sptr->items[Sptr->top];
Sptr->top--;
}
return pp;
}

Find Postfix Calculations In C

#include<stdio.h>
#include<conio.h>
#define STACKSIZE 20
typedef struct{
int top;
int items[STACKSIZE]; /*stack can contain up to 20 integers*/
}STACK;
void push(STACK *, int);
int pop(STACK *);
int calculate(char []);
int main()
{
int result;
char E[50];
printf("Enter your Postfix expression(don't use space character):\n");
scanf("%s",E);
result = calculate(E);
printf("The result of the Postfix expression %s=%d\n",E,result);
return 0;
}
int calculate(char exp[])
{
STACK s;
s.top =-1;/*indicates that the stack is empty at the beginning*/
int i,num1,num2,value;
for(i=0; exp[i]!='\0';i++){
if(exp[i] >='0' && exp[i] <='9') /*checks if exp[i] has a digit*/
push(&s,(int)(exp[i] -'0')); /*converts digit into integer*/
else{
num1=pop(&s);
num2=pop(&s);
switch(exp[i]){
case '+': value=num2+num1;break;
case '-': value=num2-num1;break;
case '*': value=num2*num1;break;
case '/': value=num2/num1;break;
default : printf("Illegal Operator\n");
exit(1);
}
push(&s,value);
}
}
return pop(&s);
}
void push(STACK *Sptr, int ps) /*pushes ps into stack*/
{
if(Sptr->top == STACKSIZE-1){
printf("Stack is full\n");
exit(1); /*exit from the function*/
}
else {
Sptr->top++;
Sptr->items[Sptr->top]= ps;
}
}
int pop(STACK *Sptr)
{
int pp;
if(Sptr->top == -1){
printf("Stack is empty\n");
exit(1); /*exit from the function*/
}
else {
pp = Sptr->items[Sptr->top];
Sptr->top--;
}
return pp;
}

EXAMPLE OF PALINDROME IN C PROGRAMMING

/*
The strings where the reading from the reverse and forward directions give the same word are called
a palindrome.

For example, -> the string ”radar” is an example for palindrome.
Among many other techniques stack can be used to determine if a string is a palindrome or not.
This is achieved by pushing all the letters of a given word into stack and checking if the letters popped are the same as the letter of the string.
*/

#include<stdio.h>
#include<conio.h>
#define STACKSIZE 25
typedef struct
{
int count;
int top;
char items[STACKSIZE];/*stack can contain up to 20 characters*/
}STACK;
void push(STACK *, int);
char pop(STACK *);
Sptr->count--;
}
return pp;
}
int main()
{
int i, check=0, size;
STACK s;
char p, A[20];
s.count=0;
s.top = -1; /*indicates that the stack is empty at the beginning*/
printf("Enter the string\n");
gets(A); /* alternatively you can use scanf("%s",A); */
/*pushing the characters of the string into the stack*/
for(i=0; A[i]!='\0';i++){
p = A[i];
push(&s,p);
}
size = s.count;
/*popping and checking if the letters are equal in rev. & forw.direction*/
for(i=0;i<=size-1;i++){
p=pop(&s);
if(p != A[i])
check ++;
}
if(check == 0)
printf("\nThe string %s is a palindrome\n",A);
else
printf("\nThe string %s is NOT a palindrome\n",A);
return 0;
}
void push(STACK *Sptr, int ps) /*pushes ps into stack*/
{
if(Sptr->top == STACKSIZE-1){
printf("Stack is full\n");
exit(1); /*exit from the function*/
}
else {
Sptr->top++;
Sptr->count++;
Sptr->items[Sptr->top]= ps;
}
}
char pop(STACK *Sptr)
{
char pp;
if(Sptr->top == -1){
printf("Stack is empty\n");
exit(1); /*exit from the function*/
}
else {
pp = Sptr->items[Sptr->top];
Sptr->top--;
Sptr->count--;
}
return pp;
}

Find string is a palindrome or not In c

/*
The strings where the reading from the reverse and forward directions give the same word are called
a palindrome.

For example, -> the string ”radar” is an example for palindrome.
Among many other techniques stack can be used to determine if a string is a palindrome or not.
This is achieved by pushing all the letters of a given word into stack and checking if the letters popped are the same as the letter of the string.
*/

#include<stdio.h>
#include<conio.h>
#define STACKSIZE 25
typedef struct
{
int count;
int top;
char items[STACKSIZE];/*stack can contain up to 20 characters*/
}STACK;
void push(STACK *, int);
char pop(STACK *);
Sptr->count--;
}
return pp;
}
int main()
{
int i, check=0, size;
STACK s;
char p, A[20];
s.count=0;
s.top = -1; /*indicates that the stack is empty at the beginning*/
printf("Enter the string\n");
gets(A); /* alternatively you can use scanf("%s",A); */
/*pushing the characters of the string into the stack*/
for(i=0; A[i]!='\0';i++){
p = A[i];
push(&s,p);
}
size = s.count;
/*popping and checking if the letters are equal in rev. & forw.direction*/
for(i=0;i<=size-1;i++){
p=pop(&s);
if(p != A[i])
check ++;
}
if(check == 0)
printf("\nThe string %s is a palindrome\n",A);
else
printf("\nThe string %s is NOT a palindrome\n",A);
return 0;
}
void push(STACK *Sptr, int ps) /*pushes ps into stack*/
{
if(Sptr->top == STACKSIZE-1){
printf("Stack is full\n");
exit(1); /*exit from the function*/
}
else {
Sptr->top++;
Sptr->count++;
Sptr->items[Sptr->top]= ps;
}
}
char pop(STACK *Sptr)
{
char pp;
if(Sptr->top == -1){
printf("Stack is empty\n");
exit(1); /*exit from the function*/
}
else {
pp = Sptr->items[Sptr->top];
Sptr->top--;
Sptr->count--;
}
return pp;
}

Push And Pop Data In Stack Using C Programming

/*
Stacks can be used to reverse a sequence.
For example,
->if a string ”Computers” is entered by the user the stack can be used to create and display the reverse string “sretupmoC” as follows.
The program simply pushes all of the characters of the string into the stack.
Then it pops and display until the stack is empty.
*/

#include<stdio.h>
#include<conio.h>
#define STACKSIZE 50
typedef struct{
int count;
int top;
char items[STACKSIZE];/*stack can contain up to 50 characters*/
}STACK;

void push(STACK *, char);
char pop(STACK *);

void main()
{
int i;
STACK s;
char p, A[20];
s.top = -1; /*indicates that the stack is empty at the beginning*/
s.count=0;
printf("Input the string please:\n");
gets(A); /* alternatively you can use scanf("%s",A); */
/*pushing the characters into the stack*/
for(i=0;A[i] != '\0';i++){
p = A[i];
push(&s,p);
}
printf("The string in reverse order is:");
/*popping and printing the string in reverse order*/
while(s.count >= 0){
p=pop(&s);
printf("%c",p);
}
return 0;
}

void push(STACK *Sptr, char ps) /*pushes ps into stack*/
{
if(Sptr->top == STACKSIZE-1){
printf("Stack is full\n");
Return; /*exit from the function*/
}
else {
Sptr->top++;
Sptr->count++;
Sptr->items[Sptr->top]= ps;
}
}

char pop(STACK *Sptr)
{
char pp;
if(Sptr->top == -1){
printf("\nStack is empty\n");
exit(1); /*exit from the function*/
}
else {
pp = Sptr->items[Sptr->top];
Sptr->top--;
Sptr->count--;
}
return pp;
}

Stack Using C Programming

/*
Stacks can be used to reverse a sequence.
For example,
->if a string ”Computers” is entered by the user the stack can be used to create and display the reverse string “sretupmoC” as follows.
The program simply pushes all of the characters of the string into the stack.
Then it pops and display until the stack is empty.
*/

#include<stdio.h>
#include<conio.h>
#define STACKSIZE 50
typedef struct{
int count;
int top;
char items[STACKSIZE];/*stack can contain up to 50 characters*/
}STACK;

void push(STACK *, char);
char pop(STACK *);

void main()
{
int i;
STACK s;
char p, A[20];
s.top = -1; /*indicates that the stack is empty at the beginning*/
s.count=0;
printf("Input the string please:\n");
gets(A); /* alternatively you can use scanf("%s",A); */
/*pushing the characters into the stack*/
for(i=0;A[i] != '\0';i++){
p = A[i];
push(&s,p);
}
printf("The string in reverse order is:");
/*popping and printing the string in reverse order*/
while(s.count >= 0){
p=pop(&s);
printf("%c",p);
}
return 0;
}

void push(STACK *Sptr, char ps) /*pushes ps into stack*/
{
if(Sptr->top == STACKSIZE-1){
printf("Stack is full\n");
Return; /*exit from the function*/
}
else {
Sptr->top++;
Sptr->count++;
Sptr->items[Sptr->top]= ps;
}
}

char pop(STACK *Sptr)
{
char pp;
if(Sptr->top == -1){
printf("\nStack is empty\n");
exit(1); /*exit from the function*/
}
else {
pp = Sptr->items[Sptr->top];
Sptr->top--;
Sptr->count--;
}
return pp;
}

Push And Pop characters In Stack Using C Programming

/*
Stacks can be used to reverse a sequence.
For example,
->if a string ”Computers” is entered by the user the stack can be used to create and display the reverse string “sretupmoC” as follows.
The program simply pushes all of the characters of the string into the stack.
Then it pops and display until the stack is empty.
*/

#include<stdio.h>
#include<conio.h>
#define STACKSIZE 50
typedef struct{
int count;
int top;
char items[STACKSIZE];/*stack can contain up to 50 characters*/
}STACK;

void push(STACK *, char);
char pop(STACK *);

void main()
{
int i;
STACK s;
char p, A[20];
s.top = -1; /*indicates that the stack is empty at the beginning*/
s.count=0;
printf("Input the string please:\n");
gets(A); /* alternatively you can use scanf("%s",A); */
/*pushing the characters into the stack*/
for(i=0;A[i] != '\0';i++){
p = A[i];
push(&s,p);
}
printf("The string in reverse order is:");
/*popping and printing the string in reverse order*/
while(s.count >= 0){
p=pop(&s);
printf("%c",p);
}
return 0;
}

void push(STACK *Sptr, char ps) /*pushes ps into stack*/
{
if(Sptr->top == STACKSIZE-1){
printf("Stack is full\n");
Return; /*exit from the function*/
}
else {
Sptr->top++;
Sptr->count++;
Sptr->items[Sptr->top]= ps;
}
}

char pop(STACK *Sptr)
{
char pp;
if(Sptr->top == -1){
printf("\nStack is empty\n");
exit(1); /*exit from the function*/
}
else {
pp = Sptr->items[Sptr->top];
Sptr->top--;
Sptr->count--;
}
return pp;
}

Insert And Delete Data In Stack Using C Programming

/*
Stacks can be used to reverse a sequence.
For example,
->if a string ”Computers” is entered by the user the stack can be used to create and display the reverse string “sretupmoC” as follows.
The program simply pushes all of the characters of the string into the stack.
Then it pops and display until the stack is empty.
*/

#include<stdio.h>
#include<conio.h>
#define STACKSIZE 50
typedef struct{
int count;
int top;
char items[STACKSIZE];/*stack can contain up to 50 characters*/
}STACK;

void push(STACK *, char);
char pop(STACK *);

void main()
{
int i;
STACK s;
char p, A[20];
s.top = -1; /*indicates that the stack is empty at the beginning*/
s.count=0;
printf("Input the string please:\n");
gets(A); /* alternatively you can use scanf("%s",A); */
/*pushing the characters into the stack*/
for(i=0;A[i] != '\0';i++){
p = A[i];
push(&s,p);
}
printf("The string in reverse order is:");
/*popping and printing the string in reverse order*/
while(s.count >= 0){
p=pop(&s);
printf("%c",p);
}
return 0;
}

void push(STACK *Sptr, char ps) /*pushes ps into stack*/
{
if(Sptr->top == STACKSIZE-1){
printf("Stack is full\n");
Return; /*exit from the function*/
}
else {
Sptr->top++;
Sptr->count++;
Sptr->items[Sptr->top]= ps;
}
}

char pop(STACK *Sptr)
{
char pp;
if(Sptr->top == -1){
printf("\nStack is empty\n");
exit(1); /*exit from the function*/
}
else {
pp = Sptr->items[Sptr->top];
Sptr->top--;
Sptr->count--;
}
return pp;
}

Displaying the linked list elements

/*
Function to display the student with highest CGPA in a linked list containing student data.
 Use the following node structure for your linked list.
*/
struct node{
int stNo;
float CGPA;
struct node *next;
};

typedef struct node *NODEPTR;
void DisplayMax(NODEPTR plist)
{
NODEPTR p;
float maxCGPA=-1.0;
int maxstNo;
p = plist;
/*current node*/
if(p == NULL){
printf(“no node/data is available in the list\n”);
return;
}
do{
if(p->CGPA > maxCGPA){
maxCGPA = p->CGPA;
maxstNo = p->stNo;
}
p = p->next;
} while(p!= NULL);
printf(“The student number with max CGPA: %d\n”, maxstNo);
printf(“The student’s CGPA: %d\n”, maxCGPA);
}

C Program For insert , delete ,display a new item in the Linked List

#include<stdio.h>
#include<conio.h>
/*
you can insert a new item to the end of the Linked List, delete the last
item from the linked list and display all the list items in the linked list. Note that the Linked List
contains integer items.      */

/*contains malloc & free functions */
#define NULL 0
struct node{
int info;
struct node *next;
};
typedef struct node nodeptr;
int menu(void);
void insertEnd(nodeptr **, int);/*insert to the end of the list*/
void deleteEnd(nodeptr **, int *);/*delete from the end " " "*/
void displayList(nodeptr *);
nodeptr *getnode(void);
void freenode(nodeptr *);
int main()
{
int choice,x;
nodeptr *List= NULL; /*List points the beginning of the list*/
do{
choice = menu();
switch(choice){
case 1:
printf("Enter new data item:");
scanf("%d",&x);
insertEnd(&List,x);
break;
case 2:
deleteEnd(&List,&x);
printf("The deleted data item is: %d",x);
break;
case 3:
displayList(List);
break;
default:
if(choice == 4)
printf("\nEnd of the Program");
else
printf("\nEnter the choice again");
break;
}
}while(choice !=4);
return 0;
}

/*
Use double pointer if you are changing the
content of the List which is a pointer to the
beginning of the Linked List.
Use single pointer if you are not changing the
content of the List which is a pointer to the
beginning of the Linked List.*/

int menu(void)
{
int c;
printf("\nMain Menu:\n");
printf("1 - Insert an item\n");
printf("2 - Delete an item\n");
printf("3 - Display the Linked List items\n");
printf("4 - Quit\n\n");
scanf("%d",&c);
return c;
}
void insertEnd(nodeptr **plist, int x)
{
nodeptr *p, *q;
p=getnode();
p->info = x;
p->next = NULL;
if(*plist == NULL)
*plist = p;
else{
q = *plist;
while(q->next != NULL)
q = q->next;
q->next = p;
}
}
void deleteEnd(nodeptr **plist, int *px)
{
nodeptr *p,*q;
if(*plist == NULL){
printf("void deletion\n");
return;
}
p = *plist; /*current node*/
q = p->next; /*the node after the current node*/
if(q == NULL){
*px = p->info; /*the data of the deleted element*/
freenode(p);
*plist = NULL;
}
else{
while(q->next != NULL){
p = p->next; /*go to the next node*/
q = p->next;
}
p->next = NULL;
*px = q->info; /*the data of the deleted element*/
freenode(q);
}
}

/*
Use double pointer if you are changing the
content of the plist which is a pointer to the
beginning of the Linked List.
Use double pointer if you are changing the
content of the plist which is a pointer to the
beginning of the Linked List.
*/

void displayList(nodeptr *plist)
{
nodeptr *p;
p = plist; /*current node*/
if(p == NULL){
printf("no node/data is available in the list\n");
return;
}
while(p!= NULL){
printf("%5d", p->info); /*prints the current data*/
p = p->next;
}
}
nodeptr *getnode(void)
{
nodeptr *p;
p = (nodeptr *) malloc(sizeof(nodeptr));
return p;
}
void freenode(nodeptr *p)
{
free(p);
}

Linear linked list structure In C Programming

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

/*contains malloc & free functions */
#define NULL 0
struct node{
int info;
struct node *next;
};
typedef struct node nodeptr;
int menu(void);
void insertEnd(nodeptr **, int);/*insert to the end of the list*/
void deleteEnd(nodeptr **, int *);/*delete from the end " " "*/
void displayList(nodeptr *);
nodeptr *getnode(void);
void freenode(nodeptr *);
int main()
{
int choice,x;
nodeptr *List= NULL; /*List points the beginning of the list*/
do{
choice = menu();
switch(choice){
case 1:
printf("Enter new data item:");
scanf("%d",&x);
insertEnd(&List,x);
break;
case 2:
deleteEnd(&List,&x);
printf("The deleted data item is: %d",x);
break;
case 3:
displayList(List);
break;
default:
if(choice == 4)
printf("\nEnd of the Program");
else
printf("\nEnter the choice again");
break;
}
}while(choice !=4);
return 0;
}

/*
Use double pointer if you are changing the
content of the List which is a pointer to the
beginning of the Linked List.
Use single pointer if you are not changing the
content of the List which is a pointer to the
beginning of the Linked List.*/

int menu(void)
{
int c;
printf("\nMain Menu:\n");
printf("1 - Insert an item\n");
printf("2 - Delete an item\n");
printf("3 - Display the Linked List items\n");
printf("4 - Quit\n\n");
scanf("%d",&c);
return c;
}
void insertEnd(nodeptr **plist, int x)
{
nodeptr *p, *q;
p=getnode();
p->info = x;
p->next = NULL;
if(*plist == NULL)
*plist = p;
else{
q = *plist;
while(q->next != NULL)
q = q->next;
q->next = p;
}
}
void deleteEnd(nodeptr **plist, int *px)
{
nodeptr *p,*q;
if(*plist == NULL){
printf("void deletion\n");
return;
}
p = *plist; /*current node*/
q = p->next; /*the node after the current node*/
if(q == NULL){
*px = p->info; /*the data of the deleted element*/
freenode(p);
*plist = NULL;
}
else{
while(q->next != NULL){
p = p->next; /*go to the next node*/
q = p->next;
}
p->next = NULL;
*px = q->info; /*the data of the deleted element*/
freenode(q);
}
}

/*
Use double pointer if you are changing the
content of the plist which is a pointer to the
beginning of the Linked List.
Use double pointer if you are changing the
content of the plist which is a pointer to the
beginning of the Linked List.
*/

void displayList(nodeptr *plist)
{
nodeptr *p;
p = plist; /*current node*/
if(p == NULL){
printf("no node/data is available in the list\n");
return;
}
while(p!= NULL){
printf("%5d", p->info); /*prints the current data*/
p = p->next;
}
}
nodeptr *getnode(void)
{
nodeptr *p;
p = (nodeptr *) malloc(sizeof(nodeptr));
return p;
}
void freenode(nodeptr *p)
{
free(p);
}