Give each of the four page replacement algorithms a name and a brief explanation. How about contrasting them?

Need assistance with the following...   Consider the pattern “ST:TOS” and the following text: OVERALL,ILIKEST:TOSBEST.BUTIFYOUIGNORETHEFIRST4SEASONS,ST:TNGISBETTERTHANST:TOS. Give the trace of the Boyer-Moore algorithm and circle the characters in the pattern that getscompared with the text. Be sure to indicate bad symbol or good suffix decisions.

Consider the following recursive mergesort algorithm (another classic divide and conquer algorithm). Mergesort was first described by John Von Neumann in 1945. The basic idea is to divide an unsorted list x of m elements into two sublists of about half the size of the original list. Repeat this operation on each sublist, and continue until we have lists of size 1 in length. Then starting with sublists of length 1, "merge" the two sublists into a single sorted list. Mergesort (m) var list left, right, result if length (m) ≤ 1 return m else var middle = length (m) / 2 for each x in m up to middle add x to left for each x in m after middle add x to right left = Mergesort (left) right = Mergesort (right) result = Merge(left, right) return result

Discuss the trade-offs between using a dictionary and a hash table for implementing a symbol table in a compiler or interpreter.

We discussed several Linked List Variations, each of which was more complex than the one preceding it, but that was able to do certain things asymptotically faster than the simpler variants could. This is one of many examples we'll see this quarter where we make a classic tradeoff in computing: using more memory (and, correspondingly, more complexity for managing what it's in it) in an effort to spend less time. While it's not always true that we can make things faster by using more memory, it's not at all uncommon to see these two things be on opposite sides of a tradeoff. One of the linked list variants we saw was a singly-linked list with head and tail pointers. Let's consider where this variant fell short and whether there are other ways to improve it besides what we saw. 1. Why isn't the presence of a tail pointer enough to allow us to remove the last node in the list in O(1) time? 2. Suppose that we added a third list-level pointer (i.e., outside of the nodes) called before Tail,…

Compare the sorting durations of the insertion sort and QuickSort using a tiny array (less than 20). What is the time difference? Could you clarify why? Compare the sorting durations of the insertion sort and QuickSort using a tiny array (less than 20). What is the time difference? Could you clarify why?Compare the sorting durations of the insertion sort and QuickSort using a tiny array (less than 20). What is the time difference? Could you clarify why?

Implement two versions of the successor function for the 8-puzzle: one that generates all the successors at once by copying and editing the 8-puzzle data structure, and one that generates one new successor each time it is called and works by modifying the parent state directly (and undoing the modifications as needed). Write versions of iterative deepening depth-first search that use these functions and compare their performance.

Write an essay contrasting the pluses and minuses of skipping the list.

Comparing the Unsorted and Sorted Linked List implementations, the "Put Item" overall seems to be less efficient for the Sorted List. Why is this?

In your essay, discuss the advantages and disadvantages of bypassing the skip list.