Kendall Smallcse.csusb.edu/tongyu/studentwork/cs330/hw/hw3_dir/Small... · 2016. 11. 2. · Kendall Small Professor Yu CSE 330 Homework 3 I believe I deserve full credit (55 points)

Kendall Small

Professor Yu

CSE 330

Homework 3

I believe I deserve full credit (55 points) for this assignment because I successfully completed

each problem and included output.

1.( 20 points ) Suppose for a certain application it was important to always know the number of

elements in a list. The implementation of the member function size() of class List discussed in

class and presented in the textbook employs a loop, and thus has O(n) execution time.

Using inheritance, write a new template class named countedList that maintains an explicit

count on the number of values held in the list, and the function size() will return this count. You

need to rewrite the insertion and deletion functions in the subclass so that the count is handled

appropriately.

//list.h

#ifndef LIST_H

#define LIST_H

template <typename T> class countedList;

template <typename T> class Node; //forward declaration

template <typename T> class listIterator; //forward declaration

template<typename T>

class List {

protected:

Node<T> *first;

Node<T> *last;

public:

//type definition

typedef T value_type;

typedef listIterator<T> iterator;

//constructor and destructor

List ();

virtual ~List();

//operations

bool empty();

int size();

T &front(); //returns first element

T &back(); //returns last element

void push_front ( T & ); //insert from the front

void push_back( T & ); //insert from the back

void pop_front(); //remove first element

void pop_back(); //remove last element

iterator begin();

iterator end();

void sort();

void insert( iterator &, T &);

void erase( iterator & );

void erase( iterator &, iterator &);

};

template <typename T>

class listIterator {

typedef listIterator<T> iterator;

protected:

List<T> *theList;

Node<T> *currentNode;

friend class List<T>;

friend class countedList<T>;

public:

//constructor

listIterator ();

listIterator ( List<T> *tl, Node<T> *cl );

T &operator * (); //dereferencing

bool operator != ( iterator &rhs );

iterator & operator ++ ( int ); //prefix

iterator operator ++ (); //postfix

};

#endif

//Node.h

#ifndef NODE_H

#define NODE_H

template <typename T> class countedList;

template <typename T> class List; //forward declaration

template <typename T> class listIterator; //forward declaration

//a Node is a node ( cell )

template <typename T> class Node {

private:

Node ( T &v ); //constructor

T value;

Node<T> *next;

Node<T> *prev;

//allow lists and iterators to access members

friend class List<T>;

friend class listIterator<T>;

friend class countedList<T>;

};

#endif

//list.cpp

#include <iostream>

#include "list.h"

#include "Node.h"

#include <stdio.h>


List<T>::List()

{

first = last = 0; //null list

}


bool List<T>::empty()

{

return first == 0;

}


int List<T>::size()

//count the number of elements in collection

/*

Comments from Tong: This is NOT a good implementation as

it takes time to traverse the list. A better way is to include

a field called 'size' in the List class; when elements are

inserted or deleted, size is adjusted.

*/

{

int count = 0;

Node<T> *p;

for ( p = first; p != 0; p = p->next )

count++;

return count;

}


void List<T>::push_front( T &a )

{

Node<T> *newNode = new Node<T> ( a );

if ( empty() )

first = last = newNode;

else {

first->prev = newNode;

newNode->next = first;

first = newNode;

}

}


void List<T>::pop_front()

{

Node <T> *temp = first;

first = first->next;

if ( first != 0 )

first->prev = 0;

else

last = 0;

delete temp;

}


List<T>::~List()

{

Node <T> *p = first;

while ( p != 0 ) {

Node<T> *temp = p;

p = p->next;

delete temp;

}

}


listIterator<T> List<T>::begin()

{

return iterator ( this, first );

}


listIterator<T> List<T>::end()

{

return iterator ( this, 0 ); //points beyond last

}

//listIterator

//constructors


listIterator<T>::listIterator()

{

}


listIterator<T>::listIterator( List<T> *lp, Node<T> *lkp )

{

theList = lp;

currentNode = lkp;

}


T & listIterator<T>::operator * ()

{

return currentNode->value;

}


bool listIterator<T>::operator != ( iterator &rhs )

{

return currentNode != rhs.currentNode;

}


listIterator<T> & listIterator<T>::operator ++ (int)

{

currentNode = currentNode->next;

return *this;

}


listIterator<T> listIterator<T>::operator ++ ()

//postfix form of increment ( e.g. assigned, then increment )

