please help me to write a program toinsertion and deletion in array

[viggy]

please give me a program for insertion for insertion and deletion in an array

[viggy]

program to push and pop in an array stack

[viggy]

program to insert and delete in an array queue

[viggy]

program to convert given decimal number to binary

[gregv21]

i think thers a decimal to binary converter in the sourcode section of this site

[alex79roma]

You need an Object Oriented solution or just a structured one (C or C++)?
Which data type you need to put into your stack and queue?
If you need a generic data type solution can you use C++ templates?

[alex79roma]

I can give you an Object-Orientd implementation with templates that supports all data types stack and queue.


QUEUE:

///////////////////////////////////////////////////
// COPY FROM HERE

#include <iostream.h>


///////////////////////////////////////////////////


#define QUEUE_SIZE 5	// MODIFY THIS!!!


///////////////////////////////////////////////////


template <class T>
class queue {
	public:
		queue();
		~queue();
		bool enqueue(T elem);
		T    dequeue();
		bool isEmpty();
		bool isFull();
		void empty();
	private:
		T             data[QUEUE_SIZE + 1];
		unsigned long head;
		unsigned long tail;
		unsigned long next(unsigned long val);
};


///////////////////////////////////////////////////


template <class T>
queue<T>::queue() {
	head = tail = 0;
}


template <class T>
queue<T>::~queue() {
}


template <class T>
bool queue<T>::enqueue(T elem) {
	if(! isFull()) {
		data[tail] = elem;
		tail = next(tail);
		return true;
	}
	else {
		return false;
	}
}


template <class T>
T queue<T>::dequeue() {
	T elem;
	if(! isEmpty()) {
		elem = data[head];
		head = next(head);
	}
	return elem;
}


template <class T>
bool queue<T>::isEmpty() {
	return head == tail;
}


template <class T>
bool queue<T>::isFull() {
	return next(tail) == head;
}


template <class T>
void queue<T>::empty() {
	head = tail = 0;
}


template <class T>
unsigned long queue<T>::next(unsigned long val) {
	if(val == QUEUE_SIZE)
		return 0;
	else
		return val + 1;
}


// COPY TILL HERE
///////////////////////////////////////////////////


///////////////////////////////////////////////////
// TEST PROGRAM


void pause() {
	char c;
	cin >> c;
}


void main() {
	queue<int> q;

	if(q.isEmpty())
		cout << "queue is empty" << endl;
	else
		cout << "queue is not empty" << endl;

	cout << "add numbers from 1 to 4" << endl;
	q.enqueue(1);
	q.enqueue(2);
	q.enqueue(3);
	q.enqueue(4);

	cout << "extracted the first element: " << q.dequeue() << endl;

	if(q.isFull())
		cout << "queue is full" << endl;
	else
		cout << "queue is not full" << endl;

	cout << "add numbers from 5 to 6" << endl;
	q.enqueue(5);
	q.enqueue(6);

	if(q.isFull())
		cout << "queue is full" << endl;
	else
		cout << "queue is not full" << endl;

	// now q should be full and then next values shoud not be enqueued
	cout << "add numbers from 7 to 8" << endl;
	q.enqueue(7);
	q.enqueue(8);

/////////////////////////////////
// print q extracting elements //

	cout << "print queue extracting elements:" << endl;
	cout << "queue = {";
	if(q.isEmpty()) {
		cout << " }" << endl;
	}
	else {
		while(! q.isEmpty()) {
			cout << q.dequeue() << ", ";
		}
		cout << "\b\b}" << endl;
	}

// print q extracting elements //
/////////////////////////////////

	if(q.isEmpty())
		cout << "queue is empty" << endl;
	else
		cout << "queue is not empty" << endl;

	pause();
}

STACK:

///////////////////////////////////////////////////
// COPY FROM HERE


#include <iostream.h>


///////////////////////////////////////////////////


#define STACK_SIZE 5	// MODIFY THIS !!!


///////////////////////////////////////////////////


template <class T>
class stack {
	public:
		stack();
		~stack();
		bool push(T elem);
		T    pop();
		T    top();
		bool isEmpty();
		bool isFull();
		void empty();
	private:
		T    data[STACK_SIZE];
		long topelem;
};


///////////////////////////////////////////////////


template <class T>
stack<T>::stack() {
	topelem = -1;
}


template <class T>
stack<T>::~stack() {
}


template <class T>
bool stack<T>::push(T elem) {
	if(! isFull()){
		data[topelem++] = elem;
		return true;
	}
	else {
		return false;
	}
}


template <class T>
T stack<T>::pop() {
	T elem;
	if(! isEmpty()) {
		elem = data[--topelem];
	}
	return elem;
}


template <class T>
T stack<T>::top() {
	T elem;
	if(! isEmpty()) {
		elem = data[topelem];
	}
	return elem;
}


template <class T>
bool stack<T>::isEmpty() {
	return topelem == -1;
}


template <class T>
bool stack<T>::isFull() {
	return topelem == STACK_SIZE - 1;
}


template <class T>
void stack<T>::empty() {
	topelem = -1;
}


// COPY TILL HERE
///////////////////////////////////////////////////


///////////////////////////////////////////////////
// TEST PROGRAM


void pause() {
	char c;
	cin >> c;
}


void main() {
	stack<int> s;

	if(s.isEmpty())
		cout << "stack is empty" << endl;
	else
		cout << "stack is not empty" << endl;

	cout << "add numbers from 1 to 4" << endl;
	s.push(1);
	s.push(2);
	s.push(3);
	s.push(4);

	cout << "extracted top element from the stack: " << s.pop() << endl;

	if(s.isFull())
		cout << "stack is full" << endl;
	else
		cout << "stack is not full" << endl;

	cout << "add numbers from 5 to 6" << endl;
	s.push(5);
	s.push(6);

	if(s.isFull())
		cout << "stack is full" << endl;
	else
		cout << "stack is not full" << endl;

	// now s should be full and then next values shoud not be pushed
	cout << "add numbers from 7 to 8" << endl;
	s.push(7);
	s.push(8);

/////////////////////////////////
// print s extracting elements //

	cout << "print stack extracting elements:" << endl;
	cout << "stack = {";
	if(s.isEmpty()) {
		cout << " }" << endl;
	}
	else {
		while(! s.isEmpty()) {
			cout << s.pop() << ", ";
		}
		cout << "\b\b}" << endl;
	}

// print s extracting elements //
/////////////////////////////////

	if(s.isEmpty())
		cout << "stack is empty" << endl;
	else
		cout << "stack is not empty" << endl;

	pause();
}

I hope this is useful for you, anyway if you need something more different I can write other code for you.