typename SortedList<T, Pred>::Node* SortedList<T, Pred>::findMinNode(typename SortedList<T, Pred>::Node* current, typename SortedList<T, Pred>::Node* min, const Sorter &sorter)
{
if (current != tail_)
{
if (sorter(current->Data, min->Data))
{
return(findMinNode(current->Next, current, sorter));
}
else
{
return(findMinNode(current->Next, min, sorter));
}
}
return(min);
}
TreeNode *removeNode(TreeNode *node, int value)
{
if(!node)
{
printf("Element not found!\n");
return nullptr;
}
if(value < node->value)
node->left = removeNode(node->left, value);
else if(value > node->value)
node->right = removeNode(node->right, value);
else // equal
{
TreeNode *left = node->left;
TreeNode *right = node->right;
delete node;
if( !right )
return left;
TreeNode *min = findMinNode(right);
min->right = removeMinNode(right);
min->left = left;
return balanseNode(min);
}
return balanseNode(node);
}
void SortedList<T, Pred>::selection_sort(Sorter sorter)
{
SortedList<T, Pred>::Node* current = head_->Next;
while(current != tail_)
{
SortedList<T, Pred>::Node* temp = findMinNode(current, current, sorter);
swapNodes(current, temp);
current = temp->Next;
}
}
//return root
Node* deleteNode(Node *node, int key){
if(node == NULL) return NULL;
if(key < node->key){
node->left = deleteNode(node->left, key);
}
else if(key > node->key){
node->right = deleteNode(node->right, key);
}
else{
if(node->left == NULL && node->right == NULL){
free(node);
return NULL;
}
if(node->left == NULL || node->right == NULL){
Node *temp = node->right ? node->right : node->left;
*node = *temp;
free(temp);
} else {
Node *temp = findMinNode(node->right);
node->key = temp->key;
node->right = deleteNode(node->right, temp->key);
}
}
node->h = max(h(node->left), h(node->right))+1;
int balance = getBalance(node);
//left left
if(balance > 1 && getBalance(node->left) >= 0){
return rightRotate(node);
}
//left right
if(balance > 1 && getBalance(node->left) < 0){
node->left = leftRotate(node->left);
return rightRotate(node);
}
//right right
if(balance < -1 && getBalance(node->right) <= 0){
return leftRotate(node);
}
//right left
if(balance < -1 && getBalance(node->right) > 0){
node->right = rightRotate(node->right);
return leftRotate(node);
}
return node;
}
TreeNode* deleteNode(TreeNode* root, int key) {
if (!root) return NULL;
if (root->val < key) root->right = deleteNode(root->right, key);
else if (root->val > key) root->left = deleteNode(root->left, key);
else {
if (!root->right) return root->left;
else if (!root->left) return root->right;
else {
TreeNode* rightMin = findMinNode(root->right);
rightMin->left = root->left;
return root->right;
}
}
return root;
}
TreeNode* deleteNode(TreeNode* root, int key) {
if (!root) return NULL;
if (key < root->val) {
root->left = deleteNode(root->left, key);
} else if (key > root->val) {
root->right = deleteNode(root->right, key);
} else {
if (!root->left) return root->right;
else if (!root->right) return root->left;
TreeNode *node = findMinNode(root->right);
root->val = node->val;
root->right = deleteNode(root->right, root->val);
}
return root;
}
int main(int argc, char* argv[]){
char buffer[BUFFER_SIZE];
int index, pages;
int requests = 0;
int faults = 0;
if(argc < 1){
printf("Too many arguments. Please look at documentation to compile.\n");
return 0;
}
sscanf(argv[1], "%d", &pages);
List* list = create(pages);
FILE* fp = fopen("out.txt", "w");
assert(fp != NULL);
while(fgets(buffer, sizeof(buffer), stdin) != NULL) {
if(!isdigit((int)buffer[0]))
continue;
sscanf(buffer, "%d", &index);
requests++;
if(findNode(list, index) != NULL){
setNodeRef(list, index, requests);
}
else{
if(listFull(list)){
replaceNode(list, findMinNode(list), index);
setNodeRef(list, index, requests);
}
else{
insertNode(list, index, 0 ,0);
setNodeRef(list, index, requests);
}
faults++;
assert(fprintf(fp, "%d \n", index) >= 0);
}
} // while
fclose(fp);
free(list);
printf("Number of page requests: %d \nNumber of page faults: %d \n", requests, faults);
return 1;
}
iterator begin() const {
return iterator(m_root ? findMinNode(m_root) : nullptr);
}
TreeNode *findMinNode (TreeNode *node)
{
if (node->left)
return findMinNode(node->left);
return node;
}
AVLTree AVLDeleteElement(int element, AVLTree tree){
AVLTree node = tree;
bool found = false;
while (node) {
long diff = node->element - element;
if(diff == 0){
found = true;
break;
}
if(diff>0){
node = node->left;
}else{
node = node->right;
}
}
if(found){
AVLTree labelNode = NULL;
if(isLeafNode(node)){
//if leaf node, delete directly;
//not root node;
if(node->parent){
deConnect(node);
}else{
tree = NULL;
}
labelNode = node->parent;
free(node);
}else if(node->right){
AVLTree minNode = findMinNode(node->right);
node->element = minNode->element;
deConnect(minNode);
free(minNode);
labelNode = minNode->parent;
}else{
labelNode = node->parent;
if(labelNode){
connectParentAndSon(labelNode, node->left, 0);
}
if(!labelNode){
tree = node->left;
}
free(node);
}
//find the node, heigh maybe changed. -- labelNode;
if(labelNode){
//start from label, find which node need roate;
AVLTree adjustNode = getRotateNode(labelNode);
if(adjustNode){
AVLTree parentNode = NULL;
parentNode = adjustNode->parent;
long leftOrRight = leftOrRight = findWhichSon(parentNode, adjustNode);
AVLTree newNode = rotate(adjustNode);
if(leftOrRight != -1){
connectParentAndSon(parentNode, newNode, leftOrRight);
}else{
//after rotate, root changed;
tree = newNode;
}
}
}
}
return tree;
}
