<p>At my school we do use Carrano and Henry, <a href="https://www.pearson.com/us/higher-education/program/Carrano-Data-Abstraction-Problem-Solving-with-C-Walls-and-Mirrors-7th-Edition/PGM333670.html" rel="nofollow noreferrer">Data Abstraction &amp; Problem Solving with C++: Walls and Mirrors</a>.</p>
<p>The <a href="https://en.wikipedia.org/wiki/Walls_and_Mirrors" rel="nofollow noreferrer">Walls and Mirrors</a> series has been in publication since 1986, and over the years has seen editions in Pascal, Modula-2, C++, and Java. (Most recent editions in C++.) In 2018 it won the McGuffey Longevity Award ​for​​ ​textbooks whose excellence has been demonstrated over time.</p>

CC BY-SA 4.0
2020-07-01T07:54:40.460Z
2020-07-01T11:50:58.247Z
2020-07-01T11:50:58.247Z
Daniel R. Collins
<p>You might find <em><a href="http://people.cs.vt.edu/%7Eshaffer/Book" rel="nofollow noreferrer">Data Structures and Algorithm Analysis</a></em>, by <a href="http://people.cs.vt.edu/%7Eshaffer/" rel="nofollow noreferrer">Clifford A. Shaffer</a>, to be helpful. There are versions for C++ and Java available. (The 3rd edition is old already [2013], and the prior editions were titled <em>A Practical Introduction to Data Structures and Algorithm Analysis</em>.)</p>
<p>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++.</p>
<p>As a 2013 book, some of the coding might be in a style or format which is no longer considered &quot;best practice.&quot; 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.</p>
<hr />
<p>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.</p>
<p>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 &quot;in-class&quot; use and for independent study. As such, it might be more useful to you than the PDF version.</p>
<p>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.</p>
<hr />
<p>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.</p>
<h2>Contents</h2>
<h3>I  Preliminaries</h3>
<ol>
<li>Data Structures and Algorithms
<ul>
<li>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</li>
</ul>
</li>
<li>Mathematical Preliminaries
<ul>
<li>Sets and Relations | Miscellaneous Notation | Logarithms | Summations and Recurrences | Recursion | Mathematical Proof Techniques (Direct Proof :: Proof by Contradiction :: Proof by Mathematical Induction) | Estimation</li>
</ul>
</li>
<li>Algorithm Analysis
<ul>
<li>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</li>
</ul>
</li>
</ol>
<h3>II Fundamental Data Structures</h3>
<ol start="4">
<li>Lists, Stacks, and Queues
<ul>
<li>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</li>
</ul>
</li>
<li>Binary Trees
<ul>
<li>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)</li>
</ul>
</li>
<li>Non-Binary Trees
<ul>
<li>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</li>
</ul>
</li>
</ol>
<h3>III Sorting and Searching</h3>
<ol start="7">
<li>Internal Sorting
<ul>
<li>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</li>
</ul>
</li>
<li>File Processing and External Sorting
<ul>
<li>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)</li>
</ul>
</li>
<li>Searching
<ul>
<li>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)</li>
</ul>
</li>
<li>Indexing</li>
</ol>
<ul>
<li>Linear Indexing | ISAM | Tree-based Indexing | 2-3 Trees | B-Trees (B+ -Trees :: B-Tree Analysis)</li>
</ul>
<h3>IV  Advanced Data Structures</h3>
<ol start="11">
<li>Graphs</li>
</ol>
<ul>
<li>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)</li>
</ul>
<ol start="12">
<li>Lists and Arrays Revisited</li>
</ol>
<ul>
<li>Multilists | Matrix Representations | Memory Management (Dynamic Storage Allocation :: Failure Policies and Garbage Collection)</li>
</ul>
<ol start="13">
<li>Advanced Tree Structures</li>
</ol>
<ul>
<li>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)</li>
</ul>
<h3>V Theory of Algorithms</h3>
<ol start="14">
<li>Analysis Techniques</li>
</ol>
<ul>
<li>Summation Techniques | Recurrence Relations (Estimating Upper and Lower Bounds :: Expanding Recurrences :: Divide and Conquer Recurrences :: Average-Case Analysis of Quicksort) | Amortized Analysis</li>
</ul>
<ol start="15">
<li>Lower Bounds</li>
</ol>
<ul>
<li>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</li>
</ul>
<ol start="16">
<li>Patterns of Algorithms</li>
</ol>
<ul>
<li>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)</li>
</ul>
<ol start="17">
<li>Limits to Computation</li>
</ol>
<ul>
<li>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)</li>
</ul>

