BSTNodeAddr searchFractionBSTYourName(BSTNodeAddr bstNodeAddr) {
  BSTNodeAddr bstNodeAddr1 = 0;
  FracAddr fracAddr = 0;

  printf("\nEnter Fraction you would like to search for\n");
  fracAddr = createFraction();
  bstNodeAddr1 = bstNodeAddr;
  while (bstNodeAddr1) {
    if (bstNodeAddr1->FracAddr->num * fracAddr->denom > fracAddr->num * bstNodeAddr1->FracAddr->denom) {
      bstNodeAddr1 = bstNodeAddr1->left;
    }
    else if (bstNodeAddr1->FracAddr->num * fracAddr->denom < fracAddr->num * bstNodeAddr1->FracAddr->denom) {
      bstNodeAddr1 = bstNodeAddr1->right;
    }
    else if (bstNodeAddr1->FracAddr->num * fracAddr->denom == fracAddr->num * bstNodeAddr1->FracAddr->denom) {
      printf("\nFraction Node found\n");
      return bstNodeAddr1;
    }
  }
  printf("\nFraction is not in tree\n");

  return 0;
}
예제 #2
0
int evaluate(FILE *fout, const char *expr)
{
    //parse the expression
    tokenNode *infix = createTokenNode();
    addAfterTokenNode(infix);
    if (!parse(expr, infix)) {
        fprintf(stderr, "Parsing failed\n");
        return 0;
    }

    //a flag for the +, -
    int previsnum = 0;

    initOperPriority();

    //calculate
    for (tokenNode *i = infix->next; i->token != NULL; i = i->next) {

        char *endptr = NULL;
        long long thisNumber = createNumber(i->token, &endptr);
        if (readNumErr) {
            fprintf(stderr, "Failed reading a number\n");
            freeAllTokenNodes(infix);
            return 0;
        }

        if (endptr != i->token) {

            pushNum(createFraction(thisNumber, 1));
            previsnum = 1;

        } else {

            char oper = i->token[0];
            switch (oper) {

                case '_':
                    pushNum(lastResult);
                    previsnum = 1;
                    break;

                case '(':
                    pushOper(oper);
                    previsnum = 0;
                    break;

                case ')':
                    if(!calculatingCycle()) {
                        fprintf(stderr, "Calculating failed\n");
                        freeAllTokenNodes(infix);
                        return 0;
                    }

                    //pop the (
                    popOper();
                    previsnum = 0;
                    break;

                default:

                    //dealing with the signs
                    if (!previsnum) {
                        if (oper == '+') {
                            oper = 'P';
                        } else if (oper == '-') {
                            oper = 'N';
                        }
                    }
                    
                    //there is an operator at the top of the stack
                    if (operNum) {

                        //compare the priorities of oper and topOper
                        if (operPriority[(int)oper] < operPriority[(int)getTopOper()]) {

                            //pop all and calc
                            if(!calculatingCycle()) {
                                fprintf(stderr, "Calculating failed\n");
                                freeAllTokenNodes(infix);
                                return 0;
                            }
                            pushOper(oper);

                        } else if (oper != 'P' && oper != 'N' && operPriority[(int)oper] == operPriority[(int)getTopOper()]) {

                            //pop one and calc to ensure the calulation is done l2r
                            //the P and N (aka +, -) are done r2l
                            if(!calculate()) {
                                fprintf(stderr, "Calculating failed\n");
                                freeAllTokenNodes(infix);
                                return 0;
                            }
                            pushOper(oper);

                        } else {
                            pushOper(oper);
                        }

                    //the operator stack is empty
                    } else {
                        pushOper(oper);
                    }
                    previsnum = 0;
                    break;
            }
        }
    }

    //pop the left operators and calc
    if(!calculatingCycle()) {
        fprintf(stderr, "Calculating failed\n");
        freeAllTokenNodes(infix);
        return 0;
    }

    //pop the result
    Fraction *result = NULL;
    switch (numNum) {
        case 0:
            fprintf(stderr, "Get no result\n");
            freeAllTokenNodes(infix);
            return 0;
        case 1:
            result = popNum();
            lastResult = *result;
            fprintf(fout, "%lld", result->numerator);
            if (result->denominator != 1) {
                fprintf(fout, "/%lld\n", result->denominator);
            } else {
                fputc('\n', fout);
            }
            break;
        default:
            fprintf(stderr, "Get multiple results\n");
            freeAllTokenNodes(infix);
            return 0;
    }

    freeAllTokenNodes(infix);

    return 1;
}
예제 #3
0
int calculate()
{
    Fraction *a = NULL, *b = NULL, c = createFraction(0, 0);

    switch (popOper()) {

        case '+':
            checkNumStack(2);
            b = popNum();
            a = popNum();

            c.numerator = a->numerator * b->denominator + b->numerator * a->denominator;
            c.denominator = a->denominator * b->denominator;

            if (c.denominator != 1 && c.denominator != 0) {
                reduce(&c);
            }
            pushNum(c);
            break;

        case '-':
            checkNumStack(2);
            b = popNum();
            a = popNum();

            c.numerator = a->numerator * b->denominator - b->numerator * a->denominator;
            c.denominator = a->denominator * b->denominator;

            if (c.denominator != 1 && c.denominator != 0) {
                reduce(&c);
            }
            pushNum(c);
            break;

        case '*':
            checkNumStack(2);
            b = popNum();
            a = popNum();

            c.numerator = a->numerator * b->numerator;
            c.denominator = a->denominator * b->denominator;

            if (c.denominator != 1 && c.denominator != 0) {
                reduce(&c);
            }
            pushNum(c);
            break;

        case '/':
            checkNumStack(2);
            b = popNum();
            a = popNum();

            c.numerator = a->numerator * b->denominator;
            c.denominator = a->denominator * b->numerator;

            if (c.denominator != 1 && c.denominator != 0) {
                reduce(&c);
            }
            pushNum(c);
            break;

        case 'P':
            checkNumStack(1);

            break;

        case 'N':
            checkNumStack(1);
            a = getTopNum();

            a->numerator *= -1;
            reduce(a);
            break;
    }

    return 1;
}
예제 #4
0
void menu() {
	int option;
	int frOption;
	frPtr lOp = 0;
	frPtr rOp = 0;
	
	do {
		printf("\nMENU : Fraction -- Tyler Hill"\
			"\n1. Creating/Updating"\
			"\n2. Adding"\
			"\n3. Subtracting"\
			"\n4. Multiplying"\
			"\n5. Dividing"\
			"\n6. Displaying"\
			"\n7. Quit");
		printf("\nEnter the option (1 or 2): ");
		scanf("%d", &option);

		switch (option) {
		case 1:
				do {
					printf("\nMENU : Creating/Updating"\
						"\n1. Left Operand"\
						"\n2. Right Operand"\
						"\n3. Both Operands"\
						"\n4. Displaying Current Operands"\
						"\n5. Return");
					printf("\nEnter the option: ");
					scanf("%d", &frOption);
					switch(frOption) {
						case 1:
							printf("\nLeft Operand: ");
							lOp = reduceFraction(createFraction());
							break;
						case 2:
							printf("\nRight Operand: ");
							rOp = reduceFraction(createFraction());
							break;
						case 3:
							printf("\nLeft Operand: ");
							lOp = reduceFraction(createFraction());
							printf("\nRight Operand: ");
							rOp = reduceFraction(createFraction());
							break;
						case 4:
							printf("");
							printf("\nLeft Operand:");
							displayFraction(lOp);
							printf("");
							printf("\nRight Operand:");
							displayFraction(rOp);
							break;
						case 5:
							break;
					}
				} while (frOption != 5);
			break;
		case 2:
			break;
		case 3:
			break;
		case 4:
			break;
		case 5:
			break;
		case 6:
			break;
		case 7:
			break;
		default:
			printf("\nYou should not be in this class!\n");
		}
	} while (option != 7);
}
int removeFractionBSTYourname(BSTAddr bstAddr) {
  BSTNodeAddr bstNodeAddr1 = 0;
  BSTNodeAddr bstNodeAddr2 = 0;
  BSTNodeAddr bstNodeAddr3 = 0;
  BSTNodeAddr bstNodeAddr4 = 0;
  int direction = 10;

  FracAddr fracAddr = 0;
  printf("\nEnter Fraction you would like to remove\n");
  fracAddr = createFraction();
  bstNodeAddr1 = *bstAddr;
  while (bstNodeAddr1) {
    if (bstNodeAddr1->FracAddr->num * fracAddr->denom > fracAddr->num * bstNodeAddr1->FracAddr->denom) {
      bstNodeAddr2 = bstNodeAddr1;
      bstNodeAddr1 = bstNodeAddr1->left;
      direction = 0;
    }
    else if (bstNodeAddr1->FracAddr->num * fracAddr->denom < fracAddr->num * bstNodeAddr1->FracAddr->denom) {
      bstNodeAddr2 = bstNodeAddr1;
      bstNodeAddr1 = bstNodeAddr1->right;
      direction = 1;
    }
    else if (bstNodeAddr1->FracAddr->num * fracAddr->denom == fracAddr->num * bstNodeAddr1->FracAddr->denom) {
      if (bstNodeAddr1->left == 0 && bstNodeAddr1->right == 0) {
        if (direction == 10) {
          *bstAddr = 0;
        }
        else if (direction == 1) {
          bstNodeAddr2->right = 0;
          free(bstNodeAddr1);
          bstNodeAddr1 = 0;
        }
        else {
          bstNodeAddr2->left = 0;
          free(bstNodeAddr1);
          bstNodeAddr1 = 0;
        }
        return 1;
      }
      else if (bstNodeAddr1->left == 0 && bstNodeAddr1->right != 0 || bstNodeAddr1->left != 0 && bstNodeAddr1->right ==0) {
        if (bstNodeAddr1->left) {
          if (direction == 1) {
            bstNodeAddr2->right = bstNodeAddr1->left;
            free(bstNodeAddr1);
            bstNodeAddr1 = 0;
          }
          else if (direction = 10) {
            bstNodeAddr2 = bstNodeAddr1->left;
            (*bstAddr)->FracAddr->num = bstNodeAddr2->FracAddr->num;
            (*bstAddr)->FracAddr->denom = bstNodeAddr2->FracAddr->denom;
            (*bstAddr)->left = 0;
          }
          else {
            bstNodeAddr2->left = bstNodeAddr1->left;
            free(bstNodeAddr1);
            bstNodeAddr1 = 0;
          }
        }
        else if (bstNodeAddr1->right) {
          if (direction == 1) {
            bstNodeAddr2->right = bstNodeAddr1->right;
            free(bstNodeAddr1);
            bstNodeAddr1 = 0;
          }
          else if (direction = 10) {
            bstNodeAddr2 = bstNodeAddr1->right;
            (*bstAddr)->FracAddr->num = bstNodeAddr2->FracAddr->num;
            (*bstAddr)->FracAddr->denom = bstNodeAddr2->FracAddr->denom;
            (*bstAddr)->right = 0;
          }
          else {
            bstNodeAddr2->left = bstNodeAddr1->right;
            free(bstNodeAddr1);
            bstNodeAddr1 = 0;
          }
        }
        return 1;
      }
      else if (bstNodeAddr1->left != 0 && bstNodeAddr1->right !=0) {
        bstNodeAddr2 = bstNodeAddr1;
        bstNodeAddr3 = bstNodeAddr1->right;
        if (bstNodeAddr3->left == 0) {
          (*bstAddr)->FracAddr->num = bstNodeAddr3->FracAddr->num;
          (*bstAddr)->FracAddr->denom = bstNodeAddr3->FracAddr->denom;
          (*bstAddr)->right = 0;
          return 1;
        }
        else {
          while (bstNodeAddr3) {
            bstNodeAddr4 = bstNodeAddr2;
            bstNodeAddr2 = bstNodeAddr3;
            bstNodeAddr3 = bstNodeAddr3->left;
          }
          bstNodeAddr1->FracAddr->num = bstNodeAddr2->FracAddr->num;
          bstNodeAddr1->FracAddr->denom = bstNodeAddr2->FracAddr->denom;
          bstNodeAddr4->left = 0;
          return 1;
        }
      }

    }
  }
  printf("\nFraction is not in tree\n");
  return 0;
}