{

//make an old copy

listIterator<T> clone ( theList, currentNode );

currentNode = currentNode->next; //advance pointer

return clone; //return old iterator

}


void List<T>::insert( listIterator<T> &itr, T &a )

{

Node<T> *p = new Node<T> ( a );

Node<T> *current = itr.currentNode;

if ( empty() ) { //empty list

first = last = p;

return;

}

//assert ( current );

if ( current == 0 ){ //point to end, thus append to list

last->next = p;

p->next = 0;

p->prev = last;

last = p;

return;

}

//otherwise, always insert before

p->next = current;

p->prev = current->prev;

current->prev = p;

current = p->prev;

if ( current != 0 )

current->next = p;

else

first = p;

}


void List<T>::erase ( listIterator<T> &start, listIterator<T> &stop )

//remove elements from the range ( before stop )

{

//List is friend of listIterator, so it can access listIterator's

// private or protected data member

Node<T> *p = start.currentNode;

Node<T> *q = p->prev;

Node<T> *stopNode = stop.currentNode;

if ( q == 0 ) { //removing initial portion of list

first = stopNode;

if ( stopNode == 0 ) //pointing to end

last = 0; //whole list is deleted

else

stopNode->prev = 0;

} else {

q->next = stopNode;

if ( stopNode == 0 )

last = q;

else

stopNode->prev = q; // q->prev = q;

}

//now delete the atoms

while ( start != stop ) {

listIterator<T> next = start;

++next;

delete start.currentNode;

start = next;

}

}

//Node.cpp

#include "Node.h"

#include "list.h"


Node<T>::Node( T &v )

{

value = v;

prev = next = 0;

}

//countedList

//Kendall Small

#include "list.h"

#ifndef COUNTEDLIST_H

#define COUNTEDLIST_H


class countedList : public List<T>{

protected:

int size;

public:

countedList(){size=0;}

void c_erase(listIterator<T> &start, listIterator<T> &stop);

void c_insert(listIterator<T> &itr, T &a);

void c_pop_front();

void c_push_front(T &a);

int c_size(){return size;}

~countedList();

};

#endif

//countedList.cpp

//Kendall Small

//#include "list.h"

#include "countedlist.h"

#include<iostream>

//using namespace std;


countedList<T>::~countedList()

{

Node <T> *p = List<T>::first;

while ( p != 0 ) {

Node<T> *temp = p;

p = p->next;

delete temp;

}

}


void countedList<T>::c_push_front(T &a)

{

size++;

Node<T> *newNode = new Node<T> ( a );

if ( List<T>::empty() )

List<T>::first = List<T>::last = newNode;

else {

List<T>::first->prev = newNode;

newNode->next = List<T>::first;

List<T>::first = newNode;

}

}


void countedList<T>::c_pop_front()

{

size--;

Node <T> *temp = List<T>::first;

List<T>::first = List<T>::first->next;

if ( List<T>::first != 0 )

List<T>::first->prev = 0;

else

List<T>::last = 0;

delete temp;

}


void countedList<T>::c_insert(listIterator<T> &itr, T &a)

{

size++;

Node<T> *p = new Node<T> ( a );

Node<T> *current = itr.currentNode;

if ( List<T>::empty() ) { //empty list

List<T>::first = List<T>::last = p;

return;

}

//assert ( current );

if ( current == 0 ){ //point to end, thus append to list

List<T>::last->next = p;

p->next = 0;

p->prev = List<T>::last;

List<T>::last = p;

return;

}

//otherwise, always insert before

p->next = current;

p->prev = current->prev;

current->prev = p;

current = p->prev;

if ( current != 0 )

current->next = p;

else

List<T>::first = p;

}


void countedList<T>::c_erase (listIterator<T> &start,listIterator<T> &stop)

//remove elements from the range ( before stop )

{

//List is friend of listIterator, so it can access listIterator's

// private or protected data member

Node<T> *p = start.currentNode;

Node<T> *q = p->prev;

Node<T> *stopNode = stop.currentNode;

if ( q == 0 ) { //removing initial portion of list

List<T>::first = stopNode;

if ( stopNode == 0 ) //pointing to end

List<T>::last = 0; //whole list is deleted

else

stopNode->prev = 0;

} else {

q->next = stopNode;

if ( stopNode == 0 )

List<T>::last = q;

else

stopNode->prev = q; // q->prev = q;

}

//now delete the atoms

while ( start != stop ) {

listIterator<T> next = start;

++next;

delete start.currentNode;

start = next;

--size;

}

}

//list_demo1.cpp

