#include <stdio.

h>

#include <stdlib.h>

//-------------Leaner Search-------------

int lSearch (float d[],int size,float key)

int index,position=-1,found=0;

for(index=0;index<size&&!found;index++)

if (d[index]==key)

found=1;

position=index;

}return position;

int main()

float d[10]={9,5,1,3,7,4,6,2,8,10};

printf("The Position Is %d",lSearch(d,10,4));

return 0;

#include <stdio.h>
#include <stdlib.h>

//-------------Binary Search No Recursive-------------

int bSearch (float d[],int size,float key)

int first=0,last=size-1,found=0,position=-1,mid;

while(!found&&last>=first)

mid=(first+last)/2;

if(d[mid]==key)

found=1;

position=mid;

else if(d[mid]>key)

last=mid-1;

else

first=mid+1;

}return position;

int main()

{
 float d[10]={1,2,3,4,5,6,7,8,9,10};

printf("The Position Is %d",bSearch(d,10,4));

return 0;

#include <stdio.h>

#include <stdlib.h>

//-------------Binary Search with Recursive-------------

int bSearch (float d[],int size,float key)

int mid =size/2;

if (d[mid]==key) return mid;

if (d[mid]>key) return bSearch(&d[0],mid+1,key);

if (d[mid]<key) return mid+1+bSearch(&d[mid+1],size-mid,key);

int main()

float d[10]={1,2,3,4,5,6,7,8,9,10};

printf("The Position Is %d",bSearch(d,10,4));

return 0;

#include <stdio.h>

#include <stdlib.h>
//-------------Bubble Sort-------------

void swap (float* p1,float* p2)

float temp;

temp=*p1;

*p1=*p2;

*p2=temp;

void bSort(float d[],int size)

int swaping,i;

do

{ swaping=0;

for (i=0;i<size-1;i++)

if (d[i]>d[i+1])

swaping=1;

swap(&d[i],&d[i+1]);

}while (swaping);

int main()

float d[10]= {5,6,4,9,8,7,3,2,10,1};

int i,size=10;
 bSort(d,10);

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

printf("%.0f \t",d[i]);

return 0;

#include <stdio.h>

#include <stdlib.h>

//-------------Selection Sort-------------

void swap (float* p1,float* p2)

float temp;

temp=*p1;

*p1=*p2;

*p2=temp;

int minin (float d[],int size)

int minid,i;

float min;

min=d[0];

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

if (d[i]<min)
 {

minid=i;

min=d[i];

return minid;

void selectsort (float d[],int size)

if (size>1){

swap(&d[0],&d[minin(&d[0],size)]);

return selectsort(&d[1],size-1);

int main()

float d[10]={9,5,1,2,3,6,4,7,10,8};

selectsort(d,10);

int i,size=10;

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

printf("%.0f\t",d[i]);

return 0;

#include <stdio.h>
#include <stdlib.h>

#define SIZE 10

//-------------Stack-------------

struct stack {int data[SIZE];

int sp;};

int init (struct stack* s)

return s->sp=-1;

int full (struct stack* s)

return s->sp==SIZE;

int emp (struct stack* s)

return s->sp==-1;

int push (struct stack* s,int item)

s->data[++s->sp]=item;

int pop (struct stack* s)

int temp;

temp=s->data[s->sp];
 --(s->sp);

return temp;

int top (struct stack* s)

return s->data[s->sp];

int main()

int i=0;

struct stack s1;

init(&s1);

while (!full(&s1))

push(&s1,i++);

while (!emp(&s1))

printf("%d\t",pop(&s1));

return 0;

#include <stdio.h>
#include <stdlib.h>

#define SIZE 10

//-------------Queue-------------

struct queue {int data[SIZE];

int head,tail;};

int increment (int item)

return ++item<=SIZE?item:0;

int init (struct queue* q)

return q->head=q->tail=0;

int full (struct queue* q)

return increment(q->tail)==q->head;

int emp(struct queue* q)

return q->tail==q->head;

int enqueue (struct queue* q,int item)

{
 q->data[q->tail]=item;

q->tail=increment(q->tail);

int dequeue (struct queue* q)

int temp;

temp=q->data[q->head];

q->head=increment(q->head);

return temp;

int main (){

int i=1;

struct queue q1;

init(&q1);

while(!full(&q1))

enqueue(&q1,i++);

while(!emp(&q1))

printf("%d\t",dequeue(&q1));

return 0;