Data Structures In C

Great!

After some thought, I decided to change the rating of the book from 5 stars to 4. First, the good: The book is fairly well contained, and offers a complete introduction to data structures. The first two chapters review struct declarations and pointers in C. The rest of the book covers linked lists, stacks, queues, hash tables, matrices, trees, graphs, and sorting. The book is well written, and the chapters are very well organized. As with every technical subject, rereading a section once or twice will probably be necessary. But once it sinks in, it is a fantastic feeling! I think that the problems at the end of the chapter are extremely valuable. Some problems are simple drills, but others will require you to apply what you learned to solve real life problems. Some require you to come up with your own algorithms. In one problem, the author guides the reader toward making a "big number" library that can handle arbitrarily large integers. I found this problem particularly enlightening, and I felt very accomplished upon its completion. Now, for the bad: In my opinion, the author's coding style is a little sloppy. My biggest issue is that he doesn't emphasize the release of dynamically allocated memory. For example, in chapter 4, he includes the complete code needed to implement a stack data structure. However, he doesn't mention anything about creating a function that will release the dynamic memory. This occurs consistently in chapter 5, too. This book is meant to appeal to beginners, and beginners are especially likely to create memory leaks. The author should have addressed this issue. Secondly, a lot of the book's source code assumes that arrays start out with an index of 1. In C, of course, all array elements start with 0. While not technically wrong, it makes the whole story more complicated. Having to switch back and forth between the book's convention and that which C expects makes "off by 1" errors very likely. In addition, the author declares functions within other functions, and even defines functions in header .h files. While there is technically nothing wrong with either, it represents bad coding practice. The book is geared toward beginning programmers, and such a coding style sets a bad example. If the author fixes these small problems, then it will make the book perfect. Even with these small issues, I highly recommend you get this book if you want a light but complete introduction to data structures.

El libro, perfecto, llego dentro de los días previstos, pero de muy mal gusto que exista el costo oculto del débito de amazonprime, encima prime, quien quiere prime, algo que se acerca a lo delictual

This book has to be probably the best "first book" I've ever come across for anyone who wants to learn data structures! It does assume that you're at least a little familiar with programming and C (it doesn't go over the language syntax, and starts off going over structs and pointers, and then jumps right into linked lists), so if you're new to programming or C, I'd recommend picking up another book first before jumping into this one. The author makes everything very easy to understand, often listing out detailed steps in plain English to explain concepts first (without using formal pseudocode), along with diagrams, and then shows you the C code to implement them. However, the author never shows full source files, only snippets of code at a time, so if you're new to C and still figuring out how to program in it, it might be tricky figuring out how to order each snippet (like which ones go above others, as getting the ordering wrong will result in a compiler error). Although explanations aren't always detailed down to specifying everything about every step (like how the queue is re-ordered when using Dijkstra's algorithm to find SSSPs), they're consistently clear and easy to follow, in a tone that's never dry or pretentious - you won't find any "it is easy to see" in this book. ;) The fonts are nice and large as well, with the majority of the text in Times New Roman and source code in a Tahoma-like typeface. Plenty of whitespace as well, so pages don't look dense and are quick to read, and the book is just under 300 pages of material too, so anyone should be able to get through it relatively quickly, probably as short as a few weeks if you go through a little bit every day. The material also includes clear, basic plain-English explanations of the main graph algorithms that are commonly taught in an algorithms course, like depth-first search, breadth-first search, Dijkstra's, Bellman-Ford, Prim's, and Kruskal's. The explanations are so clear & easy to understand that I'd almost recommend the book for them alone, because a more advanced & mathematical book like CLRS (aka "Introduction to Algorithms" by Cormen, Leiserson, et al) explains less, which can be frustrating for those who'd be learning algorithms for the first time from that book. Highly recommended for those familiar with C looking to make the jump into a data structures book first, and eventually algorithms later on. In fact, I recommend it even more as a precursor to CLRS, which has a reputation as a difficult textbook (and most college-level algorithms courses use it).

The only way for me to describe Professor Kalicharan's style of writing and teaching is the following quote attributed to Albert Einstein: "Make everything as simple as possible, but not simpler". Simplicity and (crystal) clarity are his trademark. He just wants you to understand. But he won't dumb down the subject, nor he will get over wordy. He will just use the right explanation, the one that you will remember, and he will describe every step for you so you don't get lost. He will point out what's important; he will make you understand. The book is only 300 pages long but after reading it you will be able to pick up any other book on data structures (whatever the programming language used) and say "The explanation was clearer in Professor Kalicharan's book". The code is simple and clear, you can actually remember it, think about it and play with it - things you can't do with a Data Structures book using OOP where the implementation of the simplest data structure takes at least two pages. Who needs OOP to learn about linked lists, trees or graph? In my opinion OOP takes the fun out learning Data Structures. In this book you will find: Structures Pointers Linked lists Stacks and queues Binary trees Sorting (selection sort, insertion sort, heapsort, quicksort, mergesort, Shell sort) Graphs Hashing Working with matrices To really understand data structures you need to play with them, and to do so all you need is main() and a few others functions. All of them will happily stand in only one file. To understand data structures, to play with them you don't even need to bother yourself with "modular programming" even though the programs in the book are written using modular programming concepts. If you want to write bigger software, which is entirely another story, you will need to learn more about modularity, OOP, etc. This book is not about software engineering. It is about helping you to understand Data Structures and, for me, it is simply the best book for doing that.