From 696f985995918d7d67523f2f35685d3e2498bc00 Mon Sep 17 00:00:00 2001 From: Artem Date: Fri, 4 Nov 2022 22:33:54 +0300 Subject: [PATCH 1/7] =?UTF-8?q?=D0=9D=D0=B0=D1=87=D0=B0=D0=BB=20=D1=80?= =?UTF-8?q?=D0=B0=D0=B1=D0=BE=D1=82=D1=83=20=D1=81=20=D0=B4=D0=B5=D1=80?= =?UTF-8?q?=D0=B5=D0=B2=D1=8C=D1=8F=D0=BC=D0=B8=20=D0=B8=20=D1=84=D0=B0?= =?UTF-8?q?=D0=B9=D0=BB=D0=BE=D0=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- parsingTree/parsingTree/main.c | 42 ++++++++++++++++++++++++++++++++++ parsingTree/parsingTree/tree.c | 27 ++++++++++++++++++++++ parsingTree/parsingTree/tree.h | 8 +++++++ 3 files changed, 77 insertions(+) create mode 100644 parsingTree/parsingTree/main.c create mode 100644 parsingTree/parsingTree/tree.c create mode 100644 parsingTree/parsingTree/tree.h diff --git a/parsingTree/parsingTree/main.c b/parsingTree/parsingTree/main.c new file mode 100644 index 0000000..507fe25 --- /dev/null +++ b/parsingTree/parsingTree/main.c @@ -0,0 +1,42 @@ +#include "tree.h" +#include +#include +#include +#include + +bool readFromFileToTree(char fileName[], Tree* tree) { + FILE* file = fopen(fileName, "r"); + if (file == NULL) { + printf(" !"); + return false; + } +} + +bool connectingFunction(char fileName[]) { + Tree* tree = createTree(); +} + +bool test() { + return true; +} + +int main() { + setlocale(LC_ALL, "RUS"); + if (test()) { + printf(" !\n"); + } else { + printf("...\n"); + return -1; + } + printf(" , 100 \n"); + char fileName[100] = { '\0' }; + int checkScan = scanf("%s", &fileName); + while (checkScan != 1) { + while (getchar() != '\n') { + } + + printf("..."); + checkScan = scanf("%s", &fileName); + } + +} \ No newline at end of file diff --git a/parsingTree/parsingTree/tree.c b/parsingTree/parsingTree/tree.c new file mode 100644 index 0000000..ab56f71 --- /dev/null +++ b/parsingTree/parsingTree/tree.c @@ -0,0 +1,27 @@ +#include "tree.h" +#include + +typedef struct Value { + int number; + char symbol; +} Value; + +typedef struct Node { + Value value; + Node* right; + Node* left; +} Node; + +typedef struct Tree { + Node* root; +} Tree; + +Tree* createTree(void) { + Tree* tree = calloc(1, sizeof(tree)); + return tree; +} + +Node* createNode(Tree* tree) { + Node* temp = calloc(1, sizeof(Node)); + return temp; +} \ No newline at end of file diff --git a/parsingTree/parsingTree/tree.h b/parsingTree/parsingTree/tree.h new file mode 100644 index 0000000..fe4a3ed --- /dev/null +++ b/parsingTree/parsingTree/tree.h @@ -0,0 +1,8 @@ +#ifndef TREE_H +#define TREE_H + +typedef struct Tree Tree; + +Tree* createTree(void); + +#endif From 392f5fab58ddd0d3c7d7ce2e01b851e5fd9d7237 Mon Sep 17 00:00:00 2001 From: Artem Date: Sat, 5 Nov 2022 01:34:47 +0300 Subject: [PATCH 2/7] =?UTF-8?q?=D0=A1=D0=B4=D0=B5=D0=BB=D0=B0=D0=BB=20?= =?UTF-8?q?=D0=B7=D0=B0=D0=BF=D0=B8=D1=81=D1=8C=20=D0=B8=D0=B7=20=D1=84?= =?UTF-8?q?=D0=B0=D0=B9=D0=BB=D0=B0=20=D0=B2=20=D0=B4=D0=B5=D1=80=D0=B5?= =?UTF-8?q?=D0=B2=D0=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- parsingTree/parsingTree/main.c | 73 +++++++++++++++++++++++++++- parsingTree/parsingTree/stack.c | 73 ++++++++++++++++++++++++++++ parsingTree/parsingTree/stack.h | 27 +++++++++++ parsingTree/parsingTree/tree.c | 85 ++++++++++++++++++++++++++++++++- parsingTree/parsingTree/tree.h | 9 +++- 5 files changed, 263 insertions(+), 4 deletions(-) create mode 100644 parsingTree/parsingTree/stack.c create mode 100644 parsingTree/parsingTree/stack.h diff --git a/parsingTree/parsingTree/main.c b/parsingTree/parsingTree/main.c index 507fe25..0357782 100644 --- a/parsingTree/parsingTree/main.c +++ b/parsingTree/parsingTree/main.c @@ -4,16 +4,82 @@ #include #include +bool isDigit(char symbol) { + return symbol == '0' || symbol == '1' || symbol == '2' || symbol == '3' || symbol == '4' || symbol == '5' || symbol == '6' || symbol == '7' || symbol == '8' || symbol == '9'; +} + bool readFromFileToTree(char fileName[], Tree* tree) { - FILE* file = fopen(fileName, "r"); + int errorCode = 0; + FILE* file = fopen(fileName, "rt"); if (file == NULL) { printf(" !"); return false; } + char letter = 0; + + while (!feof(file)) { + int symbol = getc(file); + if (symbol == '(' || symbol == ')') { + ungetc("", file); + } + else { + ungetc(symbol, file); + } + + fscanf(file, "%c", &letter); + if (letter == '+' || letter == '*' || letter == '/') { + addToTreeSymbol(tree, letter, &errorCode); + if (errorCode != 0) { + return false; + } + } + if (letter == '-') { + int symbol = getc(file); + if (symbol == ' ') { + addToTreeSymbol(tree, letter, &errorCode); + if (errorCode != 0) { + return false; + } + ungetc(symbol, file); + } else { + ungetc(symbol, file); + fscanf(file, "%c", &letter); + int number = -1 * (int)letter - 48; + fscanf(file, "%c", &letter); + while (isDigit(letter)) { + number *= 10; + number += (int)letter - 48; + fscanf(file, "%c", &letter); + } + addToTreeNumber(tree, number, &errorCode); + if (errorCode != 0) { + return false; + } + } + } + if (isDigit(letter)) { + int number = (int)letter - 48; + fscanf(file, "%c", &letter); + while (isDigit(letter)) { + number *= 10; + number += (int)letter - 48; + fscanf(file, "%c", &letter); + } + addToTreeNumber(tree, number, &errorCode); + if (errorCode != 0) { + return false; + } + } + } + return true; } bool connectingFunction(char fileName[]) { Tree* tree = createTree(); + if (!readFromFileToTree(fileName, tree)) { + return false; + } + return true; } bool test() { @@ -38,5 +104,8 @@ int main() { printf("..."); checkScan = scanf("%s", &fileName); } - + if (!connectingFunction(fileName)) { + printf("...\n"); + return -1; + } } \ No newline at end of file diff --git a/parsingTree/parsingTree/stack.c b/parsingTree/parsingTree/stack.c new file mode 100644 index 0000000..725a598 --- /dev/null +++ b/parsingTree/parsingTree/stack.c @@ -0,0 +1,73 @@ +#include "stack.h" +#include +#include + +typedef struct Value { + int number; + char symbol; +} Value; + +typedef struct Node { + Value value; + Node* right; + Node* left; +} Node; + +typedef struct Unit { + Node* value; + Unit* next; +}Unit; + +typedef struct Stack { + Unit* head; +}Stack; + +Stack* createStack(void) { + Stack* stack = calloc(1, sizeof(stack)); + return stack; +} + +int push(Stack* stack, Node* value) { + Unit* temp = calloc(1, sizeof(Unit)); + if (temp == NULL) { + printf(" ..."); + return -1; + } + temp->value = value; + temp->next = stack->head; + + stack->head = temp; + return 0; +} + +Node* pop(Stack* stack, int* errorCode) { + if (stack->head == NULL) { + if (errorCode != NULL) { + *errorCode = -1; + } + return NULL; + } + if (errorCode != NULL) { + *errorCode = 0; + } + + Node* value = stack->head->value; + + Unit* next = stack->head->next; + free(stack->head); + stack->head = next; + + return value; +} + +bool isEmpty(Stack* stack) { + return stack->head == NULL; +} + +void deleteStack(Stack* stack) { + while (!isEmpty(stack)) { + int errorCode = 0; + pop(stack, &errorCode); + } + stack = NULL; +} \ No newline at end of file diff --git a/parsingTree/parsingTree/stack.h b/parsingTree/parsingTree/stack.h new file mode 100644 index 0000000..e2f1583 --- /dev/null +++ b/parsingTree/parsingTree/stack.h @@ -0,0 +1,27 @@ +#ifndef STACK_H +#define STACK_H +#include + +typedef struct Stack Stack; + +typedef struct Node Node; + +typedef struct Value Value; + +typedef struct Unit Unit; + +// stack'a +Stack* createStack(void); + +// +int push(Stack* stack, Node* value); + +// ( ) +Node* pop(Stack* stack, int* errorCode); + +// +bool isEmpty(Stack* stack); + +// +void deleteStack(Stack* stack); +#endif \ No newline at end of file diff --git a/parsingTree/parsingTree/tree.c b/parsingTree/parsingTree/tree.c index ab56f71..1092de2 100644 --- a/parsingTree/parsingTree/tree.c +++ b/parsingTree/parsingTree/tree.c @@ -1,5 +1,7 @@ #include "tree.h" +#include "stack.h" #include +#include typedef struct Value { int number; @@ -21,7 +23,88 @@ Tree* createTree(void) { return tree; } -Node* createNode(Tree* tree) { +Node* createNode(void) { Node* temp = calloc(1, sizeof(Node)); return temp; +} + +Node* nonRecursivePreorder(Node* root, int* errorCode) { + Stack* stack = createStack(); + Node* current = root; + while (true) { + if (current != NULL) { + if (current->value.symbol == 0 && current->value.number == 0) { + return current; + } + push(stack, current); + current = current->left; + } + else { + if (isEmpty(stack)) { + free(stack); + return; + } + current = pop(stack, errorCode); + if (*errorCode != 0) { + return; + } + current = current->right; + } + } + deleteStack(stack); +} + +void addToTreeSymbol(Tree* tree, char symbol, int* errorCode) { + if (tree == NULL) { + *errorCode = -1; + return; + } + if (tree->root == NULL) { + tree->root = createNode(); + if (tree->root == NULL) { + *errorCode = -1; + return; + } + tree->root->value.symbol = symbol; + tree->root->left = createNode(); + if (tree->root->left == NULL) { + *errorCode = -1; + return; + } + tree->root->right = createNode(); + if (tree->root == NULL) { + *errorCode = -1; + return; + } + } + Node* newRoot = nonRecursivePreorder(tree->root, errorCode); + if (*errorCode != 0 || newRoot == NULL) { + *errorCode = -1; + return; + } + newRoot->value.symbol = symbol; + newRoot->left = createNode(); + if (newRoot->left == NULL) { + *errorCode = -1; + return; + } + newRoot->right = createNode(); + if (newRoot->right == NULL) { + *errorCode = -1; + return; + } +} + +void addToTreeNumber(Tree* tree, int number, int* errorCode) { + + if (tree == NULL || tree->root == NULL) { + *errorCode = -1; + return; + } + Node* newRoot = nonRecursivePreorder(tree->root, errorCode); + if (*errorCode != 0 || newRoot == NULL) { + *errorCode = -1; + return; + } + newRoot->value.number = number; } \ No newline at end of file diff --git a/parsingTree/parsingTree/tree.h b/parsingTree/parsingTree/tree.h index fe4a3ed..2aeafd8 100644 --- a/parsingTree/parsingTree/tree.h +++ b/parsingTree/parsingTree/tree.h @@ -3,6 +3,13 @@ typedef struct Tree Tree; +// Tree* createTree(void); -#endif +// , int' char' +void addToTreeSymbol(Tree* tree, char symbol, int* errorCode); + +// , int' char' +void addToTreeNumber(Tree* tree, int number, int* errorCode); + +#endif \ No newline at end of file From 716582a29aa6180bd7c2cdaffbdab831ccefd818 Mon Sep 17 00:00:00 2001 From: Artem Date: Sat, 5 Nov 2022 12:44:35 +0300 Subject: [PATCH 3/7] =?UTF-8?q?=D0=A1=D0=B4=D0=B5=D0=BB=D0=B0=D0=BB=20?= =?UTF-8?q?=D1=84=D1=83=D0=BD=D0=BA=D1=86=D0=B8=D1=8E=20=D0=BF=D0=BE=D0=B4?= =?UTF-8?q?=D1=81=D1=87=D1=91=D1=82=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- parsingTree/parsingTree/main.c | 6 +++++ parsingTree/parsingTree/test.txt | 1 + parsingTree/parsingTree/tree.c | 45 ++++++++++++++++++++++++++++++-- parsingTree/parsingTree/tree.h | 2 ++ 4 files changed, 52 insertions(+), 2 deletions(-) create mode 100644 parsingTree/parsingTree/test.txt diff --git a/parsingTree/parsingTree/main.c b/parsingTree/parsingTree/main.c index 0357782..c134c15 100644 --- a/parsingTree/parsingTree/main.c +++ b/parsingTree/parsingTree/main.c @@ -79,6 +79,12 @@ bool connectingFunction(char fileName[]) { if (!readFromFileToTree(fileName, tree)) { return false; } + int errorCode = 0; + int number = postorderCount(tree, &errorCode); + if (errorCode != 0) { + return -1; + } + printf("%d\n", number); return true; } diff --git a/parsingTree/parsingTree/test.txt b/parsingTree/parsingTree/test.txt new file mode 100644 index 0000000..40914e1 --- /dev/null +++ b/parsingTree/parsingTree/test.txt @@ -0,0 +1 @@ +(* (+ 1 1) 2) \ No newline at end of file diff --git a/parsingTree/parsingTree/tree.c b/parsingTree/parsingTree/tree.c index 1092de2..207c4be 100644 --- a/parsingTree/parsingTree/tree.c +++ b/parsingTree/parsingTree/tree.c @@ -42,16 +42,17 @@ Node* nonRecursivePreorder(Node* root, int* errorCode) { else { if (isEmpty(stack)) { free(stack); - return; + return NULL; } current = pop(stack, errorCode); if (*errorCode != 0) { - return; + return NULL; } current = current->right; } } deleteStack(stack); + return NULL; } void addToTreeSymbol(Tree* tree, char symbol, int* errorCode) { @@ -76,6 +77,7 @@ void addToTreeSymbol(Tree* tree, char symbol, int* errorCode) { *errorCode = -1; return; } + return; } Node* newRoot = nonRecursivePreorder(tree->root, errorCode); if (*errorCode != 0 || newRoot == NULL) { @@ -107,4 +109,43 @@ void addToTreeNumber(Tree* tree, int number, int* errorCode) { return; } newRoot->value.number = number; +} + +void postorderHelp(Node* root, Stack* stack) { + if (root != NULL) { + postorderHelp(root->left, stack); + postorderHelp(root->right, stack); + if (root->value.symbol != 0) { + int errorCode = 0; + Node* element = pop(stack, &errorCode); + int secondNumber = element->value.number; + element = pop(stack, &errorCode); + Node* newElement = createNode(); + int firstNumber = element->value.number; + int newNumber = 0; + if (root->value.symbol == '+') { + newNumber = secondNumber + firstNumber; + } else if (root->value.symbol == '*') { + newNumber = secondNumber * firstNumber; + } else if (root->value.symbol == '-') { + newNumber = secondNumber - firstNumber; + } else { + newNumber = secondNumber / firstNumber; + } + newElement->value.number = newNumber; + push(stack, newElement); + } else { + push(stack, root); + }/// , + } +} + +int postorderCount(Tree* tree, int* errorCode) { + Stack* stack = createStack(); + postorderHelp(tree->root, stack); + Node* newElement = pop(stack, errorCode); + if (*errorCode != 0 || newElement == NULL) { + return 0; + } + return newElement->value.number; } \ No newline at end of file diff --git a/parsingTree/parsingTree/tree.h b/parsingTree/parsingTree/tree.h index 2aeafd8..2b607ad 100644 --- a/parsingTree/parsingTree/tree.h +++ b/parsingTree/parsingTree/tree.h @@ -12,4 +12,6 @@ void addToTreeSymbol(Tree* tree, char symbol, int* errorCode); // , int' char' void addToTreeNumber(Tree* tree, int number, int* errorCode); +// , +int postorderCount(Tree* tree, int* errorCode); #endif \ No newline at end of file From ce2b1a5e29a5dacc63490857d8ee58f0c938f5d8 Mon Sep 17 00:00:00 2001 From: Artem Date: Sat, 5 Nov 2022 14:15:12 +0300 Subject: [PATCH 4/7] =?UTF-8?q?=D0=A1=D0=B4=D0=B5=D0=BB=D0=B0=D0=BB=20?= =?UTF-8?q?=D1=82=D0=B5=D1=81=D1=82,=20=D0=B2=D1=8B=D0=B2=D0=BE=D0=B4=20?= =?UTF-8?q?=D0=BD=D0=B0=20=D1=8D=D0=BA=D1=80=D0=B0=D0=BD,=20=D0=BF=D0=BE?= =?UTF-8?q?=D1=84=D0=B8=D0=BA=D1=81=D0=B8=D0=BB=20=D0=BF=D1=80=D0=BE=D0=B1?= =?UTF-8?q?=D0=BB=D0=B5=D0=BC=D1=83=20=D1=81=20=D1=83=D1=82=D0=B5=D1=87?= =?UTF-8?q?=D0=BA=D0=BE=D0=B9=20=D0=BF=D0=B0=D0=BC=D1=8F=D1=82=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- parsingTree/parsingTree/main.c | 14 +++++- parsingTree/parsingTree/stack.c | 11 +++++ parsingTree/parsingTree/stack.h | 3 ++ parsingTree/parsingTree/test.txt | 2 +- parsingTree/parsingTree/tree.c | 73 +++++++++++++++++++++++++++----- parsingTree/parsingTree/tree.h | 6 +++ 6 files changed, 97 insertions(+), 12 deletions(-) diff --git a/parsingTree/parsingTree/main.c b/parsingTree/parsingTree/main.c index c134c15..6815a10 100644 --- a/parsingTree/parsingTree/main.c +++ b/parsingTree/parsingTree/main.c @@ -79,17 +79,29 @@ bool connectingFunction(char fileName[]) { if (!readFromFileToTree(fileName, tree)) { return false; } + printTree(tree); int errorCode = 0; int number = postorderCount(tree, &errorCode); if (errorCode != 0) { return -1; } printf("%d\n", number); + clearTree(tree); return true; } bool test() { - return true; + Tree* tree = createTree(); + if (!readFromFileToTree("test.txt", tree)) { + return false; + } + int errorCode = 0; + int number = postorderCount(tree, &errorCode); + if (errorCode != 0) { + return -1; + } + clearTree(tree); + return number == -16; } int main() { diff --git a/parsingTree/parsingTree/stack.c b/parsingTree/parsingTree/stack.c index 725a598..81223ce 100644 --- a/parsingTree/parsingTree/stack.c +++ b/parsingTree/parsingTree/stack.c @@ -64,10 +64,21 @@ bool isEmpty(Stack* stack) { return stack->head == NULL; } +void customDelete(Stack* stack) { + while (!isEmpty(stack)) { + int errorCode = 0; + Node* element = pop(stack, &errorCode); + free(element); + } + free(stack); + stack = NULL; +} + void deleteStack(Stack* stack) { while (!isEmpty(stack)) { int errorCode = 0; pop(stack, &errorCode); } + free(stack); stack = NULL; } \ No newline at end of file diff --git a/parsingTree/parsingTree/stack.h b/parsingTree/parsingTree/stack.h index e2f1583..49b4f30 100644 --- a/parsingTree/parsingTree/stack.h +++ b/parsingTree/parsingTree/stack.h @@ -24,4 +24,7 @@ bool isEmpty(Stack* stack); // void deleteStack(Stack* stack); + +// + +void customDelete(Stack* stack); #endif \ No newline at end of file diff --git a/parsingTree/parsingTree/test.txt b/parsingTree/parsingTree/test.txt index 40914e1..293996f 100644 --- a/parsingTree/parsingTree/test.txt +++ b/parsingTree/parsingTree/test.txt @@ -1 +1 @@ -(* (+ 1 1) 2) \ No newline at end of file +(- (* (+ 2 2) 2) (* (+ 4 4) 3)) \ No newline at end of file diff --git a/parsingTree/parsingTree/tree.c b/parsingTree/parsingTree/tree.c index 207c4be..93d4b83 100644 --- a/parsingTree/parsingTree/tree.c +++ b/parsingTree/parsingTree/tree.c @@ -1,6 +1,7 @@ #include "tree.h" #include "stack.h" #include +#include #include typedef struct Value { @@ -111,10 +112,10 @@ void addToTreeNumber(Tree* tree, int number, int* errorCode) { newRoot->value.number = number; } -void postorderHelp(Node* root, Stack* stack) { +void postorderHelp(Node* root, Stack* stack, Stack* stackToClear) { if (root != NULL) { - postorderHelp(root->left, stack); - postorderHelp(root->right, stack); + postorderHelp(root->left, stack, stackToClear); + postorderHelp(root->right, stack, stackToClear); if (root->value.symbol != 0) { int errorCode = 0; Node* element = pop(stack, &errorCode); @@ -124,28 +125,80 @@ void postorderHelp(Node* root, Stack* stack) { int firstNumber = element->value.number; int newNumber = 0; if (root->value.symbol == '+') { - newNumber = secondNumber + firstNumber; + newNumber = firstNumber + secondNumber; } else if (root->value.symbol == '*') { - newNumber = secondNumber * firstNumber; + newNumber = firstNumber * secondNumber; } else if (root->value.symbol == '-') { - newNumber = secondNumber - firstNumber; + newNumber = firstNumber - secondNumber; } else { - newNumber = secondNumber / firstNumber; + newNumber = firstNumber / secondNumber; } newElement->value.number = newNumber; push(stack, newElement); + push(stackToClear, newElement); } else { push(stack, root); - }/// , + } + } +} + +void infix(Node* root, int isNeedStample) { + if (root != NULL) { + if (root->value.symbol != 0) { + printf("(%c ", root->value.symbol); + ++isNeedStample; + } else { + if (isNeedStample == 0) { + printf("%d ", root->value.number); + } else { + printf("%d", root->value.number); + while (isNeedStample != 0) { + printf(")"); + --isNeedStample; + } + printf(" "); + } + } + infix(root->left, 0); + infix(root->right, isNeedStample); + } +} + +void printTree(Tree* tree) { + if (tree == NULL) { + return; } + infix(tree->root, 0); + printf("\n"); } int postorderCount(Tree* tree, int* errorCode) { Stack* stack = createStack(); - postorderHelp(tree->root, stack); + Stack* stackToClear = createStack(); + postorderHelp(tree->root, stack, stackToClear); Node* newElement = pop(stack, errorCode); if (*errorCode != 0 || newElement == NULL) { return 0; } - return newElement->value.number; + int number = newElement->value.number; + customDelete(stackToClear); + return number; +} + +void postorderDelete(Node* root) { + if (root != NULL) { + postorderDelete(root->left); + postorderDelete(root->right); + free(root); + root = NULL; + } +} + +void clearTree(Tree* tree) { + if (tree == NULL) { + return; + } + postorderDelete(tree->root); + free(tree); + tree = NULL; } \ No newline at end of file diff --git a/parsingTree/parsingTree/tree.h b/parsingTree/parsingTree/tree.h index 2b607ad..efdcba8 100644 --- a/parsingTree/parsingTree/tree.h +++ b/parsingTree/parsingTree/tree.h @@ -14,4 +14,10 @@ void addToTreeNumber(Tree* tree, int number, int* errorCode); // , int postorderCount(Tree* tree, int* errorCode); + +// +void printTree(Tree* tree); + +// +void clearTree(Tree* tree); #endif \ No newline at end of file From 834f0b108693829d8ce7a4731ca295e946e4ad55 Mon Sep 17 00:00:00 2001 From: Artem Date: Sat, 5 Nov 2022 14:25:16 +0300 Subject: [PATCH 5/7] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BB=20ungetc,=20?= =?UTF-8?q?=D1=82=D0=B0=D0=BC=20=D0=B3=D0=B4=D0=B5=20=D0=BE=D0=BD=D0=B0=20?= =?UTF-8?q?=D0=BD=D0=B5=20=D0=BD=D1=83=D0=B6=D0=BD=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- parsingTree/parsingTree/main.c | 10 +--------- parsingTree/parsingTree/test.txt | 2 +- 2 files changed, 2 insertions(+), 10 deletions(-) diff --git a/parsingTree/parsingTree/main.c b/parsingTree/parsingTree/main.c index 6815a10..05f220f 100644 --- a/parsingTree/parsingTree/main.c +++ b/parsingTree/parsingTree/main.c @@ -18,14 +18,6 @@ bool readFromFileToTree(char fileName[], Tree* tree) { char letter = 0; while (!feof(file)) { - int symbol = getc(file); - if (symbol == '(' || symbol == ')') { - ungetc("", file); - } - else { - ungetc(symbol, file); - } - fscanf(file, "%c", &letter); if (letter == '+' || letter == '*' || letter == '/') { addToTreeSymbol(tree, letter, &errorCode); @@ -101,7 +93,7 @@ bool test() { return -1; } clearTree(tree); - return number == -16; + return number == -4; } int main() { diff --git a/parsingTree/parsingTree/test.txt b/parsingTree/parsingTree/test.txt index 293996f..28906b5 100644 --- a/parsingTree/parsingTree/test.txt +++ b/parsingTree/parsingTree/test.txt @@ -1 +1 @@ -(- (* (+ 2 2) 2) (* (+ 4 4) 3)) \ No newline at end of file +(- (* (+ 2 2) 2) (* (+ 2 2) 3)) \ No newline at end of file From 47ca3aadc6c32adb9c3072af11bb98ae3475eff1 Mon Sep 17 00:00:00 2001 From: Palezehvat <114094069+Palezehvat@users.noreply.github.com> Date: Fri, 18 Nov 2022 14:55:47 +0300 Subject: [PATCH 6/7] Delete HomeworksAccept directory --- HomeworksAccept/homework21.09/read.me | 1 - HomeworksAccept/homework28.09/read.me | 1 - HomeworksAccept/read.me | 1 - 3 files changed, 3 deletions(-) delete mode 100644 HomeworksAccept/homework21.09/read.me delete mode 100644 HomeworksAccept/homework28.09/read.me delete mode 100644 HomeworksAccept/read.me diff --git a/HomeworksAccept/homework21.09/read.me b/HomeworksAccept/homework21.09/read.me deleted file mode 100644 index 5e4d090..0000000 --- a/HomeworksAccept/homework21.09/read.me +++ /dev/null @@ -1 +0,0 @@ -3 домашка diff --git a/HomeworksAccept/homework28.09/read.me b/HomeworksAccept/homework28.09/read.me deleted file mode 100644 index 5061ad0..0000000 --- a/HomeworksAccept/homework28.09/read.me +++ /dev/null @@ -1 +0,0 @@ -4 домашка diff --git a/HomeworksAccept/read.me b/HomeworksAccept/read.me deleted file mode 100644 index 1773bf8..0000000 --- a/HomeworksAccept/read.me +++ /dev/null @@ -1 +0,0 @@ -Здесь представлены домашнии работы, прошедшии проверку From 7e4749b4080ed10115d2f5f147328fc17d16068c Mon Sep 17 00:00:00 2001 From: Artem Date: Fri, 23 Dec 2022 13:04:13 +0300 Subject: [PATCH 7/7] =?UTF-8?q?=D0=A0=D0=B5=D0=B2=D1=8C=D1=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- parsingTree/parsingTree/main.c | 6 +- parsingTreeNew/parsingTreeNew.sln | 31 +++ parsingTreeNew/parsingTreeNew/main.c | 123 ++++++++++ .../parsingTreeNew/parsingTreeNew.vcxproj | 156 +++++++++++++ .../parsingTreeNew.vcxproj.filters | 41 ++++ parsingTreeNew/parsingTreeNew/stack.c | 84 +++++++ parsingTreeNew/parsingTreeNew/stack.h | 30 +++ parsingTreeNew/parsingTreeNew/test.txt | 1 + parsingTreeNew/parsingTreeNew/tree.c | 210 ++++++++++++++++++ parsingTreeNew/parsingTreeNew/tree.h | 23 ++ 10 files changed, 702 insertions(+), 3 deletions(-) create mode 100644 parsingTreeNew/parsingTreeNew.sln create mode 100644 parsingTreeNew/parsingTreeNew/main.c create mode 100644 parsingTreeNew/parsingTreeNew/parsingTreeNew.vcxproj create mode 100644 parsingTreeNew/parsingTreeNew/parsingTreeNew.vcxproj.filters create mode 100644 parsingTreeNew/parsingTreeNew/stack.c create mode 100644 parsingTreeNew/parsingTreeNew/stack.h create mode 100644 parsingTreeNew/parsingTreeNew/test.txt create mode 100644 parsingTreeNew/parsingTreeNew/tree.c create mode 100644 parsingTreeNew/parsingTreeNew/tree.h diff --git a/parsingTree/parsingTree/main.c b/parsingTree/parsingTree/main.c index 05f220f..77a4409 100644 --- a/parsingTree/parsingTree/main.c +++ b/parsingTree/parsingTree/main.c @@ -5,7 +5,7 @@ #include bool isDigit(char symbol) { - return symbol == '0' || symbol == '1' || symbol == '2' || symbol == '3' || symbol == '4' || symbol == '5' || symbol == '6' || symbol == '7' || symbol == '8' || symbol == '9'; + return symbol >= '0' && symbol <= '9'; } bool readFromFileToTree(char fileName[], Tree* tree) { @@ -36,11 +36,11 @@ bool readFromFileToTree(char fileName[], Tree* tree) { } else { ungetc(symbol, file); fscanf(file, "%c", &letter); - int number = -1 * (int)letter - 48; + int number = -letter - '0'; fscanf(file, "%c", &letter); while (isDigit(letter)) { number *= 10; - number += (int)letter - 48; + number += letter - '0'; fscanf(file, "%c", &letter); } addToTreeNumber(tree, number, &errorCode); diff --git a/parsingTreeNew/parsingTreeNew.sln b/parsingTreeNew/parsingTreeNew.sln new file mode 100644 index 0000000..f771b6d --- /dev/null +++ b/parsingTreeNew/parsingTreeNew.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.31903.59 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "parsingTreeNew", "parsingTreeNew\parsingTreeNew.vcxproj", "{733ABB93-2B1F-48F0-B050-3DB11AF05EA5}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {733ABB93-2B1F-48F0-B050-3DB11AF05EA5}.Debug|x64.ActiveCfg = Debug|x64 + {733ABB93-2B1F-48F0-B050-3DB11AF05EA5}.Debug|x64.Build.0 = Debug|x64 + {733ABB93-2B1F-48F0-B050-3DB11AF05EA5}.Debug|x86.ActiveCfg = Debug|Win32 + {733ABB93-2B1F-48F0-B050-3DB11AF05EA5}.Debug|x86.Build.0 = Debug|Win32 + {733ABB93-2B1F-48F0-B050-3DB11AF05EA5}.Release|x64.ActiveCfg = Release|x64 + {733ABB93-2B1F-48F0-B050-3DB11AF05EA5}.Release|x64.Build.0 = Release|x64 + {733ABB93-2B1F-48F0-B050-3DB11AF05EA5}.Release|x86.ActiveCfg = Release|Win32 + {733ABB93-2B1F-48F0-B050-3DB11AF05EA5}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {EA3F37A8-33E7-4249-BFEB-E26D8F0E43D3} + EndGlobalSection +EndGlobal diff --git a/parsingTreeNew/parsingTreeNew/main.c b/parsingTreeNew/parsingTreeNew/main.c new file mode 100644 index 0000000..967163b --- /dev/null +++ b/parsingTreeNew/parsingTreeNew/main.c @@ -0,0 +1,123 @@ +#include "tree.h" +#include +#include +#include +#include + +bool isDigit(char symbol) { + return symbol >= '0' && symbol <= '9'; +} + +bool readFromFileToTree(char fileName[], Tree* tree) { + int errorCode = 0; + FILE* file = fopen(fileName, "rt"); + if (file == NULL) { + printf(" !"); + return false; + } + char letter = 0; + + while (!feof(file)) { + fscanf(file, "%c", &letter); + if (letter == '+' || letter == '*' || letter == '/') { + addToTreeSymbol(tree, letter, &errorCode); + if (errorCode != 0) { + return false; + } + } + if (letter == '-') { + int symbol = getc(file); + if (symbol == ' ') { + addToTreeSymbol(tree, letter, &errorCode); + if (errorCode != 0) { + return false; + } + ungetc(symbol, file); + } + else { + ungetc(symbol, file); + fscanf(file, "%c", &letter); + int number = -letter - '0'; + fscanf(file, "%c", &letter); + while (isDigit(letter)) { + number *= 10; + number += letter - '0'; + fscanf(file, "%c", &letter); + } + addToTreeNumber(tree, number, &errorCode); + if (errorCode != 0) { + return false; + } + } + } + if (isDigit(letter)) { + int number = (int)letter - 48; + fscanf(file, "%c", &letter); + while (isDigit(letter)) { + number *= 10; + number += (int)letter - 48; + fscanf(file, "%c", &letter); + } + addToTreeNumber(tree, number, &errorCode); + if (errorCode != 0) { + return false; + } + } + } + return true; +} + +bool connectingFunction(char fileName[]) { + Tree* tree = createTree(); + if (!readFromFileToTree(fileName, tree)) { + return false; + } + printTree(tree); + int errorCode = 0; + int number = postorderCount(tree, &errorCode); + if (errorCode != 0) { + return -1; + } + printf("%d\n", number); + clearTree(tree); + return true; +} + +bool test() { + Tree* tree = createTree(); + if (!readFromFileToTree("test.txt", tree)) { + return false; + } + int errorCode = 0; + int number = postorderCount(tree, &errorCode); + if (errorCode != 0) { + return -1; + } + clearTree(tree); + return number == -4; +} + +int main() { + setlocale(LC_ALL, "RUS"); + if (test()) { + printf(" !\n"); + } + else { + printf("...\n"); + return -1; + } + printf(" , 100 \n"); + char fileName[100] = { '\0' }; + int checkScan = scanf("%s", &fileName); + while (checkScan != 1) { + while (getchar() != '\n') { + } + + printf("..."); + checkScan = scanf("%s", &fileName); + } + if (!connectingFunction(fileName)) { + printf("...\n"); + return -1; + } +} \ No newline at end of file diff --git a/parsingTreeNew/parsingTreeNew/parsingTreeNew.vcxproj b/parsingTreeNew/parsingTreeNew/parsingTreeNew.vcxproj new file mode 100644 index 0000000..37ddfe4 --- /dev/null +++ b/parsingTreeNew/parsingTreeNew/parsingTreeNew.vcxproj @@ -0,0 +1,156 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + Win32Proj + {733abb93-2b1f-48f0-b050-3db11af05ea5} + parsingTreeNew + 10.0 + + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + false + + + true + + + false + + + + Level3 + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + Level3 + false + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/parsingTreeNew/parsingTreeNew/parsingTreeNew.vcxproj.filters b/parsingTreeNew/parsingTreeNew/parsingTreeNew.vcxproj.filters new file mode 100644 index 0000000..79302ee --- /dev/null +++ b/parsingTreeNew/parsingTreeNew/parsingTreeNew.vcxproj.filters @@ -0,0 +1,41 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + + + Исходные файлы + + + Исходные файлы + + + + + Исходные файлы + + + \ No newline at end of file diff --git a/parsingTreeNew/parsingTreeNew/stack.c b/parsingTreeNew/parsingTreeNew/stack.c new file mode 100644 index 0000000..fb9a743 --- /dev/null +++ b/parsingTreeNew/parsingTreeNew/stack.c @@ -0,0 +1,84 @@ +#include "stack.h" +#include +#include + +typedef struct Value { + int number; + char symbol; +} Value; + +typedef struct Node { + Value value; + Node* right; + Node* left; +} Node; + +typedef struct Unit { + Node* value; + Unit* next; +}Unit; + +typedef struct Stack { + Unit* head; +}Stack; + +Stack* createStack(void) { + Stack* stack = calloc(1, sizeof(stack)); + return stack; +} + +int push(Stack* stack, Node* value) { + Unit* temp = calloc(1, sizeof(Unit)); + if (temp == NULL) { + printf(" ..."); + return -1; + } + temp->value = value; + temp->next = stack->head; + + stack->head = temp; + return 0; +} + +Node* pop(Stack* stack, int* errorCode) { + if (stack->head == NULL) { + if (errorCode != NULL) { + *errorCode = -1; + } + return NULL; + } + if (errorCode != NULL) { + *errorCode = 0; + } + + Node* value = stack->head->value; + + Unit* next = stack->head->next; + free(stack->head); + stack->head = next; + + return value; +} + +bool isEmpty(Stack* stack) { + return stack->head == NULL; +} + +void customDelete(Stack* stack) { + while (!isEmpty(stack)) { + int errorCode = 0; + Node* element = pop(stack, &errorCode); + free(element); + } + free(stack); + stack = NULL; +} + +void deleteStack(Stack* stack) { + while (!isEmpty(stack)) { + int errorCode = 0; + pop(stack, &errorCode); + } + free(stack); + stack = NULL; +} \ No newline at end of file diff --git a/parsingTreeNew/parsingTreeNew/stack.h b/parsingTreeNew/parsingTreeNew/stack.h new file mode 100644 index 0000000..49b4f30 --- /dev/null +++ b/parsingTreeNew/parsingTreeNew/stack.h @@ -0,0 +1,30 @@ +#ifndef STACK_H +#define STACK_H +#include + +typedef struct Stack Stack; + +typedef struct Node Node; + +typedef struct Value Value; + +typedef struct Unit Unit; + +// stack'a +Stack* createStack(void); + +// +int push(Stack* stack, Node* value); + +// ( ) +Node* pop(Stack* stack, int* errorCode); + +// +bool isEmpty(Stack* stack); + +// +void deleteStack(Stack* stack); + +// + +void customDelete(Stack* stack); +#endif \ No newline at end of file diff --git a/parsingTreeNew/parsingTreeNew/test.txt b/parsingTreeNew/parsingTreeNew/test.txt new file mode 100644 index 0000000..28906b5 --- /dev/null +++ b/parsingTreeNew/parsingTreeNew/test.txt @@ -0,0 +1 @@ +(- (* (+ 2 2) 2) (* (+ 2 2) 3)) \ No newline at end of file diff --git a/parsingTreeNew/parsingTreeNew/tree.c b/parsingTreeNew/parsingTreeNew/tree.c new file mode 100644 index 0000000..7a2b069 --- /dev/null +++ b/parsingTreeNew/parsingTreeNew/tree.c @@ -0,0 +1,210 @@ +#include "tree.h" +#include "stack.h" +#include +#include +#include + +typedef struct Value { + int number; + char symbol; +} Value; + +typedef struct Node { + Value value; + Node* right; + Node* left; +} Node; + +typedef struct Tree { + Node* root; +} Tree; + +Tree* createTree(void) { + Tree* tree = calloc(1, sizeof(Tree)); + return tree; +} + +Node* createNode(void) { + Node* temp = calloc(1, sizeof(Node)); + return temp; +} + +Node* nonRecursivePreorder(Node* root, int* errorCode) { + Stack* stack = createStack(); + Node* current = root; + while (true) { + if (current != NULL) { + if (current->value.symbol == 0 && current->value.number == 0) { + return current; + } + push(stack, current); + current = current->left; + } + else { + if (isEmpty(stack)) { + free(stack); + return NULL; + } + current = pop(stack, errorCode); + if (*errorCode != 0) { + return NULL; + } + current = current->right; + } + } + deleteStack(stack); + return NULL; +} + +void addToTreeSymbol(Tree* tree, char symbol, int* errorCode) { + if (tree == NULL) { + *errorCode = -1; + return; + } + if (tree->root == NULL) { + tree->root = createNode(); + if (tree->root == NULL) { + *errorCode = -1; + return; + } + tree->root->value.symbol = symbol; + tree->root->left = createNode(); + if (tree->root->left == NULL) { + *errorCode = -1; + return; + } + tree->root->right = createNode(); + if (tree->root == NULL) { + *errorCode = -1; + return; + } + return; + } + Node* newRoot = nonRecursivePreorder(tree->root, errorCode); + if (*errorCode != 0 || newRoot == NULL) { + *errorCode = -1; + return; + } + newRoot->value.symbol = symbol; + newRoot->left = createNode(); + if (newRoot->left == NULL) { + *errorCode = -1; + return; + } + newRoot->right = createNode(); + if (newRoot->right == NULL) { + *errorCode = -1; + return; + } +} + +void addToTreeNumber(Tree* tree, int number, int* errorCode) { + + if (tree == NULL || tree->root == NULL) { + *errorCode = -1; + return; + } + Node* newRoot = nonRecursivePreorder(tree->root, errorCode); + if (*errorCode != 0 || newRoot == NULL) { + *errorCode = -1; + return; + } + newRoot->value.number = number; +} + +void postorderHelp(Node* root, Stack* stack, Stack* stackToClear) { + if (root == NULL) { + return; + } + postorderHelp(root->left, stack, stackToClear); + postorderHelp(root->right, stack, stackToClear); + if (root->value.symbol != 0) { + int errorCode = 0; + Node* element = pop(stack, &errorCode); + int secondNumber = element->value.number; + element = pop(stack, &errorCode); + Node* newElement = createNode(); + int firstNumber = element->value.number; + int newNumber = 0; + if (root->value.symbol == '+') { + newNumber = firstNumber + secondNumber; + } + else if (root->value.symbol == '*') { + newNumber = firstNumber * secondNumber; + } + else if (root->value.symbol == '-') { + newNumber = firstNumber - secondNumber; + } + else { + newNumber = firstNumber / secondNumber; + } + newElement->value.number = newNumber; + push(stack, newElement); + push(stackToClear, newElement); + } + else { + push(stack, root); + } +} + +void infix(Node* root, int isNeedStample) { + if (root != NULL) { + if (root->value.symbol != 0) { + printf("(%c ", root->value.symbol); + ++isNeedStample; + } + else { + if (isNeedStample == 0) { + printf("%d ", root->value.number); + } + else { + printf("%d", root->value.number); + while (isNeedStample != 0) { + printf(")"); + --isNeedStample; + } + printf(" "); + } + } + infix(root->left, 0); + infix(root->right, isNeedStample); + } +} + +void printTree(Tree* tree) { + if (tree == NULL) { + return; + } + infix(tree->root, 0); + printf("\n"); +} + +int postorderCount(Tree* tree, int* errorCode) { + Stack* stack = createStack(); + Stack* stackToClear = createStack(); + postorderHelp(tree->root, stack, stackToClear); + Node* newElement = pop(stack, errorCode); + if (*errorCode != 0 || newElement == NULL) { + return 0; + } + int number = newElement->value.number; + customDelete(stackToClear); + return number; +} + +void postorderDelete(Node* root) { + if (root != NULL) { + postorderDelete(root->left); + postorderDelete(root->right); + free(root); + root = NULL; + } +} + +void clearTree(Tree* tree) { + if (tree == NULL) { + return; + } + postorderDelete(tree->root); + free(tree); +} \ No newline at end of file diff --git a/parsingTreeNew/parsingTreeNew/tree.h b/parsingTreeNew/parsingTreeNew/tree.h new file mode 100644 index 0000000..efdcba8 --- /dev/null +++ b/parsingTreeNew/parsingTreeNew/tree.h @@ -0,0 +1,23 @@ +#ifndef TREE_H +#define TREE_H + +typedef struct Tree Tree; + +// +Tree* createTree(void); + +// , int' char' +void addToTreeSymbol(Tree* tree, char symbol, int* errorCode); + +// , int' char' +void addToTreeNumber(Tree* tree, int number, int* errorCode); + +// , +int postorderCount(Tree* tree, int* errorCode); + +// +void printTree(Tree* tree); + +// +void clearTree(Tree* tree); +#endif \ No newline at end of file