You might find Data Structures and Algorithm Analysis, by Clifford A. Shaffer, to be helpful. There are versions for C++ and Java available. (The 3rd edition is old already [2013], and the prior editions were titled A Practical Introduction to Data Structures and Algorithm Analysis.)

It does get very in-depth into the field, including the mathematics involved in analysis and proofs. That said, however, my first read through it (2nd Ed.) was very helpful in many ways, and I didn't then know anything about C++.

As a 2013 book, some of the coding might be in a style or format which is no longer considered "best practice." This is likely more true for the manner in which Object Oriented Programming is utilized than for the syntactical style. The material, discussion, and analysis are still as valid as ever.

The link above is to the author's page where the PDF versions are available, along with many resources to accompany the book. Of course, if you must have a dead-tree version, they are still available, new and used, from places such as Amazon.

The author has stopped updating the PDF and print versions of the book in favor of an online version. I have not experimented with the online version, although a quick peek at it leads me to believe that it is available for "in-class" use and for independent study. As such, it might be more useful to you than the PDF version.

As a caution, I've also seen a 4th Edition with the same title, but by a different author. It may, or may not, be an updated version of the same book, done with the original author's help and blessings. Having never read the 4th Edition I cannot say if it's connected at all.

To give a better idea of the content, and layout, of the book, I am listing an abridged version of the books Table of Contents.

Contents

I Preliminaries

1. Data Structures and Algorithms
   • A Philosophy of Data Structures (The Need for Data Structures :: Costs and Benefits) | Abstract Data Types and Data Structures | Design Patterns (Flyweight :: Visitor :: Composite :: Strategy) | Problems, Algorithms, and Programs
2. Mathematical Preliminaries
   • Sets and Relations | Miscellaneous Notation | Logarithms | Summations and Recurrences | Recursion | Mathematical Proof Techniques (Direct Proof :: Proof by Contradiction :: Proof by Mathematical Induction) | Estimation
3. Algorithm Analysis
   • Introduction | Best, Worst, and Average Cases | A Faster Computer, or a Faster Algorithm? | Asymptotic Analysis (Upper Bounds :: Lower Bounds :: Θ Notation :: Simplifying Rules :: Classifying Functions) | Calculating the Running Time for a Program | Analyzing Problems | Common Misunderstandings | Multiple Parameters | Space Bounds 3.10 Speeding Up Your Programs 3.11 Empirical Analysis

II Fundamental Data Structures

4. Lists, Stacks, and Queues
   • Lists (Array-Based List Implementation :: Linked Lists :: Comparison of List Implementations :: Element Implementations :: Doubly Linked Lists) | Stacks (Array-Based Stacks :: Linked Stacks :: Comparison of Array-Based and Linked Stacks :: Implementing Recursion) | Queues (Array-Based Queues :: Linked Queues :: Comparison of Array-Based and Linked Queues) | Dictionaries
5. Binary Trees
   • Definitions and Properties (The Full Binary Tree Theorem :: A Binary Tree Node ADT) | Binary Tree Traversals | Binary Tree Node Implementations (Pointer-Based Node Implementations :: Space Requirements :: Array Implementation for Complete Binary Trees) | Binary Search Trees | Heaps and Priority Queues | Huffman Coding Trees (Building Huffman Coding Trees :: Assigning and Using Huffman Codes :: Search in Huffman Trees)
6. Non-Binary Trees
   • General Tree Definitions and Terminology (An ADT for General Tree Nodes :: General Tree Traversals) | The Parent Pointer Implementation | General Tree Implementations (List of Children :: The Left-Child/Right-Sibling Implementation :: Dynamic Node Implementations :: Dynamic “Left-Child/Right-Sibling” Implementation) | K-ary Trees | Sequential Tree Implementations

III Sorting and Searching

7. Internal Sorting
   • Sorting Terminology and Notation | Three Θ(n2) Sorting Algorithms (Insertion Sort :: Bubble Sort :: Selection Sort :: The Cost of Exchange Sorting) | Shellsort | Mergesort | Quicksort | Heapsort | Binsort and Radix Sort | An Empirical Comparison of Sorting Algorithms | Lower Bounds for Sorting
8. File Processing and External Sorting
   • Primary versus Secondary Storage | Disk Drives (Disk Drive Architecture :: Disk Access Costs) | Buffers and Buffer Pools | The Programmer’s View of Files | External Sorting (Simple Approaches to External Sorting :: Replacement Selection :: Multiway Merging)
9. Searching
   • Searching Unsorted and Sorted Arrays | Self-Organizing Lists | Bit Vectors for Representing Sets | Hashing (Hash Functions :: Open Hashing :: Closed Hashing :: Analysis of Closed Hashing :: Deletion)
10. Indexing

• Linear Indexing | ISAM | Tree-based Indexing | 2-3 Trees | B-Trees (B+ -Trees :: B-Tree Analysis)

IV Advanced Data Structures

11. Graphs

• Terminology and Representations | Graph Implementations | Graph Traversals (Depth-First Search :: Breadth-First Search :: Topological Sort) | Shortest-Paths Problems (Single-Source Shortest Paths) | Minimum-Cost Spanning Trees (Prim’s Algorithm :: Kruskal’s Algorithm)

12. Lists and Arrays Revisited

• Multilists | Matrix Representations | Memory Management (Dynamic Storage Allocation :: Failure Policies and Garbage Collection)

13. Advanced Tree Structures

• Tries | Balanced Trees (The AVL Tree :: The Splay Tree) | Spatial Data Structures (The K-D Tree :: The PR quadtree :: Other Point Data Structures :: Other Spatial Data Structures)

V Theory of Algorithms

14. Analysis Techniques

• Summation Techniques | Recurrence Relations (Estimating Upper and Lower Bounds :: Expanding Recurrences :: Divide and Conquer Recurrences :: Average-Case Analysis of Quicksort) | Amortized Analysis

15. Lower Bounds

• Introduction to Lower Bounds Proofs | Lower Bounds on Searching Lists (Searching in Unsorted Lists :: Searching in Sorted Lists) | Finding the Maximum Value | Adversarial Lower Bounds Proofs | State Space Lower Bounds Proofs | Finding the ith Best Element | Optimal Sorting

16. Patterns of Algorithms

• Dynamic Programming (The Knapsack Problem :: All-Pairs Shortest Paths) | Randomized Algorithms (Randomized algorithms for finding large values :: Skip Lists) | Numerical Algorithms (Exponentiation :: Largest Common Factor :: Matrix Multiplication :: Random Numbers :: The Fast Fourier Transform)

17. Limits to Computation

• Reductions | Hard Problems (The Theory of N P-Completeness :: N P-Completeness Proofs :: Coping with N P-Complete Problems) | Impossible Problems (Uncountability :: The Halting Problem Is Unsolvable)

(source: wikimedia.org)

Don't buy any book use

MIT OCW

.