From the Publisher:
Mark Allen Weiss provides a proven approach to algorithms and data structures using the exciting Java programming language as the implementation tool. With Java he highlights conceptual topics, focusing on ADTs and the analysis of algorithms for efficiency as well as performance and running time. Dr. Weiss also distinguishes this text with a logical organization of topics, his engaging writing style, and an extensive use of figures and examples showing the successive stages of an algorithm. 
Features:
Contains extensive sample code using Java 1.2, which is available over the Internet. Covers the Java Collections Library in an appendix. Includes a chapter on algorithm and design techniques that covers greedy algorithms, divide-and-conquer algorithms, dynamic programming, randomized algorithms, and backtracking. Presents current topics and new data structures such as Fibonacci heaps, skew heaps, binomial queues, skip lists, and splay trees. Offers a chapter on amortized analysis that examines the advanced data structures presented earlier in the book. Provides a chapter on advanced data structures and their implementation, covering red-black trees, top-down splay trees, treaps, k-d trees, pairing heaps, and more.

/pdf/data-structures-and-algorithm-analysis-in-c-sso9i21zsp.pdf

Data Structures and Algorithm Analysis in C

Two in-place variants of the classical mergesort algorithm are analysed in detail. The first, straightforward variant performs at most N log2 N + O(N) comparisons and 3N log2 N + O(N) moves to sort N elements. The second, more advanced variant requires at most N log2 N + O(N) comparisons and eN log2 N moves, for any fixed e > 0 and any N > N(e). In theory, the second one is superior to advanced versions of heapsort. In practice, due to the overhead in the index manipulation, our fastest in-place mergesort behaves still about 50 per cent slower than the bottom-up heapsort. However, our implementations are practical compared to mergesort algorithms based on in-place merging.

Practical in-place mergesort

Introducing a NEW addition to our growing library of computer science titles,Algorithm Design and Applications, by Michael T. Goodrich & Roberto Tamassia! Algorithms is a course required for all computer science majors, with a strong focus on theoretical topics. Students enter the course after gaining hands-on experience with computers, and are expected to learn how algorithms can be applied to a variety of contexts. This new book integrates application with theory. Goodrich & Tamassia believe that the best way to teach algorithmic topics is to present them in a context that is motivated from applications to uses in society, computer games, computing industry, science, engineering, and the internet. The text teaches students about designing and using algorithms, illustrating connections between topics being taught and their potential applications, increasing engagement.

Algorithm Design and Applications

The purpose of this paper is to introduce frameworks based on data-flow equations which estimate the worst-case execution time (WCET) of real-time programs. These frameworks allow several different WCET analysis techniques with various precisions, which range from naive approaches to exact analysis, provided exact knowledge on the program behavior is available. In addition, data-flow frameworks can also be used for symbolic analysis based on information derived automatically from the source code of the program.

/pdf/data-flow-frameworks-for-worst-case-execution-time-analysis-3a4485qnai.pdf

Data-Flow Frameworks for Worst-Case Execution Time Analysis

A window insert assembly is disclosed having a spring-biased frame construction used to secure the insert within existing window frames of varying size. The insert assembly is particularly useful for mounting interiorly of an existing window pane to form a "double pane" insulative window structure, i.e., by creating a thermal cavity between the interior side of the existing window pane and the window pane of the insert. The insert assembly comprises a solid pane, such as a glass pane, mounted in a first frame. The first frame is received within a second frame which has movable sides for changing the size of the second frame. Springs are provided between the second frame and the first frame, preferably on all four sides of the rectangular window insert assembly, which bias the second frame outwardly relative to the first frame. The size of the second frame is adjustable by pressing one or more sides against this bias to fit the insert within an existing window frame in which it is to be installed. Once in place within the window frame, the second frame is released. The spring bias presses the second frame sides into engagement with the window frame, creating a compression fit between the insert assembly and the window frame. The window insert assembly is readily installed without any tools, and is adjustable to fit varying size window frames.

The Ultimate Heapsort.

The analysis of heapsort

Heapsort is a classical sorting algorithm due to Williams. Given an array to sort, Heapsort first transforms the keys of the array into a heap. The heap is then sorted by repeatedly swapping the root of the heap with the last key in the bottom row, and then sifting this new root down to an appropriate position to restore heap order.
In Williams' original Heapsort, the new root is sifted down by repeatedly comparing its two children, and swapping it with its larger child if a comparison shows the child to be larger than the key being sifted. Floyd proposed an important variant of Williams' Heapsort which unconditionally performs the swap with the larger child.
This thesis analyzes the asymptotic number of executions of each instruction for both versions of Heapsort in the average, best, and worst cases.
In the average case, when sorting a uniformly generated random heap on N distinct keys, Williams' Heapsort performs $\sim$2N lg N key comparisons while Floyd's variant performs ${\sim}N$ lg N key comparisons (lg is the logarithm base two). Another quantity of interest is the number of times keys are swapped with their right children. Both Williams' and Floyd's versions of Heapsort expect to perform ${\sim}{1\over2}N$ lg N such swaps.
Sedgewick, and independently Fleischer and Wegener, have presented arguments to demonstrate that the number of key comparisons required by Williams' Heapsort in the best case and Floyd's Heapsort in the worst case are ${\sim}N$ lg N and ${\sim}{3\over2}N$ lg N respectively. These arguments are extended and applied in a different form to demonstrate that in the worst case, Williams' and Floyd's Heapsorts perform ${\sim}{3\over2}N$ lg N swaps of keys with their right children, while in the best case at most ${\sim}{1\over4}N$ lg N such swaps are performed. For both versions of Heapsort, it is shown that these best and worst case numbers can be found in heaps that also require the best and worst case numbers of key comparisons.

Russel Warren Schaffer

Papers

The analysis of heapsort

Analysis of heapsort