Chapter 1: Why Data Structures Are Important
1.1 Data Structure 2
1.2 Arrays: Basic Data Structures 3
1.3 Speed ​​Measurement 5
1.4 Reading 6
1.5 Search 9
1.6 Insert 11
1.7 Delete 14
1.8 Sets: The Impact of a Single Rule on Efficiency 15
1.9 Final 19
1.10 Practice Problem 19

Chapter 2: Why Algorithms Matter 21
2.1 Ordered Arrays 22
2.2 Searching an ordered array 25
2.3 Binary Search 27
2.4 Binary Search vs. Linear Search 31
2.5 Finish 34
2.6 Practice Problem 34

Chapter 3 Big O Notation 35
3.1 Big O: How many steps does an algorithm need when there are N data elements? 36
3.2 The Essence of Big O 37
3.3 The third type of algorithm 40
3.4 log 42
3.5 Learn about O(log N) 43
3.6 Real-World Example 44
3.7 Final 46
3.8 Practice Problem 46

Chapter 4: Speeding Up Big O Code 49
4.1 Bubble Sort 49
4.2 Practical Uses of Bubble Sort 51
4.3 Efficiency of Bubble Sort 58
4.4 Quadratic Problem 60
4.5 Linear Solution 62
4.6 Finish 65
4.7 Practice Problem 65

Chapter 5 Optimization with and without Big O 67
5.1 Selection Sort 67
5.2 Practical Uses of Selection Sort 68
5.3 Efficiency of Selection Sort 75
5.4 Ignoring Constants 76
5.5 Big O Category 78
5.6 Finish 81
5.7 Practice Problem 82

Chapter 6 Optimization for Optimistic Scenarios 85
6.1 Insertion Sort 85
6.2 Practical Uses of Insertion Sort 87
6.3 Efficiency of Insertion Sort 94
6.4 Average case 96
6.5 Real-World Example 98
6.6 Wrapping Up 101
6.7 Practice Problem 101

Chapter 7 Big O's in Everyday Code 103
7.1 Even average 104
7.2 Word Generator 105
7.3 Array Sample 107
7.4 Average temperature 108 degrees Celsius
7.5 Clothing Brands 109
7.6 Counting the number of 1s 110
7.7 Palindrome Checker 111
7.8 Finding All Products 112
7.9 Handling Multiple Datasets 114
7.10 Password Cracker 115
7.11 Final 118
7.12 Practice Problem 118

Chapter 8: Super-Fast Lookups Using Hash Tables 123
8.1 Hash Table 124
8.2 Hashing with a Hash Function 125
8.3 Creating a Thesaurus for Fun and Profit, Especially Profit 126
8.4 Hash Table Lookup 128
8.5 Handling Collisions 130
8.6 Building an Efficient Hash Table 133
8.7 Hash Tables for Data Organization 135
8.8 Hash Tables for Speed ​​Improvement 137
8.9 Finish 142
8.10 Practice Problem 142

Chapter 9: Writing Concise Code with Stacks and Queues 145
9.1 Stack 145
9.2 Abstract Data Types 148
9.3 Practical Use of Stacks 150
9.4 Code Implementation: Stack-Based Code Linter 153
9.5 The Importance of Constrained Data Structures 156
9.6 Q 157
9.7 Practical Use of Queues 159
9.8 Finish 161
9.9 Practice Problem 161

Chapter 10 Recursive Iteration Using Recursion 163
10.1 Recursion Instead of Loops 163
10.2 Base Conditions 165
10.3 Reading Recursive Code 166
10.4 Recursion Through the Eyes of a Computer 169
10.5 Filesystem Traversal 172
10.6 Finish 174
10.7 Practice Problem 174

Chapter 11: Writing Recursively 177
11.1 Recursive Category: Repeated Execution 177
11.2 Recursive Categories: Computation 182
11.3 Top-Down Recursion: A New Way of Thinking 185
11.4 Staircase Problem 191
11.5 Creating Anagrams 195
11.6 Finish 199
11.7 Practice Problem 200

Chapter 12 Dynamic Programming 203
12.1 Unnecessary recursive calls 203
12.2 Small Improvements for Big O 207
12.3 Efficiency of Recursion 208
12.4 Duplicate Subproblem 209
12.5 Dynamic Programming with Memoization 211
12.6 Dynamic Programming via a Bottom-Up Approach 214
12.7 Finish 217
12.8 Practice Problem 217

Chapter 13: Speeding Up Recursive Algorithms 219
13.1 Split 220
13.2 Quick Sort 225
13.3 Efficiency of Quick Sort 232
13.4 Worst-case scenario for quick sort 237
13.5 Quick Select 238
13.6 Sorting, the Core of Other Algorithms 242
13.7 Finish 244
13.8 Practice Problem 244