/*

Because of the use of template when defining the List and Node classes,

unfortunately, we do need to include the .cpp files here for the

current compilers.

*/

#include <iostream>

#include "list.cpp"

#include "Node.cpp"

#include "countedlist.cpp"

using namespace std;


void print_list( countedList<T> &aList )

{

typename countedList<T>::iterator start, stop;

start = aList.begin(); stop = aList.end();

while ( start != stop ){

cout << *start << ",\t";

++start;

}

cout << endl;

}

int main()

{

typedef double T;

countedList<T> aList; //a list

T n;

while ( true ) {

cout << "Enter a number, -99 to terminate: ";

cin >> n;

if ( n == -99 )

break;

aList.c_push_front( n ); //insert into list at front

} //while

cout << "You have entered the list: " << endl;

print_list( aList );

listIterator<double> itr1;

listIterator<double> itr2;

itr2 = aList.begin();

itr1 = aList.end();

cout<<"The size of the list is: "<<aList.c_size()<<endl;

for(int i=0;i<aList.c_size()-1;i++){

++itr2;

}

cout<<"Deleting one item...\n";

aList.c_erase(itr2, itr1);




++itr2;

}

cout<<"Deleting two items...\n";





++itr2;

}

cout<<"Deleting three items...\n";



cout<<"Adding two items (0's')...\n";

n=0;

aList.c_insert(itr1,n);

itr1 = aList.end();

aList.c_insert(itr1, n);


//++itr2; ++itr2;

//aList.c_erase(itr2, itr1 );

print_list( aList );


return 0;

}

2. ( 15 points )

a) What is the postfix expression of the following?

(a * ( b + c ) + ( b / d ) * a / e

The postfix expression is: a, b, c, +, *, b, d, /, a, *, e, /, +

b) Write a complete program that can parse an arbitrary infix expression consisting of real

numbers, positive and negative, convert it to postfix and evaluate it ( see lab 8 ). Add to your

program a menu that have the following instructions:

(i) c -- clear all values from postfix queue,

(ii) d -- double front value of the postfix queue

Test your implementation with various infix input expressions.

//

//Kendall Small

#ifndef SYMBOL_H

#define SYMBOL_H

#include<string>

#include<queue>

#include<stack>

#include<stdio.h>

#include<ctype.h>


typedef double dType; //Data type: int or double

enum inKind {operate, number}; //input kind

class SYMBOL{

public:

dType num; //stores numbers

inKind kind; //determines number or operator

char operatr; //stores operators

};

void in2postFix(stack<SYMBOL> &ifix, queue<SYMBOL> &pfix);

dType eval (queue<SYMBOL> &post);

#endif

//TOOLS_H

//Kendall Small

#include "symbol.h"

#ifndef TOOLS_H

#define TOOLS_H

void que2stack(queue<SYMBOL> &que, stack<SYMBOL> &s);

void reverse_stack(stack<SYMBOL> &s, stack<SYMBOL> &sr);

bool c_is_an_operator( char c);

void print_que(queue<SYMBOL> q);

void print_stack(stack<SYMBOL> s);

void double_first(queue<SYMBOL> &q);

void clear(queue<SYMBOL> &q);

#endif

//in2postfix.cpp

#include "symbol.h"

int precedence(char c){

switch(c){

case '+':

case '-':

return 1;

case '*':

case '/':

return 2;

}

return 0; //lowest precedence

}

void transfer(stack<SYMBOL> &s, queue<SYMBOL> &q){

q.push(s.top());

s.pop(); //Add top stack elem to queue, then delete

}

void in2postFix(stack<SYMBOL> &ifix, queue<SYMBOL> &pfix){

stack<SYMBOL> opStack; //stack of operators

SYMBOL a;

while(!ifix.empty()){

a=ifix.top(); //get next operator/operand from infix

ifix.pop(); //remove(delete) the top operator/operand

if(a.kind==number){pfix.push(a);} //to postfix queue

else if(opStack.empty()){opStack.push(a);} //to operator stack

else if(a.operatr=='('){opStack.push(a);} //Since ( lowest precedence

else if(a.operatr==')'){ //

while(opStack.top().operatr != '(')

transfer (opStack, pfix);

opStack.pop(); //transfer ( and remove

} else {

while(!opStack.empty()&&precedence(a.operatr)<=precedence(opStack.top().operatr))

transfer(opStack, pfix);

opStack.push(a);

}

}//while

while(!opStack.empty())

transfer(opStack, pfix);

}

//eval.cpp

//Kendall Small

#include "tools.h"

#include "symbol.h"

//Evaluate postfix expression

