mList Function #include <iostream> #include <cassert> using namespace std; templ
ID: 3917394 • Letter: M
Question
mList Function
#include <iostream>
#include <cassert>
using namespace std;
template <typename T>
class Lnode
{
public :
T data;
Lnode *lptr;
Lnode *rptr;
};
template <typename T>
class Mlist
{ public :
//done
Mlist();
void add(T x);
void del();
T getfront();
T getback();
T operator[] (unsigned int i);
void insert(int i,T x);
void erase(int i);
void del(T x);
void print();
private :
Lnode<T> *first;
Lnode<T> *last;
int lsize;
};
template <typename T>
Mlist<T>::Mlist()
{
first=0;
last=0;
lsize=0;
}
template <typename T>
void Mlist<T>::add(T x)
{
Lnode<T> *ptr = new Lnode<T>;
ptr->data=x;
if(lsize==0)
{
ptr->lptr=0;
ptr->rptr=0;
first=ptr;
last=ptr;
}
else
{
ptr->lptr=last;
ptr->rptr=0;
last->rptr=ptr;
last=ptr;
}
lsize++;
}
template <typename T>
void Mlist<T>::del()
{
Lnode<T> *cur = new Lnode<T>;
first=first->rptr;
delete cur;
first->lptr=0;
lsize--;
}
template <typename T>
T Mlist<T>::getfront()
{
return first->data;
}
template <typename T>
T Mlist<T>::getback()
{
return last->data;
}
template <typename T>
T Mlist<T>::operator[] (unsigned int i)
{
assert(lsize>0);
Lnode<T> *ptr;
ptr=first;
for(int j=0; j<i; j++)
{
ptr=ptr->rptr;
}
return ptr->data;
}
template <typename T>
void Mlist<T>::insert(int i,T x)
{
Lnode<T> *nptr = new Lnode<T>;
nptr->data=x;
assert(i>=0 and i<=lsize);
if (i==0 and lsize==0) //empty list
{
first=nptr;
last=nptr;
nptr->lptr=0;
nptr->rptr=0;
lsize++;
return;
}
if (i==0) //add front
{
nptr->lptr=0;
nptr->rptr=first;
first=nptr;
lsize++;
return;
}
if (i==lsize) //add end
{
nptr->lptr=last;
last->rptr=nptr;
nptr->rptr=0;
last=nptr;
lsize++;
return;
}
Lnode<T> *ptr=first;
for (int j=0; j< i; j++)
{
ptr=ptr->rptr;
}
Lnode<T> *previous = ptr->lptr;
nptr->rptr=ptr;
nptr->lptr=previous;
previous->rptr=nptr;
ptr->lptr=nptr;
lsize++;
return;
}
template <typename T>
void Mlist<T>::erase(int i)
{
Lnode<T> *ptr=first;
for (int j=0; j< i; j++)
{
ptr=ptr->rptr;
}
// now ptr points to [i]
Lnode<T> *next = ptr->rptr;
Lnode<T> *previous = ptr->lptr;
if (previous==0 and next==0) // one element
{ delete first;
first=0;
last=0;
lsize--;
return;
}
if ( next==0) // last element
{ last=previous;
last->rptr=0;
delete ptr;
lsize--;
return;
}
if (previous==0) //delete first element
{ first=ptr->rptr;
first->lptr=0;
delete ptr;
lsize--;
ptr=first;
}
else // not the first and not the last
{
previous->rptr=ptr->rptr;
next->lptr=ptr->lptr;
delete ptr;
lsize--;
}
}
template <typename T>
void Mlist<T>::del(T x)
{
if (lsize==0)
{
return;
}
Lnode<T> *ptr=first;
while ( ptr != 0 )
{
if (ptr->data == x)
{
Lnode<T> *next = ptr->rptr;
Lnode<T> *previous = ptr->lptr;
if (previous==0 and next==0) // one element
{ delete first;
first=0;
last=0;
lsize--;
return;
}
if ( next==0) // last element
{ last=previous;
last->rptr=0;
delete ptr;
lsize--;
return;
}
if (previous==0) //delete first element
{ first=ptr->rptr;
first->lptr=0;
delete ptr;
lsize--;
}
else // not the first and not the last
{
previous->rptr=ptr->rptr;
next->lptr=ptr->lptr;
delete ptr;
ptr=next;
lsize--;
}
}
else // move ptr to right
{
ptr=ptr->rptr;
}
}
}
template <typename T>
void Mlist<T>::print()
{
for(int i = 0; i < this->lsize; i++)
{
std::cout << this->operator[](i) << std::endl;
}
}
int main()
{
Mlist<int> x;
x.add(5);
x.add(10);
x.add(7);
x.add(1);
x.insert(3, 8);
x.erase(1);
x.del(7);
x.print();
return 0;
}
Explanation / Answer
here is your modified code : ---------->>>>>>>
#include <iostream>
#include <cassert>
using namespace std;
template <typename T>
class Lnode
{
public :
T data;
Lnode *lptr;
Lnode *rptr;
};
template <typename T>
class Mlist
{ public :
//done
Mlist();
void add(T x);
void del();
T getfront();
T getback();
T operator[] (unsigned int i);
void insert(int i,T x);
void erase(int i);
void addorder(T x);
void del(T x);
void print();
private :
Lnode<T> *first;
Lnode<T> *last;
int lsize;
};
//adding definition
template<typename T>
void Mlist<T>::addorder(T x){
if(first == NULL){
add(x);
return;
}
Lnode<T> *cur = first;
Lnode<T> *nNode = new Lnode<T>();
nNode->data = x;
while(cur != NULL){
if(cur->data > x){
if(cur->lptr == NULL){
nNode->rptr = first;
first = nNode;
first->lptr = NULL;
lsize++;
return;
}
nNode->lptr = cur->lptr;
nNode->rptr = cur;
cur->lptr = nNode;
nNode->lptr->rptr = nNode;
lsize++;
return;
}
cur = cur->rptr;
}
delete nNode;
add(x);
}
template <typename T>
Mlist<T>::Mlist()
{
first=0;
last=0;
lsize=0;
}
template <typename T>
void Mlist<T>::add(T x)
{
Lnode<T> *ptr = new Lnode<T>;
ptr->data=x;
if(lsize==0){
ptr->lptr=0;
ptr->rptr=0;
first=ptr;
last=ptr;
}
else{
ptr->lptr=last;
ptr->rptr=0;
last->rptr=ptr;
last=ptr;
}
lsize++;
}
template <typename T>
void Mlist<T>::del()
{
Lnode<T> *cur = new Lnode<T>;
first=first->rptr;
delete cur;
first->lptr=0;
lsize--;
}
template <typename T>
T Mlist<T>::getfront()
{
return first->data;
}
template <typename T>
T Mlist<T>::getback()
{
return last->data;
}
template <typename T>
T Mlist<T>::operator[] (unsigned int i)
{
assert(lsize>0);
Lnode<T> *ptr;
ptr=first;
for(int j=0; j<i; j++){
ptr=ptr->rptr;
}
return ptr->data;
}
template <typename T>
void Mlist<T>::insert(int i,T x)
{
Lnode<T> *nptr = new Lnode<T>;
nptr->data=x;
assert(i>=0 and i<=lsize);
if (i==0 and lsize==0) //empty list
{
first=nptr;
last=nptr;
nptr->lptr=0;
nptr->rptr=0;
lsize++;
return;
}
if(i==0)//add front
{
nptr->lptr=0;
nptr->rptr=first;
first=nptr;
lsize++;
return;
}
if (i==lsize) //add end
{
nptr->lptr=last;
last->rptr=nptr;
nptr->rptr=0;
last=nptr;
lsize++;
return;
}
Lnode<T> *ptr=first;
for (int j=0; j< i; j++){
ptr=ptr->rptr;
}
Lnode<T> *previous = ptr->lptr;
nptr->rptr=ptr;
nptr->lptr=previous;
previous->rptr=nptr;
ptr->lptr=nptr;
lsize++;
return;
}
template <typename T>
void Mlist<T>::erase(int i)
{
Lnode<T> *ptr=first;
for (int j=0; j< i; j++){
ptr=ptr->rptr;
}
// now ptr points to [i]
Lnode<T> *next = ptr->rptr;
Lnode<T> *previous = ptr->lptr;
if (previous==0 and next==0) // one element
{
delete first;
first=0;
last=0;
lsize--;
return;
}
if ( next==0) // last element
{
last=previous;
last->rptr=0;
delete ptr;
lsize--;
return;
}
if (previous==0) //delete first element
{
first=ptr->rptr;
first->lptr=0;
delete ptr;
lsize--;
ptr=first;
}
else // not the first and not the last
{
previous->rptr=ptr->rptr;
next->lptr=ptr->lptr;
delete ptr;
lsize--;
}
}
template <typename T>
void Mlist<T>::del(T x)
{
if (lsize==0){
return;
}
Lnode<T> *ptr=first;
while ( ptr != 0 ){
if (ptr->data == x){
Lnode<T> *next = ptr->rptr;
Lnode<T> *previous = ptr->lptr;
if (previous==0 and next==0) // one element
{
delete first;
first=0;
last=0;
lsize--;
return;
}
if ( next==0) // last element
{
last=previous;
last->rptr=0;
delete ptr;
lsize--;
return;
}
if (previous==0) //delete first element
{
first=ptr->rptr;
first->lptr=0;
delete ptr;
lsize--;
}
else // not the first and not the last
{
previous->rptr=ptr->rptr;
next->lptr=ptr->lptr;
delete ptr;
ptr=next;
lsize--;
}
}
else // move ptr to right
{
ptr=ptr->rptr;
}
}
}
template <typename T>
void Mlist<T>::print()
{
for(int i = 0; i < this->lsize; i++){
std::cout << this->operator[](i) << std::endl;
}
}
int main()
{
Mlist<int> x;
x.addorder(5);
x.addorder(10);
x.addorder(7);
x.addorder(1);
x.print();
return 0;
}
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.