From a7eb7fceb187a7318795e0f2c17a165d5dd37a66 Mon Sep 17 00:00:00 2001 From: Wu Junfeng Date: Thu, 26 Feb 2015 04:43:05 +0300 Subject: [PATCH 1/2] Wu_Junfeng_DFA --- wu_dfa/wu_dfa | Bin 0 -> 40920 bytes wu_dfa/wu_dfa.cpp | 612 ++++++++++++++++++++++++++++++++++++++++++++++ wu_dfa/wu_dfa.h | 567 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1179 insertions(+) create mode 100755 wu_dfa/wu_dfa create mode 100644 wu_dfa/wu_dfa.cpp create mode 100644 wu_dfa/wu_dfa.h diff --git a/wu_dfa/wu_dfa b/wu_dfa/wu_dfa new file mode 100755 index 0000000000000000000000000000000000000000..dd5bac29e82a7cb3a376feaf395dc51dc1548177 GIT binary patch literal 40920 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 +using namespace std; +#include +#include +#include +#include +#include "wu_dfa.h" + +#define LStack LinkedStack + +class DFA +{ +public: + DFA(); + ~DFA(); + void GetRegExp(); + void InsertCatNode(); + void RegExpToPost(); + void GetEdgeNumber(); + void ThompsonConstruction(); + void SubsetConstruction(); +private: + char *exp; + char *post; + char *edge; + int edgeNumber; + int **DStates; + int **Dtran; + int *AcceptStates; + int DStatesNumber; + int DtranNumber; + int NFAStatesNumber; + int DFAStatesNumber; + AdjacentTable *NFATable; + TransitionTable *DFATable; + int Precedence(char symbol); + int CompArray(int *t1, int *t2); + int MinimizeDFAStates(int **Dtran, int *AcceptStates, int DtranNumber, int edgeNumber); + }; + +DFA::DFA() +{ + exp = new char[128]; + post = new char[128]; + edge = new char[128]; + edgeNumber = 0; + NFAStatesNumber = 0; + DFAStatesNumber = 0; + DStatesNumber = 0; + DtranNumber = 0; + NFATable = new AdjacentTable(); +} + +DFA::~DFA() +{ + delete [] exp; + delete [] post; + delete [] edge; + delete [] AcceptStates; + NFATable->Clear(); + DFATable->Clear(); +} + +void DFA::GetRegExp() +{ + cout << "\ninput regular expression: " << endl; + cin >> exp; + for (int i=0; exp[i]!='\0'; i++) + { + if (exp[i] == '~') + { + cout << "\n'~'is forbidden！" << endl; + getchar(); + exit(1); + } + } + cout << "------------------------" << endl; +} + +void DFA::InsertCatNode() +{ + int i = 0, j, len = strlen(exp); + while (exp[i+1] != '\0') + { + if (((exp[i] != '(' && exp[i] != '.' && exp[i] != '|'&& exp[i+1] != '/') + || exp[i] == ')' || exp[i] == '*' || exp[i] == '+' || exp[i] == '?') + && (exp[i+1] != ')' && exp[i+1] != '.' && exp[i+1] != '|' + && exp[i+1] != '*' && exp[i+1] != '+' && exp[i+1] != '?' && exp[i+1] != '/')) + { + for (j=len; j>i+1; j--) + { + exp[j] = exp[j-1]; + } + exp[i+1] = '.'; + len++; + exp[len] = '\0'; + i++; + } + i++; + } + cout << "1.Insert cat-node\n" + << exp << "\n------------------------" << endl; +} +int DFA::Precedence(char symbol) +{ + int priority; + switch (symbol) + { + case '|': priority = 1; break; + case '.': priority = 2; break; + case '*': priority = 3; break; + case '+': priority = 4; break; + case '?': priority = 5; break; + case '/': priority = 6; break; + default: priority = 0; break; + } + return priority; +} +void DFA::RegExpToPost() +{ + int i = 0, j = 0; + char ch, cl; + strcpy(post, "\0"); + LStack *ls = new LStack(); + ls->Clear(); + ls->Push('#'); + ch = exp[i]; + while (ch != '\0') + { + if (ch == '(') + { + ls->Push(ch); + ch = exp[++i]; + } + else if (ch == ')') + { + while (ls->GetTop() != '(') + { + post[j++] = ls->Pop(); + } + ls->Pop(); + ch = exp[++i]; + } + else if ((ch == '|') || (ch == '*') || (ch == '.') || (ch == '+') || (ch == '?') || (ch == '/') ) + { + cl = ls->GetTop(); + while (Precedence(cl) >= Precedence(ch)) + { + post[j++] = cl; + ls->Pop(); + cl = ls->GetTop(); + } + ls->Push(ch); + ch = exp[++i]; + } + else + { + post[j++] = ch; + ch = exp[++i]; + } + } + ch = ls->Pop(); + while ((ch == '|') || (ch == '*') || (ch == '.') || (ch == '+') || (ch == '?') || (ch == '/') ) + { + post[j++] = ch; + ch = ls->Pop(); + } + post[j] = '\0'; + ls->Clear(); + cout << "2.regexp to post\n" + << post << "\n------------------------" << endl; +} + +void DFA::GetEdgeNumber() +{ + int i = 0, j; + edgeNumber = 0; + while (post[i] != '\0') + { + if (post[i] == '.' || post[i] == '|' || post[i] == '*' || post[i] == '+' || post[i] == '?' || post[i] == '/') + { + i++; + continue; + } + for (j=0; j *states = new LStack(); + states->Clear(); + if (strlen(post) < 1) + { + cout << "No Valid Regular Expression Found!" << endl; + getchar(); + exit(1); + } + NFATable->SetValue(0, 0); + i = 1; + j = 0; + ch = post[j]; + while (ch != '\0') + { + if (ch == '.') + { + s2 = states->Pop(); + int temp1 = states->Pop(); + int temp2 = states->Pop(); + s1 = states->Pop(); + NFATable->InsertEdgeByValue(temp2, temp1, '~'); + states->Push(s1); + states->Push(s2); + } + else if (ch == '|') + { + s2 = states->Pop(); + int temp1 = states->Pop(); + int temp2 = states->Pop(); + s1 = states->Pop(); + NFATable->InsertVertex(i); + NFATable->InsertVertex(i+1); + NFATable->InsertEdgeByValue(i, s1, '~'); + NFATable->InsertEdgeByValue(i, temp1, '~'); + NFATable->InsertEdgeByValue(temp2, i+1, '~'); + NFATable->InsertEdgeByValue(s2, i+1, '~'); + s1 = i; + s2 = i+1; + states->Push(s1); + states->Push(s2); + i += 2; + } + else if (ch == '*') + { + s2 = states->Pop(); + s1 = states->Pop(); + NFATable->InsertVertex(i); + NFATable->InsertVertex(i+1); + NFATable->InsertEdgeByValue(i, i+1, '~'); + NFATable->InsertEdgeByValue(s2, s1, '~'); + NFATable->InsertEdgeByValue(i, s1, '~'); + NFATable->InsertEdgeByValue(s2, i+1, '~'); + s1 = i; + s2 = i+1; + states->Push(s1); + states->Push(s2); + i += 2; + } + else if (ch == '+') + { + s2 = states->Pop(); + s1 = states->Pop(); + NFATable->InsertVertex(i); + NFATable->InsertVertex(i+1); + NFATable->InsertEdgeByValue(s2, s1, '~'); + NFATable->InsertEdgeByValue(i, s1, '~'); + NFATable->InsertEdgeByValue(s2, i+1, '~'); + s1 = i; + s2 = i+1; + states->Push(s1); + states->Push(s2); + i += 2; + } + else if (ch == '?') + { + s2 = states->Pop(); + s1 = states->Pop(); + NFATable->InsertVertex(i); + NFATable->InsertVertex(i+1); + NFATable->InsertEdgeByValue(i, i+1, '~'); + NFATable->InsertEdgeByValue(i, s1, '~'); + NFATable->InsertEdgeByValue(s2, i+1, '~'); + s1 = i; + s2 = i+1; + states->Push(s1); + states->Push(s2); + i += 2; + } + else if (ch == '/') + { + s2 = states->Pop(); + s1 = states->Pop(); + NFATable->InsertVertex(i); + NFATable->InsertVertex(i+1); + NFATable->InsertEdgeByValue(i, i+1, '~'); + s1 = i; + s2 = i+1; + states->Push(s1); + states->Push(s2); + i += 2; + } + else + { + NFATable->InsertVertex(i); + NFATable->InsertVertex(i+1); + NFATable->InsertEdgeByValue(i, i+1, ch); + s1 = i; + s2 = i+1; + states->Push(s1); + states->Push(s2); + i += 2; + } + j++; + ch = post[j]; + } + s2 = states->Pop(); + s1 = states->Pop(); + NFATable->InsertEdgeByValue(0, s1, '~'); + if (! states->IsEmpty()) + { + cout << "Some error in your input string!" << endl; + getchar(); + exit(1); + } + NFAStatesNumber = s2 + 1; +} + +int DFA::CompArray(int *t1, int *t2) +{ + int i = 0, j = 0, len1, len2; + while (t1[i] != -1) + { + i++; + } + len1 = i; + while (t2[j] != -1) + { + j++; + } + len2 = j; + if (len1 != len2) + { + return 0; + } + for (i=0; iOutputNFA(); + cout << "------------------------" << endl; + DStates = (int**)(new int*[NFAStatesNumber+1]); + for (i=0; iClosure(T); + DStates[DStatesNumber] = T; + DStatesNumber++; + k = 0; + while (k < DStatesNumber) + { + for (i=0; edge[i]!='\0'; i++) + { + temp = NFATable->Closure(NFATable->Move(T, edge[i])); + if (temp[0] != -1) + { + for (j=0; jSetValue(i, j, Dtran[i][j]); + } + } + + cout << "7.DFA\nstate"; + for (j=0; jGetValue(i, j) < 0) cout << " "; + else if (DFATable->GetValue(i, j) < 10) cout << " " << DFATable->GetValue(i, j); + else if (DFATable->GetValue(i, j) < 100) cout << " " << DFATable->GetValue(i, j); + else if (DFATable->GetValue(i, j) < 1000) cout << " " << DFATable->GetValue(i, j); + else cout << " " << DFATable->GetValue(i, j); + } + if (AcceptStates[i] == 1) + { + cout << " Acc"; + } + cout << endl; + } + cout << "------------------------" << endl; + for (i=0; i +using namespace std; +#include +#include +#include +#include + + +template +class LinkedStack; + + +template +class StackNode +{ + friend class LinkedStack; +private: + T data; + StackNode *next; + StackNode(T item = 0, StackNode *p = NULL) + { + data = item; + next = p; + } +}; + + +template +class LinkedStack +{ +private: + StackNode *top; +public: + LinkedStack(); + ~LinkedStack(); + bool IsEmpty(void) const; + int Length(void) const; + void Push(const T &item); + T Pop(void); + T GetTop(void); + void Clear(void); +}; + +template +LinkedStack::LinkedStack() +{ + top = NULL; +} + +template +LinkedStack::~LinkedStack() +{ + Clear(); +} + +template +bool LinkedStack::IsEmpty(void) const +{ + return (! top); +} + +template +int LinkedStack::Length(void) const +{ + StackNode *temp = new StackNode(); + temp = top; + int length = 0; + while (temp) + { + temp = temp->next; + length++; + } + return length; +} + +template +void LinkedStack::Push(const T &item) +{ + top = new StackNode(item, top); +} + +template +T LinkedStack::Pop(void) +{ + if (! IsEmpty()) + { + StackNode *temp = top; + top = top->next; + T value = temp->data; + delete temp; + return value; + } + else + { + cout << "Stack Already Empty!" << endl; + getchar(); + exit(1); + } +} + +template +T LinkedStack::GetTop(void) +{ + if (! IsEmpty()) + { + return top->data; + } + else + { + cout << "Stack Already Empty!" << endl; + getchar(); + exit(1); + } +} + +template +void LinkedStack::Clear(void) +{ + StackNode *temp = new StackNode(); + while (top) + { + temp = top; + top = top->next; + delete temp; + } +} + + +class Edge +{ +public: + int number; + int position; + char weight; + Edge *link; + Edge(); + Edge(int num, int pos, char ch); +}; +Edge::Edge() +{ + number = -1; + position = -1; + link = NULL; +} +Edge::Edge(int num, int pos, char ch) +{ + number = num; + position = pos; + weight = ch; + link = NULL; +} + + +class Vertex +{ +public: + int number; + Vertex *next; + Edge *out; + Vertex(); + Vertex(int num); +}; +Vertex::Vertex() +{ + number = -1; + next = NULL; + out = NULL; +} +Vertex::Vertex(int num) +{ + number = num; + next = NULL; + out = NULL; +} + + +class AdjacentTable +{ +private: + Vertex *startVertex; + int numOfVertices; + int numOfEdges; +public: + AdjacentTable(); + ~AdjacentTable(); + int GetValueByPos(int pos) const; + int GetPosByValue(int value) const; + char GetWeightByPos(int v1, int v2) const; + char GetWeightByValue(int value1, int value2) const; + void SetValue(int value, int pos); + void InsertVertex(int value); + void InsertEdgeByPos(int v1, int v2, char weight); + void InsertEdgeByValue(int value1, int value2, char weight); + void RemoveAllEdges(void); + void Clear(void); + int* Closure(int *T); + int* Move(int *T, char ch); + void OutputNFA(void); +}; + +AdjacentTable::AdjacentTable() +{ + numOfVertices = 1; + numOfEdges = 0; + startVertex = new Vertex(); +} + +AdjacentTable::~AdjacentTable() +{ + Vertex *p; + Edge *q; + p = startVertex; + for (int i=0; iout; + while (q) + { + p->out = q->link; + delete q; + q = p->out; + } + p = p->next; + } +} + +int AdjacentTable::GetValueByPos(int pos) const +{ + if ((pos >= 0) && (pos < numOfVertices)) + { + Vertex *p = startVertex; + for (int i=0; inext; + } + return p->number; + } + return -1; +} + +int AdjacentTable::GetPosByValue(int value) const +{ + Vertex *p = startVertex; + for (int i=0; inumber == value) + { + return i; + } + p = p->next; + } + return -1; +} + +char AdjacentTable::GetWeightByPos(int v1, int v2) const +{ + if ((v1 >= 0) && (v2 >= 0) && (v1 < numOfVertices) && (v2 < numOfVertices)) + { + Vertex *p = startVertex; + for (int i=0; inext; + } + Edge *q = p->out; + while (q) + { + if (q->position == v2) + { + return (q->weight); + } + else + { + q = q->link; + } + } + } + return '#'; +} + +char AdjacentTable::GetWeightByValue(int value1, int value2) const +{ + return GetWeightByPos(GetPosByValue(value1), GetPosByValue(value2)); +} + +void AdjacentTable::SetValue(int value, int pos) +{ + if ((pos < 0) || (pos >= numOfVertices)) + { + cout << "Illegal setting: The vertex doesn't exist!" << endl; + getchar(); + exit(1); + } + Vertex *p = startVertex; + for (int i=0; inext; + } + p->number = value; +} + +void AdjacentTable::InsertVertex(int value) +{ + int pos = GetPosByValue(value); + if ((pos >= 0) && (pos < numOfVertices)) + { + cout << "Illegal insertion: The same vertex has existed!" << endl; + getchar(); + exit(1); + } + Vertex *p = startVertex; + while (p->next) + { + p = p->next; + } + Vertex *newVertex = new Vertex(value); + p->next = newVertex; + numOfVertices++; +} + +void AdjacentTable::InsertEdgeByPos(int v1, int v2, char weight) +{ + if ((v1 < 0) || (v1 >= numOfVertices) || (v2 < 0) || (v2 >= numOfVertices)) + { + cout << "Illegal insertion: The vertex doesn't exist!" << endl; + getchar(); + exit(1); + } + Vertex *p = startVertex; + for (int i=0; inext; + } + Edge *q = p->out; + Edge *newEdge = new Edge(GetValueByPos(v2), v2, weight); + if (! q) + { + p->out = newEdge; + numOfEdges++; + return; + } + while ((q->position != v2) && (q->link)) + { + q = q->link; + } + if (q->position == v2) + { + cout << "Illegal insertion: The Edge has existed!" << endl; + getchar(); + exit(1); + } + if (! q->link) + { + q->link = newEdge; + numOfEdges++; + } +} + +void AdjacentTable::InsertEdgeByValue(int value1, int value2, char weight) +{ + int v1 = GetPosByValue(value1), v2 = GetPosByValue(value2); + InsertEdgeByPos(v1, v2, weight); +} + +void AdjacentTable::RemoveAllEdges(void) +{ + Vertex *p = startVertex; + for (int i=0; iout; + while (q) + { + p->out = q->link; + delete q; + q = p->out; + } + p = p->next; + } + numOfEdges = 0; +} + +void AdjacentTable::Clear(void) +{ + RemoveAllEdges(); + Vertex *p = startVertex->next; + while (p) + { + startVertex->next = p->next; + delete p; + p = startVertex->next; + } + numOfVertices = 1; +} + +int* AdjacentTable::Closure(int *T) +{ + int i = 0, j, k = 0, l, len = 0; + int *temp = new int[128]; + Vertex *p; + Edge *q; + while (T[len] != -1) + { + len++; + } + while (T[i] != -1) + { + for (l=0; lnext; + } + q = p->out; + while (q) + { + if (q->weight == '~') + { + for (l=0; lnumber == temp[l]) + { + break; + } + } + if (l == k) + { + temp[k] = q->number; + k++; + T[len++] = q->number; + T[len] = -1; + } + } + q = q->link; + } + i++; + } + temp[k] = -1; + return temp; +} + +int* AdjacentTable::Move(int *T, char ch) +{ + int i = 0, j, k = 0, l; + int *temp = new int[128]; + Vertex *p; + Edge *q; + while (T[i] != -1) + { + int pos = GetPosByValue(T[i]); + p = startVertex; + for (j=0; jnext; + } + q = p->out; + while (q) + { + if (q->weight == ch) + { + for (l=0; lnumber == temp[l]) + { + break; + } + } + if (l == k) + { + temp[k] = q->number; + k++; + } + } + q = q->link; + } + i++; + } + temp[k] = -1; + return temp; +} + +void AdjacentTable::OutputNFA(void) +{ + Vertex *p = startVertex; + Edge *q = new Edge(); + cout << "state edge(weight)" << endl; + for (int i=0; inumber; + if (p->number < 10) cout << " "; + else if (p->number < 100) cout << " "; + else if (p->number < 1000) cout << " "; + else cout << " "; + q = p->out; + if (q) + { + while (q) + { + cout << q->number << "(" << q->weight << ") "; + q = q->link; + } + } + else + { + cout << "END"; + } + cout << endl; + p = p->next; + } +} + + +class TransitionTable +{ +public: + TransitionTable(int rowNum, int colNum); + ~TransitionTable(); + void SetValue(int i, int j, int value); + int GetValue(int i, int j); + void Clear(void); +private: + int **matrix; + int rowNumber; + int colNumber; +}; + +TransitionTable::TransitionTable(int rowNum, int colNum) +{ + rowNumber = rowNum; + colNumber = colNum; + matrix = (int**)(new int*[rowNumber]); + for (int i=0; i Date: Thu, 26 Feb 2015 04:54:31 +0300 Subject: [PATCH 2/2] Wu_Junfeng_DFA --- wu_dfa/Makefile | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 wu_dfa/Makefile diff --git a/wu_dfa/Makefile b/wu_dfa/Makefile new file mode 100644 index 00000000..dcd7ecd --- /dev/null +++ b/wu_dfa/Makefile @@ -0,0 +1,4 @@ +all: + g++ wu_dfa.cpp -o wu_dfa +clean: + rm -f wu_dfa \ No newline at end of file