439 lines
13 KiB
C++
439 lines
13 KiB
C++
//Derek McQuay 647465151 CS 235 Fall 2012 midterm 1
|
|
#include "polylist.h"
|
|
|
|
polylist::polylist(): head(NULL) {}
|
|
polylist::~polylist() {clear();}
|
|
|
|
void polylist::insert(string term) {
|
|
vector<string> v = parse_expression(term);
|
|
if(!is_valid(v)) {
|
|
return;
|
|
}
|
|
if(v.size() == 1) { //expression of the form x
|
|
if(v[0][0] == '-') {
|
|
insertTail(0, -1, v[0][1]);
|
|
}
|
|
else {
|
|
insertTail(0, 1, v[0][0]);
|
|
}
|
|
}
|
|
if(v.size() == 2) { // expresion of the form 2 x
|
|
int exp = atoi(v[0].c_str());
|
|
insertTail(0, exp, v[1][0]);
|
|
}
|
|
if(v.size() == 3) { // expression of the form x ^ 4
|
|
int exp = atoi(v[2].c_str());
|
|
int after_exp = 0;
|
|
if(exp == 0) {
|
|
if(v[0][0] == '-') {
|
|
insertTail(exp, -1, v[0][0]);
|
|
}
|
|
else {
|
|
insertTail(exp, 1, v[0][0]);
|
|
}
|
|
}
|
|
node* node_ptr = head;
|
|
while(node_ptr != NULL) {
|
|
if(node_ptr->exponent <= exp) {
|
|
after_exp++;
|
|
break;
|
|
}
|
|
after_exp++;
|
|
node_ptr = node_ptr->next;
|
|
}
|
|
string before = at(after_exp - 1);
|
|
vector<string> previous_vector = parse_expression(before);
|
|
if(previous_vector.size() == 1) {
|
|
if(node_ptr == head) {
|
|
if(node_ptr == head && size() == 0) {
|
|
if(v[0][0] == '-') {
|
|
insertHead(exp, -1, v[0][0]);
|
|
}
|
|
else {
|
|
insertHead(exp, 1, v[0][0]);
|
|
}
|
|
}
|
|
else if(node_ptr->exponent == exp) {
|
|
node_ptr->coefficient += 1;
|
|
if(node_ptr->coefficient == 0) {
|
|
remove(exp);
|
|
}
|
|
}
|
|
else {
|
|
if(v[0][0] == '-') {
|
|
insertHead(exp, -1, v[0][1]);
|
|
}
|
|
else {
|
|
insertHead(exp, 1, v[0][0]);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
node_ptr->coefficient += 1;
|
|
if(node_ptr->coefficient == 0) {
|
|
remove(exp);
|
|
}
|
|
}
|
|
}
|
|
if(previous_vector.size() == 2) {
|
|
if(v[0][0] == '-') {
|
|
insertHead(exp, -1, v[0][1]);
|
|
}
|
|
else {
|
|
insertHead(exp, 1, v[0][0]);
|
|
}
|
|
}
|
|
if(previous_vector.size() == 3) {
|
|
int insertionNodeExponent = atoi(previous_vector[2].c_str());
|
|
if(insertionNodeExponent == exp) {
|
|
node* node_ptr2 = head;
|
|
while(node_ptr2 != NULL) {
|
|
if(node_ptr2->exponent == exp) {
|
|
if(v[0][0] == '-') {
|
|
node_ptr2->coefficient -= 1;
|
|
}
|
|
else {
|
|
node_ptr2->coefficient += 1;
|
|
}
|
|
if(node_ptr2->coefficient == 0) {
|
|
remove(exp);
|
|
}
|
|
}
|
|
node_ptr2 = node_ptr2->next;
|
|
}
|
|
}
|
|
else{
|
|
if(v[0][0] == '-') {
|
|
insertAfter(exp, -1, v[0][1], insertionNodeExponent);
|
|
}
|
|
else {
|
|
insertAfter(exp, 1, v[0][0], insertionNodeExponent);
|
|
}
|
|
}
|
|
}
|
|
if(previous_vector.size() == 4) {
|
|
int insertionNodeExponent = atoi(previous_vector[3].c_str());
|
|
if(insertionNodeExponent == exp) {
|
|
node* node_ptr2 = head;
|
|
while(node_ptr2 != NULL) {
|
|
if(node_ptr2->exponent == exp) {
|
|
node_ptr2->coefficient += 1;
|
|
if(node_ptr2->coefficient == 0) {
|
|
remove(exp);
|
|
}
|
|
}
|
|
node_ptr2 = node_ptr2->next;
|
|
}
|
|
}
|
|
else {
|
|
if(v[0][0] == '-') {
|
|
insertAfter(exp, -1, v[0][1], insertionNodeExponent);
|
|
}
|
|
else {
|
|
insertAfter(exp, 1, v[0][0], insertionNodeExponent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(v.size() == 4) { //expression of the form "2 x ^ 3"
|
|
int coef = atoi(v[0].c_str());
|
|
int exp = atoi(v[3].c_str());
|
|
int after_exp = 0;
|
|
node* node_ptr = head;
|
|
if(exp == 0) {
|
|
insertTail(exp, coef, v[1][0]);
|
|
return;
|
|
}
|
|
while(node_ptr != NULL) {
|
|
if(node_ptr->exponent <= exp) {
|
|
break;
|
|
}
|
|
after_exp++;
|
|
node_ptr = node_ptr->next;
|
|
}
|
|
string before = at(after_exp - 1);
|
|
vector<string> previous_vector = parse_expression(before);
|
|
if(previous_vector.size() == 1) {
|
|
if(node_ptr == head) {
|
|
if(node_ptr == head && size() == 0) {
|
|
insertHead(exp, coef, v[1][0]);
|
|
}
|
|
else if(node_ptr->exponent == exp) {
|
|
node_ptr->coefficient += coef;
|
|
if(node_ptr->coefficient == 0) {
|
|
remove(exp);
|
|
}
|
|
}
|
|
else {
|
|
insertHead(exp, coef, v[1][0]);
|
|
}
|
|
}
|
|
else {
|
|
node_ptr->coefficient += coef;
|
|
if(node_ptr->coefficient == 0) {
|
|
remove(exp);
|
|
}
|
|
}
|
|
}
|
|
if(previous_vector.size() == 2) {
|
|
insertHead(exp, coef, v[1][0]);
|
|
}
|
|
if(previous_vector.size() == 3) {
|
|
int insertionNodeExponent = atoi(previous_vector[2].c_str());
|
|
if(node_ptr->exponent == exp) {
|
|
node* node_ptr2 = head;
|
|
while(node_ptr2 != NULL) {
|
|
if(node_ptr2->exponent == exp) {
|
|
node_ptr2->coefficient += coef;
|
|
if(node_ptr2->coefficient == 0) {
|
|
remove(exp);
|
|
}
|
|
}
|
|
node_ptr2 = node_ptr2->next;
|
|
}
|
|
}
|
|
else{
|
|
insertAfter(exp, coef, v[1][0], insertionNodeExponent);
|
|
}
|
|
}
|
|
if(previous_vector.size() == 4) {
|
|
int insertionNodeExponent = atoi(previous_vector[3].c_str());
|
|
if(node_ptr == NULL) {
|
|
insertTail(exp, coef, v[1][0]);
|
|
}
|
|
else {
|
|
if(node_ptr->exponent == exp) {
|
|
node* node_ptr2 = head;
|
|
while(node_ptr2 != NULL) {
|
|
if(node_ptr2->exponent == exp) {
|
|
node_ptr2->coefficient += coef;
|
|
if(node_ptr2->coefficient == 0) {
|
|
remove(exp);
|
|
}
|
|
}
|
|
node_ptr2 = node_ptr2->next;
|
|
}
|
|
}
|
|
else {
|
|
insertAfter(exp, coef, v[1][0], insertionNodeExponent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void polylist::clear() {
|
|
node* node_ptr = head;
|
|
while(head) {
|
|
node_ptr = head;
|
|
head = head->next;
|
|
delete node_ptr;
|
|
}
|
|
}
|
|
|
|
string polylist::at(int index) {
|
|
if(index < 0) {
|
|
return "invalid";
|
|
}
|
|
if(size() <= index) {
|
|
return "invalid";
|
|
}
|
|
node* node_ptr = head;
|
|
for(int i = 0; i < index; i++){
|
|
node_ptr = node_ptr->next;
|
|
}
|
|
if(head == NULL)
|
|
return "invalid";
|
|
stringstream s;
|
|
s << *node_ptr;
|
|
return s.str();
|
|
}
|
|
|
|
int polylist::size() {
|
|
int size_of_list = 0;
|
|
node* node_ptr = head;
|
|
while(node_ptr != NULL) {
|
|
size_of_list++;
|
|
node_ptr = node_ptr->next;
|
|
}
|
|
return size_of_list;
|
|
}
|
|
|
|
string polylist::printList() {
|
|
stringstream s;
|
|
if(head == NULL)
|
|
return "";
|
|
node* node_ptr = head;
|
|
while(node_ptr != NULL) {
|
|
if(node_ptr->next == NULL) {
|
|
s << *node_ptr;
|
|
return s.str();
|
|
}
|
|
else {
|
|
s << *node_ptr << " + ";
|
|
node_ptr = node_ptr->next;
|
|
}
|
|
}
|
|
return s.str();
|
|
}
|
|
|
|
void polylist::remove(int exponent) {
|
|
node* node_ptr = head;
|
|
if(node_ptr->exponent == exponent) {
|
|
node* ptr = head;
|
|
head = head->next;
|
|
delete ptr;
|
|
return;
|
|
}
|
|
while(node_ptr != NULL) {
|
|
if(node_ptr->next == NULL)
|
|
return;
|
|
if(node_ptr->next->exponent == exponent) {
|
|
node* ptr = node_ptr->next;
|
|
node_ptr->next = node_ptr->next->next;
|
|
delete ptr;
|
|
}
|
|
node_ptr = node_ptr->next;
|
|
}
|
|
}
|
|
|
|
void polylist::insertHead(int exponent, int coefficient, char variable) {
|
|
head = new node(exponent, coefficient, variable, head);
|
|
}
|
|
|
|
void polylist::insertTail(int exponent, int coefficient, char variable) {
|
|
if(head == NULL) {
|
|
insertHead(exponent, coefficient, variable);
|
|
return;
|
|
}
|
|
node* node_ptr = head;
|
|
while(node_ptr != NULL) {
|
|
if(node_ptr->next == NULL) {
|
|
if(node_ptr->exponent == exponent) {
|
|
node_ptr->coefficient += coefficient;
|
|
if(node_ptr->coefficient == 0) {
|
|
remove(exponent);
|
|
}
|
|
}
|
|
else{
|
|
node_ptr->next = new node(exponent, coefficient, variable, NULL);
|
|
break;
|
|
}
|
|
}
|
|
node_ptr = node_ptr->next;
|
|
}
|
|
}
|
|
|
|
void polylist::insertAfter(int exponent, int coefficient, char variable, int insertionNodeExponent) {
|
|
node* node_ptr = head;
|
|
while(node_ptr != NULL) {
|
|
if(node_ptr->exponent == insertionNodeExponent) {
|
|
if(head == node_ptr) {
|
|
insertHead(exponent, coefficient, variable);
|
|
}
|
|
else{
|
|
node* temp = new node(exponent, coefficient, variable, NULL);
|
|
temp->next = node_ptr->next;
|
|
node_ptr->next = temp;
|
|
}
|
|
}
|
|
node_ptr = node_ptr->next;
|
|
}
|
|
}
|
|
|
|
bool is_valid(vector<string> expression) {
|
|
if(expression.empty()) { //if expression is size 0
|
|
return false;
|
|
}
|
|
if(expression.size() == 1) { //if expression is size one. only case if "x"
|
|
if(expression[0][0] == '-') {
|
|
if(expression[0] == "-x")
|
|
return true;
|
|
if(!isalpha(expression[0][1]) or expression[0].size() > 1) {
|
|
return false;
|
|
}
|
|
}
|
|
else if(!isalpha(expression[0][0]) or expression[0].size() > 1) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if(expression.size() == 2) { //if expression is size two, only case is of form "2 x"
|
|
for(unsigned int i = 0; i < expression[0].size(); i++) {
|
|
if(expression[0][0] != '-') {
|
|
if(!isdigit(expression[0][i])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if(!isalpha(expression[1][0]) or expression[1].size() > 1) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if(expression.size() == 3) { //if expression is size three, only case is of form "x ^ 1"
|
|
if(expression[0][0] == '-') {
|
|
if(expression[0] == "-x")
|
|
return true;
|
|
if(!isalpha(expression[0][1]) or expression[0].size() > 1) {
|
|
return false;
|
|
}
|
|
}
|
|
else if(!isalpha(expression[0][0]) or expression[0].size() > 1) {
|
|
return false;
|
|
}
|
|
if(expression[1] != "^") {
|
|
return false;
|
|
}
|
|
for(unsigned int i = 0; i < expression[2].size(); i++) {
|
|
if(!isdigit(expression[2][i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if(expression.size() == 4) { //if expression is size four, only case is of form "1 x ^ 1"
|
|
for(unsigned int i = 0; i < expression[0].size(); i++) {
|
|
if(expression[0][0] != '-') {
|
|
if(!isdigit(expression[0][i])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if(!isalpha(expression[1][0]) or expression[1].size() > 1) {
|
|
return false;
|
|
}
|
|
if(expression[2] != "^") {
|
|
return false;
|
|
}
|
|
for(unsigned int i = 0; i < expression[3].size(); i++) {
|
|
if(!isdigit(expression[3][i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
vector<string> parse_expression(string expression) { //parses expression with " " being the delimeter
|
|
vector<string> results;
|
|
string s;
|
|
for(unsigned int i = 0; i < expression.length(); i++) {
|
|
char c = expression[i];
|
|
if(c != ' ') {
|
|
s += c;
|
|
}
|
|
else {
|
|
if(s != "") {
|
|
results.push_back(s);
|
|
s.clear();
|
|
}
|
|
}
|
|
}
|
|
if(s != "") {
|
|
results.push_back(s);
|
|
}
|
|
return results;
|
|
}
|