SHOW:
|
|
- or go back to the newest paste.
1 | #include <iostream> | |
2 | #include <string> | |
3 | #include <cassert> | |
4 | - | #include <cstdlib> |
4 | + | |
5 | - | #include <ctime> |
5 | + | |
6 | ||
7 | ||
8 | struct Qnode{ | |
9 | - | struct BST_Node { |
9 | + | string val; |
10 | - | string key; |
10 | + | Qnode* next; |
11 | - | // we'll ignore "stuff" |
11 | + | |
12 | - | string stuff; |
12 | + | |
13 | - | BST_Node* left; |
13 | + | struct Queue{ |
14 | - | BST_Node* right; |
14 | + | Qnode *first; |
15 | Qnode *last; | |
16 | }; | |
17 | - | typedef BST_Node* BST; |
17 | + | |
18 | struct PQnode{ | |
19 | - | void BST_init (BST& root) { |
19 | + | int priority; |
20 | - | root = NULL; |
20 | + | Queue q; |
21 | PQnode* next; | |
22 | ||
23 | - | bool BST_isEmpty(BST root) { |
23 | + | |
24 | - | return NULL == root; |
24 | + | |
25 | typedef PQnode* PQ; | |
26 | ||
27 | - | bool BST_has(string key, BST curNode) { |
27 | + | void initPQ (PQ& pq) { |
28 | - | if (BST_isEmpty(curNode)) { // i.e., NULL == ROOT |
28 | + | pq = NULL; |
29 | - | return false; |
29 | + | |
30 | - | } else if (key == curNode->key) { |
30 | + | |
31 | - | return true; |
31 | + | bool isEmptyPQ (const PQ& pq){ |
32 | - | } else if (key < curNode->key) { |
32 | + | return NULL == pq; |
33 | - | return BST_has (key,curNode->left); |
33 | + | |
34 | - | } else { |
34 | + | |
35 | - | return BST_has (key,curNode->right); |
35 | + | void enterPQ (PQ& pq, string val, int priority) { |
36 | Qnode *newQnode = new Qnode; | |
37 | newQnode->val = val; | |
38 | newQnode->next = NULL; | |
39 | - | BST BST_insert (string key, BST &curNode) { |
39 | + | if(isEmptyPQ(pq) || priority < pq->priority){ |
40 | - | if (NULL == curNode) { |
40 | + | PQnode *newpq = new PQnode; |
41 | - | curNode = new BST_Node; |
41 | + | newpq->priority = priority; |
42 | - | curNode->key = key; |
42 | + | newpq->next = NULL; |
43 | - | curNode->left = NULL; |
43 | + | newpq->q.first = newQnode; |
44 | - | curNode->right = NULL; |
44 | + | newpq->q.last = newQnode; |
45 | - | } else if (key == curNode->key) { |
45 | + | newpq->next = pq; |
46 | - | cerr << "duplicate key: " << key << endl; |
46 | + | pq = newpq; |
47 | - | assert(false); |
47 | + | |
48 | - | } else if (key < curNode->key) { |
48 | + | PQnode *temp = pq; |
49 | - | curNode->left = BST_insert (key,curNode->left); |
49 | + | while(temp->next!=NULL && temp->next->priority <= priority){ |
50 | - | } else { |
50 | + | temp = temp->next; |
51 | - | curNode->right = BST_insert(key,curNode->right); |
51 | + | |
52 | if(temp->priority == priority){ | |
53 | - | return curNode; |
53 | + | temp->q.last->next = newQnode; |
54 | temp->q.last = newQnode; | |
55 | }else{ | |
56 | - | void BST_print(BST curNode) { |
56 | + | PQnode *newpq = new PQnode; |
57 | - | if (curNode != NULL) { |
57 | + | newpq->priority = priority; |
58 | - | BST_print (curNode->left); |
58 | + | newpq->next = NULL; |
59 | - | cout << curNode->key << endl; |
59 | + | newpq->q.first = newQnode; |
60 | - | BST_print (curNode->right); |
60 | + | newpq->q.last = newQnode; |
61 | if(temp->next != NULL){ | |
62 | newpq->next = temp->next; | |
63 | } | |
64 | - | string BST_lookup (const BST& root, string key) { |
64 | + | temp->next = newpq; |
65 | - | if (BST_isEmpty(root)) { |
65 | + | |
66 | - | return ""; // or "ERROR", or ... umm ... |
66 | + | |
67 | - | } else if (key == root->key) { |
67 | + | |
68 | - | return root->stuff; |
68 | + | |
69 | - | } else if (key < root->key) { |
69 | + | string firstPQ (const PQ& pq){ |
70 | - | return BST_lookup (root->left, key); |
70 | + | assert (!isEmptyPQ(pq)); |
71 | - | } else { |
71 | + | return(pq->q.first->val); |
72 | - | return BST_lookup (root->right, key); |
72 | + | |
73 | ||
74 | void leavePQ (PQ& pq) { | |
75 | assert (!isEmptyPQ(pq)); | |
76 | - | void BST_delete(string key, BST& tree) { |
76 | + | if(pq->q.first->next == NULL){ |
77 | - | assert (!BST_isEmpty(tree)); |
77 | + | PQnode *temppq = pq; |
78 | - | BST_Node *previousNode = tree; |
78 | + | pq=pq->next; |
79 | - | BST_Node *deleteNode = tree; |
79 | + | delete temppq->q.first; |
80 | delete temppq; | |
81 | - | while(deleteNode != NULL && key != deleteNode->key){ |
81 | + | |
82 | - | if (key < deleteNode->key) { |
82 | + | Qnode *temp = pq->q.first; |
83 | - | previousNode = deleteNode; |
83 | + | pq->q.first = pq->q.first->next; |
84 | - | deleteNode = deleteNode->left; |
84 | + | delete temp; |
85 | - | } else { |
85 | + | |
86 | - | previousNode = deleteNode; |
86 | + | |
87 | - | deleteNode = deleteNode->right; |
87 | + | int sizePQ (const PQ& pq) { |
88 | if (isEmptyPQ(pq)) { | |
89 | return 0; | |
90 | - | if (NULL == deleteNode) { |
90 | + | |
91 | - | return; |
91 | + | int numPQ = 0; |
92 | PQnode *temp = pq; | |
93 | - | if(deleteNode->left == NULL && deleteNode->right == NULL){ |
93 | + | while(temp!= NULL){ |
94 | - | // cout << "Test: " << previousNode->left->key << deleteNode->key; |
94 | + | Qnode *tempQ = temp->q.first; |
95 | - | if(tree->key == deleteNode->key){ |
95 | + | //cout << "Blah: " << tempQ->val << endl; |
96 | - | tree = NULL; |
96 | + | while(tempQ!=NULL){ |
97 | - | }else if(previousNode->left != NULL && previousNode->left->key == deleteNode->key){ |
97 | + | //cout << tempQ->val << endl; |
98 | - | previousNode->left=NULL; |
98 | + | numPQ++; |
99 | tempQ = tempQ->next; | |
100 | - | previousNode->right=NULL; |
100 | + | |
101 | temp = temp->next; | |
102 | - | delete deleteNode; |
102 | + | |
103 | - | }else if(deleteNode->left == NULL && deleteNode->right != NULL){ |
103 | + | return numPQ; |
104 | - | if(tree->key == deleteNode->key){ |
104 | + | |
105 | - | tree = deleteNode->right; |
105 | + | |
106 | - | }else if(previousNode->left != NULL && previousNode->left->key == deleteNode->key){ |
106 | + | int sizeByPriority (const PQ& pq, int priority) { |
107 | - | previousNode->left = deleteNode->right; |
107 | + | if (isEmptyPQ(pq)) { |
108 | - | }else if(previousNode->right != NULL && previousNode->right->key == deleteNode->key){ |
108 | + | return 0; |
109 | - | previousNode->right = deleteNode->right; |
109 | + | |
110 | int numPQ = 0; | |
111 | - | delete deleteNode; |
111 | + | PQnode *temp = pq; |
112 | - | }else if(deleteNode->right == NULL && deleteNode->left != NULL){ |
112 | + | while(temp->next!=NULL && temp->next->priority <= priority){ |
113 | - | if(tree->key == deleteNode->key){ |
113 | + | temp = temp->next; |
114 | - | tree = deleteNode->left; |
114 | + | |
115 | - | }else if(previousNode->right != NULL && previousNode->right->key == deleteNode->key){ |
115 | + | if (NULL == temp || temp->priority != priority) { |
116 | - | previousNode->right = deleteNode->left; |
116 | + | return 0; |
117 | - | }else if(previousNode->left != NULL && previousNode->left->key == deleteNode->key){ |
117 | + | |
118 | - | previousNode->left = deleteNode->left; |
118 | + | Qnode *tempQ = temp->q.first; |
119 | while(tempQ!=NULL){ | |
120 | - | delete deleteNode; |
120 | + | numPQ ++; |
121 | tempQ = tempQ->next; | |
122 | - | BST_Node *switchNode = deleteNode->left; |
122 | + | |
123 | - | BST_Node *previousSwitchNode = deleteNode; |
123 | + | return numPQ; |
124 | - | while(switchNode->right != NULL){ |
124 | + | |
125 | - | previousSwitchNode = switchNode; |
125 | + | |
126 | - | switchNode = switchNode->right; |
126 | + | int numPriorities (const PQ& pq) { |
127 | if (isEmptyPQ(pq)) { | |
128 | return 0; | |
129 | - | if(deleteNode->key == previousSwitchNode->key){ |
129 | + | |
130 | - | //previousSwitchNode->left = switchNode->left; |
130 | + | int numPQ = 0; |
131 | - | switchNode->right = deleteNode->right; |
131 | + | PQnode *temp = pq; |
132 | - | if(tree->key == deleteNode->key){ |
132 | + | while(temp!=NULL){ |
133 | - | tree = switchNode; |
133 | + | numPQ ++; |
134 | - | delete deleteNode; |
134 | + | temp = temp->next; |
135 | - | }else{ |
135 | + | |
136 | - | if(previousNode->left == NULL || previousNode->left->key == deleteNode->key){ |
136 | + | return numPQ; |
137 | - | previousNode->left = switchNode; |
137 | + | |
138 | - | }else if(previousNode->right == NULL || previousNode->right->key == deleteNode->key){ |
138 | + | |
139 | - | previousNode->right = switchNode; |
139 | + | void CGprint(const PQ& pq){ |
140 | - | } |
140 | + | PQ temp=pq; |
141 | - | delete deleteNode; |
141 | + | while(temp!=NULL){ |
142 | //cout<<"priority "<<temp->priority<<". Priority size: "<<sizeByPriority(pq, temp->priority)<<" :"<<endl; | |
143 | Qnode* iter=temp->q.first; | |
144 | - | previousSwitchNode->right = switchNode->left; |
144 | + | while(iter!=NULL){ |
145 | - | switchNode->left = deleteNode->left; |
145 | + | cout<<iter->val<<endl; |
146 | - | switchNode->right = deleteNode->right; |
146 | + | iter=iter->next; |
147 | - | if(tree->key == deleteNode->key){ |
147 | + | |
148 | - | tree = switchNode; |
148 | + | temp=temp->next; |
149 | - | delete deleteNode; |
149 | + | |
150 | - | }else{ |
150 | + |