dType eval(queue<SYMBOL> &post){

stack<SYMBOL> eval;

dType a, b, ans;

char binaryOp; //binary operators +,=,*,/

SYMBOL symPop, symEval; //symbols popped element and evaluate

while(!post.empty()){

symPop=post.front();

post.pop();

if(symPop.kind==number)

eval.push(symPop); //save numbers until operator is found

else {

symEval = eval.top(); //gets a number to evaluate

a = symEval.num;

eval.pop();

symEval=eval.top(); //another number to evaluate

b = symEval.num;

eval.pop();

binaryOp=symPop.operatr;

switch(binaryOp){

case '-':

ans = b - a;

break;

case '+':

ans=b+a;

break;

case '/':

ans = b/a;

break;

case '*':

ans=b*a;

break;

}

symEval.num=ans; //answer goes back on until queue empty

eval.push(symEval);

}

}

symEval=eval.top();

return symEval.num;

}

//tools.cpp

//Kendall Small

#include "symbol.h"

#include "tools.h"

#include<iostream>


void double_first(queue<SYMBOL> &q){

SYMBOL temp = q.front();

if(q.front().operatr == operate){

cout<<"Cannot double an operator.\n";

}

else

q.front().num *= 2;

}

void clear(queue<SYMBOL> &q){

while(!q.empty()){

q.pop();

}

}

void que2stack(queue<SYMBOL> &q, stack<SYMBOL> &s){

SYMBOL sym;

while(!q.empty()){

sym=q.front();

q.pop();

s.push(sym);

}

}

void reverse_stack(stack<SYMBOL> &s, stack<SYMBOL> &sr){

SYMBOL sym;

while(!s.empty()){

sym=s.top();

sr.push(sym);

s.pop();

}

}

bool c_is_an_operator(char c){

if(c=='(' || c==')' || c=='+' || c=='*' || c=='/' || c=='-')

return true;

return false;

}

void print_que(queue<SYMBOL> q){

while(!q.empty()){

SYMBOL s=q.front();

q.pop();

if(s.kind==number)

cout<<s.num<<" ";

else

cout<<s.operatr<< " ";

}

cout<<endl;

}

void print_stack(stack<SYMBOL> s){

while(!s.empty()){

SYMBOL a= s.top();

s.pop();

if(a.kind==number)

cout<<a.num<<" ";

else

cout<<a.operatr<<" ";

}

cout<<endl;

}

//Infix to postfix program main.cpp

//Kendall Small

#include "symbol.h"

#include "tools.h"

#include <iostream>


int main() {

stack<SYMBOL> sym, s1;

queue<SYMBOL> que;

SYMBOL s;

char c, select, again;

double x, xInt, xFrac, fracD;

int dotFlag, readFlag, numFlag, sign, lpFlag;

dType ans;

do{

cout<<"Enter an infix expression using real numbers\n";

cout<<"Every negative number after the first must be inside parenthesis\n";

cout<<"For example: -1*(3 + (-4))\n";

x=xInt=xFrac=0;

fracD=0.1;

dotFlag=numFlag=0;

lpFlag=0;

while((c=getchar())==' ');

if(c=='-'){

sign=-1;

c=getchar();

} else

sign=1;

while(true){

if(c=='.') dotFlag=1;

if(isdigit(c)){

if(!dotFlag)

xInt=xInt*10+(c-'0');

else {

xFrac+=(c-'0')*fracD;

fracD*=0.1;

}

numFlag=1;

}else

if((numFlag==1)&&(c!='.')){

x=xInt+xFrac;

s.num=x*sign;

s.kind=number;

sym.push(s);

sign=1;

fracD=0.1;

x=xInt=xFrac=0.0;

dotFlag=numFlag=0;

}else if(c=='('){

while((c=getchar())==' ');

if(c=='-'){

lpFlag=1;

sign=-1;

c=getchar();

continue;

}else{

ungetc(c,stdin);

c='(';

}

}//(c=='(')

if(c_is_an_operator(c)){

if(!lpFlag){

s.operatr=c;

s.kind=operate;

sym.push(s);

}

lpFlag=0;

}

if(c=='\n')break;

c=getchar();

}//while(true)

reverse_stack(sym, s1);

cout<<"The infix expression you entered was: ";

print_stack(s1);

in2postFix(s1, que);

cout<<"Please select an option: \n";

cout<<"Enter: c -- clear all values from postfix queue (start again)\n";

cout<<"Enter: d -- double the value in the first spot of the postfix queue\n";

cout<<"Anything else will finish the program as usual, giving output.\n";

cin>>select;

switch(select){

case 'c':

case 'C':{

clear(que);

cout<<"Printing empty postfix queue: ";

print_que(que);

cout<<"If nothing printed then postfix queue successfully cleared.\n";

break;

}

case 'd':

case 'D':{

cout<<"Postfix queue before: \n";

print_que(que);

double_first(que);

cout<<"Postfix expression after doubling: \n";

print_que(que);

cout<<"The answer is: "<<eval(que)<<endl;

break;

}

default:{

cout<<"After conversion the postfix expression is: ";

print_que(que);

cout<<"The answer is: "<<eval(que)<<endl;

break;

}

}//switch

cout<<"Again? (Y/N)\n";

cin>>again;

cin.clear(); cin.ignore(INT_MAX,'\n');

}while(again == 'Y' || again=='y');

return 0;

}

