--The difficulty of things is far less than the fear of things!
data structure! Many people should be afraid of data structures and algorithms . From this point of view, data structures and algorithms are not important, and they have already been used. Many people think so, and there is only one reason: his own knowledge is not enough! But for an engineer, bypassing data structures and algorithms and dreaming of writing high-quality code is like a music student who wants to bypass music theory and play Chopin and Beethoven directly. The possibility is basically zero. Except, hahahaha. Some people will feel that they actually write code, as if they don’t need any data structures and algorithms . They just use the code of the predecessors + the two familiar keys on the keyboard, and they can run it after changing it. They are very happy and happy. However, I think that learning data structures and algorithms is like running and exercising every day. You may not see any changes in one or two days. However, the spirit has been slowly integrated into your body, and the changes are imperceptible. Similarly, the foundation of data structures and algorithms is also subtly affecting the quality of the code you write. There is no martial arts master who is not strong in internal strength, and he can dominate the martial arts by relying on Huaquan and embroidering his legs!
This series is called "The Protracted War on Data Structures and Algorithms (C++ Version)". The reason why it is called On Protracted War is that, in my opinion, data structures and algorithms can never be learned. , The spirit of Yugong moving mountains. The second is because the code is written in C++, hahahaha. Less gossip, old rules, more precipitation, less impetuous! Start the catalogue!
Campaign 1: The gate of the advanced master
Campaign 2: The Art of Data
Campaign 3: The Soul of the First Knowing Program
Campaign 4: Trial of the Procedural Soul
Battle 5: Time Complexity of the Algorithm
Campaign 6: Efficiency Metrics for Algorithms
Campaign 7: Relaxing Moments
Campaign 8: Introduction to Reflective Programming
Battle 9: Smart Pointer Example
Campaign 10: Introduction to C++ Exceptions
Campaign 11: Anomaly Class Construction
Campaign 12: Creation of the top-level parent class
Campaign 13: Evolution of the Class Family Structure
Battle 14: Essential Operations on Linear Tables
Battle 15: Sequential Storage Structure for Linear Tables
Battle 16: Abstract Implementation of Sequential Storage Structures
Campaign 17: StaticList and DynamicList
Battle 18: Analysis of Sequentially Stored Linear Tables
Battle 19: Creation of Array Classes (Part 1)
Battle 20: Creation of Array Classes (Part 2)
Battle 21: Chained storage structure for linear tables
Battle 22: The Concrete Implementation of Singly Linked List
Battle 23: Comparative Analysis of Sequence List and Singly Linked List
Battle 24: Traversal optimization of a singly linked list
Battle 25: Implementation of a Static Singly Linked List
Campaign 26: Analysis of Typical Problems
Battle 27: Rediscussion on Smart Pointers (Part 1)
Battle 28: Rediscussion on Smart Pointers (Part 2)
Battle 29: Implementation of Circular Linked List
Battle 30: Implementation of Doubly Linked List
Battle 31: Two Macros of the Old Testament (Linux)
Battle 32: Analysis of Linux Kernel Linked List
Battle 33: Implementation of Doubly Circular Linked List
Battle 34: Concept and Implementation of Stack (Part 1)
Battle 35: Concept and Implementation of Stack (Part 2)
Battle 36: Concept and Implementation of Queue (Part 1)
Battle 37: Concept and Implementation of Queue (Part 2)
Campaign 38: Two interesting questions
Battle 39: Creation of String Class (Part 1)
Battle 40: Creation of String Class (Part 2)
Battle 41: KMP Substring Search Algorithm
Battle 42: KMP algorithm application
Battle 43: The Thought and Application of Recursion (Part 1)
Battle 44: The Thought and Application of Recursion (Part 2)
Battle 45: The Thought and Application of Recursion (Part 2)
Campaign 46: Basic Concepts of Sorting
Campaign 47: Selection Sort and Insertion Sort
Battle 48: Bubble Sort and Hill Sort
Battle 49: Merge Sort and Quick Sort
Campaign 50: Examples of Engineering Applications of Sorting
Campaign 51: Definition and Manipulation of Trees
Battle 52: Storage Structure and Implementation of Trees
Campaign 53: Find operations for nodes in a tree
Battle 54: Insertion of Nodes in Trees
Campaign 55: Clearing of Nodes in the Tree
Battle 56: Deletion of a Node in a Tree
Battle 57: Implementation of Attribute Operations in Trees
Battle 58: Hierarchical Traversal of Tree Structures
Battle 59: Tree to Binary Tree Conversion
Battle 60: Deep Properties of Binary Trees
Battle 61: Storage Structure Design of Binary Tree
Battle 62: Node search operation in binary tree
Battle 63: Node Insertion in Binary Tree
Battle 64: Node Deletion and Clearing in Binary Tree
Battle 65: Implementation of Attribute Operations in Binary Trees
Battle 66: Hierarchical Traversal of Binary Trees
Battle 67: Typical way of traversing a binary tree
Battle 68: Comparison and Addition of Binary Trees
Battle 69: Threaded Implementation of Binary Tree
Battle 70: Analysis of classic binary tree interview questions
Campaign 71: Definition and Operation of Graphs
Battle 72: Graph Storage Structure (Part 1)
Battle 73: Graph Storage Structure (Part 2)
Campaign 74: Traversal of Graphs (BFS)
Campaign 75: Traversal of Graphs (DFS)
Campaign 76: Minimum Spanning Tree (Prim)
Campaign 77: Minimum Spanning Tree (Kruskal)
Battle 78: The Shortest Path (Dijkstra)
Campaign 79: The Shortest Path (Floyd)
Battle 80: The Longest No Descending Sequence (End)