Chapter 14 Node-Based Data Structures 247
14.1 Linked Lists 247
14.2 Implementing a Linked List 249
14.3 Reading 251
14.4 Search 254
14.5 Insert 255
14.6 Delete 259
14.7 Efficiency of Linked List Operations 262
14.8 Practical Uses of Linked Lists 262
14.9 Doubly Linked Lists 263
14.10 Doubly Linked List-Based Queues 266
14.11 Final 268
14.12 Practice Problem 268

Chapter 15: Speeding Up with Binary Search Trees 271
15.1 Tree 272
15.2 Binary Search Trees 274
15.3 Search 275
15.4 Insert 280
15.5 Delete 285
15.6 Practical Uses of Binary Search Trees 296
15.7 Binary Search Tree Traversal 296
15.8 Finish 301
15.9 Practice Problem 301

Chapter 16: Managing Priorities with Heaps 303
16.1 Priority Queue 303
16.2 Heap 305
16.3 Heap Properties 308
16.4 Heap Insertion 309
16.5 Finding the Last Node 311
16.6 Heap Deletion 312
16.7 Heaps vs. Ordered Arrays 316
16.8 Revisiting the Last Node Problem 317
16.9 Implementing a Heap with Arrays 319
16.10 Priority Queues Implemented with Heaps 326
16.11 Final 326
16.12 Practice Problem 327

Chapter 17: It Doesn't Hurt to Know Try 329
17.1 Try 330
17.2 Saving Words 332
17.3 Try Search 335
17.4 Efficiency of Trie Search 339
17.5 Try Insert 339
17.6 Developing an Auto-Complete Feature 344
17.7 Completing the Auto-Complete Feature 350
Trie with values ​​17.8: Improved auto-completion 350
17.9 Finish 352
17.10 Practice Problem 352

Chapter 18 Connecting Everything into One Graph 355
18.1 Graph 356
18.2 Directed Graphs 358
18.3 Object-Oriented Graph Implementation 359
18.4 Graph Exploration 361
18.5 Depth-First Search 363
18.6 Breadth-First Search 373
18.7 Efficiency of Graph Search 386
18.8 Weighted Graph 389
18.9 Dijkstra's Algorithm 393
18.10 Finish 410
18.11 Practice Problem 411

Chapter 19: Handling Space Constraints 415
19.1 The Big O of Space Complexity 415
19.2 Time and Space Tradeoffs 418
19.3 The Hidden Cost of Recursion 421
19.4 Finish 423
19.5 Practice Problem 424

Chapter 20 Code Optimization Techniques 427
20.1 Prerequisite: Understanding the Current Big O 427
20.2 Getting Started: The Biggest Big O You Can Imagine 428
20.3 Magic Views 429
20.4 Pattern Recognition 437
20.5 Greedy Algorithm 445
20.6 Changing Data Structures 457
20.7 Finish 464
20.8 Farewell 464
20.9 Practice Problem 465

Appendix A Practice Problems Answers 469
Search 505

It's not the algorithm that's difficult, it's the explanation.

Books explaining data structures and algorithms often contain repetitive technical terms and mathematical concepts, making them difficult for non-specialists or beginners.
However, most data structures and algorithms can be understood with common sense.
Mathematical notation is just a language, and everything dealt with in mathematics can be explained using common sense.
Now, let's understand data structures and algorithms simply with explanations that make sense and are similar to everyday language.

Understanding begins with words, learning begins with your fingertips.

Another reason why data structures and algorithms are difficult to learn is because of the theory-oriented explanations.
We've all had the experience of thinking we've read and understood something, only to find ourselves unable to code.
Conceptual understanding alone is not enough; true learning comes from learning while writing code.
Don't be lazy and just write code line by line to get a feel for the real world.

An introductory book for non-majors, but also useful for job seekers.

In a job interview, it's not just about getting the right answer.
You should be able to explain why you used this data structure, what its time complexity is, and why your chosen data structure is more efficient than other approaches.
With practical, real-world examples like password crackers, finding friends on social networks, finding the cheapest airline tickets, and library software, you can practice choosing data structures to maximize efficiency and improving existing algorithms to improve performance.

What this book covers

Why data structures and algorithms are important
○ Understanding algorithm efficiency using Big O notation
○Data structures that improve code efficiency
Recursive algorithms for elegant code
Node-based data structures boasting tremendous performance
○Space complexity to determine memory efficiency
○Some code optimization techniques

Target audience

○College students who find algorithms difficult to read
○Interviewers who are busy preparing for employment
○A practitioner who can code but lacks algorithms