3. ( 10 points ) Write a program that makes use of the functions of bitset to do the following:

a. it asks for an integer as input, prints out its value in 24-bit binary form and in 8-hex-digit

form;

b. it asks for a binary value as input and prints out its decimal value; it should be able to

handle binary values up to 32-bit.

//Bitset

//Kendall Small

#include<iostream>

#include<stdio.h>

#include<stdlib.h>

#include<string>

#include<bitset>


int main() {

int toBinary, temp;

long fromBinary;

char hex[240];

string binary;

cout<<"Please enter an integer to be converted to 24-bit binary: \n";

cin>>toBinary;

bitset<24> intSet(toBinary);

cout<<"The integer "<<toBinary<<" is equal to "<<intSet<<" in binary form.\n";

bitset<32> hexSet(toBinary);

cout<<"The integer "<<toBinary<<" is equal to hex: ";//<<hex<<" in hex form.\n";

for(int i=31;i>=0;i-=4){

bitset<4> t;

for(int j=i;j>(i-4);j--){

t[j%4]=hexSet[j];

}

fromBinary=t.to_ulong();

itoa(fromBinary,hex, 16);

cout<<hex<<" ";

}

cout<<endl<<endl;

cin.clear();

cin.ignore(INT_MAX,'\n');

cout<<"Enter a string of binary up to 32 bits long: \n";

getline(cin, binary);

bitset<32> stringSet(binary);

fromBinary = stringSet.to_ulong();

cout<<"The binary "<<binary<<" is equal to "<<fromBinary<<" in base 10.\n";

return 0;

}

4. ( 10 points ) Write a program that makes use of a backtrack algorithm to see if you can put 10

queens on a hypothetical 10x10 square chess board with no queen threatening any other. If

there's a solution, prints out the solution.

//Backtracking algorithm

//Kendall Small

#include <iostream>


class nQueen{

public:

nQueen();

void clear();

void printBoard();

void setPiece(int col, bool &verdict);

bool answer(int);

private:

int n; //size

char board[10][10];

void set(int col, int row){board[row][col]='X';}

void get(int col, int row){board[row][col]='-';}

bool danger(int col, int row);

};

nQueen::nQueen(){

n=10; //change size here as well

for(int i=0;i<n;i++){

for(int j=0;j<n;j++){

board[i][j] = '-';

}

}

}

void nQueen::printBoard(){

for(int i=0;i<n;i++){

for(int j=0;j<n;j++){

cout<<board[i][j]<<" ";

}

cout<<"\n";

}

}

bool nQueen::danger(int r, int c){

int a, b;

for(a=0;a<c;a++){

if(board[r][a]=='X')

return true;

}

for(a=r, b=c;a>=0 && b>=0;a--, b--){

if(board[a][b]=='X')

return true;

}

for(a=r, b=c;b>=0 && a<n;a++, b--){

if(board[a][b]=='X')

return true;

}

return false;

}

bool nQueen::answer(int col){

if(col>=n){

return true;

}

for(int a=0;a<n;a++){

if(danger(a, col)==false){

set(col, a);

//board[a][col]= 'X';

if(answer(col+1)==true)

return true;

get(col, a);

//board[a][col]='-';

}

}

return false;

}

int main() {

nQueen ten;

bool verdict;

verdict = ten.answer(0);

if(verdict==true)

ten.printBoard();

else

cout<<"There is no solution.\n";

return 0;

}

Documents

Kendall Smallcse.csusb.edu/tongyu/studentwork/cs330/hw/hw3_dir/Small... · 2016. 11. 2. · Kendall Small Professor Yu CSE 330 Homework 3 I believe I deserve full credit (55 points)