CC BY-SA 4.0
2020-06-29T09:47:48.717Z
2020-06-29T09:47:48.717Z
Gypsy Spellweaver
<p>I am a student from CS background. I am currently going through <em><strong>&quot;Introduction to Algorithms&quot;</strong></em> By Cormen et. al.</p>
<p><span class="math-container">$\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad$</span><a href="https://i.sstatic.net/RNZUB.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/RNZUB.png" alt="CLRS" /></a></p>
<p>It is indeed a classic and a master-piece from the four authors. Each and every algorithm in it is written in the simplest manner possible. Each and every algorithms have analysis involved in a hardcore manner. Thought it is a fantastic book on algorithm design and analysis and many sources recommend it for data structures as well but I find that the data structures section is quite less in the above book.</p>
<hr />
<p>I have gone through the data structure book below :</p>
<p><span class="math-container">$\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad$</span><a href="https://i.sstatic.net/lHPA4.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/lHPA4.png" alt="Data structures using C and C++ by Tanenbaum et. al" /></a></p>
<p><em><strong>Data structures using C and C++ by Tanenbaum et. al</strong></em></p>
<p>Though the above book deals with the various topics of data structure I found that many of the implementations of the data structures and their manipulation algorithms have been made unnecessarily complex and it took quite a lot of time to understand certain pieces of codes which otherwise could have been written in a much more elegant manner. This makes it difficult to recall the algorithms in the text which is far beyond intuition at some places. Though the book contains algorithms of the data structure manipulations but at most places the hardcore analysis is missing.</p>
<hr />
<p>So could any one recommend me a book on data structure which is as elegant as CLRS , simple and lucid, which would help me for myself study. Even if it does not revolve around any particular programming language - it is fine, but if it does it would it be good if the language is a modern one and not the older ones like PASCAL, FORTRAN,... (although even in CLRS 2nd edition they follow the PASCAL like pseudo-code structure, but it is fine as long as it does not go into the nicks and nacks of the features special to these vintage languages)</p>

CC BY-SA 4.0
2020-07-03T15:42:00.733Z
What about doing a course in Coursera?
Enamul Hassan
CC BY-SA 4.0
2020-07-03T17:01:24.440Z
yes you can consider as none can beat the knowledge acquired from a video lecture series and the corresponding book followed in the video lecture series, it lasts forever. As you are having an instructor whom you can play or pause or rewind if you cannot understand the topic. However the corresponding book followed by the instructor is definitely required for greater in-depth everlasting knowledge. If you only watch video lecture, you shall understand the things at great depth , but it stays only temporarily and then you forget. For an everlasting effect, frequent brush up is required I hope
Abhishek Ghosh
<self-learning><resource-request><textbook>
Book recommendations for self studying Data Structures in depth in an elegant manner
# Book recommendations for self studying Data Structures in depth in an elegant manner

(Asked by: username_0 on 2020-06-28)

I am a student from CS background. I am currently going through ***"Introduction to Algorithms"*** By Cormen et. al.

$\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad$[![CLRS](https://i.sstatic.net/RNZUB.png)](https://i.sstatic.net/RNZUB.png)

It is indeed a classic and a master-piece from the four authors. Each and every algorithm in it is written in the simplest manner possible. Each and every algorithms have analysis involved in a hardcore manner. Thought it is a fantastic book on algorithm design and analysis and many sources recommend it for data structures as well but I find that the data structures section is quite less in the above book.

---

I have gone through the data structure book below :

$\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad$[![Data structures using C and C++ by Tanenbaum et. al](https://i.sstatic.net/lHPA4.png)](https://i.sstatic.net/lHPA4.png)

***Data structures using C and C++ by Tanenbaum et. al***

Though the above book deals with the various topics of data structure I found that many of the implementations of the data structures and their manipulation algorithms have been made unnecessarily complex and it took quite a lot of time to understand certain pieces of codes which otherwise could have been written in a much more elegant manner. This makes it difficult to recall the algorithms in the text which is far beyond intuition at some places. Though the book contains algorithms of the data structure manipulations but at most places the hardcore analysis is missing.

---

So could any one recommend me a book on data structure which is as elegant as CLRS , simple and lucid, which would help me for myself study. Even if it does not revolve around any particular programming language - it is fine, but if it does it would it be good if the language is a modern one and not the older ones like PASCAL, FORTRAN,... (although even in CLRS 2nd edition they follow the PASCAL like pseudo-code structure, but it is fine as long as it does not go into the nicks and nacks of the features special to these vintage languages)

**Tags:** self-learning, resource-request, textbook

> **Comments:**
> **username_1**: What about doing a course in Coursera?  
> **username_0**: yes you can consider as none can beat the knowledge acquired from a video lecture series and the corresponding book followed in the video lecture series, it lasts forever. As you are having an instructor whom you can play or pause or rewind if you cannot understand the topic. However the corresponding book followed by the instructor is definitely required for greater in-depth everlasting knowledge. If you only watch video lecture, you shall understand the things at great depth , but it stays only temporarily and then you forget. For an everlasting effect, frequent brush up is required I hope  

---

## 2 answers

### Answer by username_2 on 2020-07-01. Score: 3

At my school we do use Carrano and Henry, [Data Abstraction & Problem Solving with C++: Walls and Mirrors](https://www.pearson.com/us/higher-education/program/Carrano-Data-Abstraction-Problem-Solving-with-C-Walls-and-Mirrors-7th-Edition/PGM333670.html).

The [Walls and Mirrors](https://en.wikipedia.org/wiki/Walls_and_Mirrors) series has been in publication since 1986, and over the years has seen editions in Pascal, Modula-2, C++, and Java. (Most recent editions in C++.) In 2018 it won the McGuffey Longevity Award ​for​​ ​textbooks whose excellence has been demonstrated over time.


---

### Answer by username_3 on 2020-06-29. Score: 3

You might find *[Data Structures and Algorithm Analysis](http://people.cs.vt.edu/%7Eshaffer/Book)*, by [Clifford A. Shaffer](http://people.cs.vt.edu/%7Eshaffer/), 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)


---

