Hands-On Data Structures and Algorithms with Python: Write complex and powerful code using the latest features of Python 3.7, 2nd Edition

Cover
Title Page
Copyright and Credits
Dedication
Packt Upsell
Contributors
Acknowledgments
Table of Contents
Preface
Chapter 1: Python Objects, Types, and Expressions
	Technical requirements
	Installing Python
	Understanding data structures and algorithms
		Python for data
		The Python environment
		Variables and expressions
		Variable scope
	Flow control and iteration
	Overview of data types and objects
		Strings
		Lists
			Functions as first class objects
		Higher order functions
		Recursive functions
	Generators and co-routines
		Classes and object programming
		Special methods
			Inheritance
			Data encapsulation and properties
	Summary
	Further reading
Chapter 2: Python Data Types and Structures
	Technical requirements
	Built-in data types
	None type
	Numeric types
	Representation error
	Membership, identity, and logical operations
	Sequences
	Learning about tuples
	Beginning with dictionaries
		Python
	Sorting dictionaries
	Dictionaries for text analysis
	Sets
		Immutable sets
	Modules for data structures and algorithms
		Collections
			Deques
			ChainMap objects
			Counter objects
			Ordered dictionaries
			defaultdict
			Learning about named tuples
			Arrays
	Summary
Chapter 3: Principles of Algorithm Design
	Technical requirements
	An introduction to algorithms
		Algorithm design paradigms
	Recursion and backtracking
		Backtracking
			Divide and conquer – long multiplication
			The recursive approach
		Runtime analysis
			Asymptotic analysis
	Big O notation
		Composing complexity classes
			Omega notation (Ω)
			Theta notation (ϴ )
		Amortized analysis
	Summary
Chapter 4: Lists and Pointer Structures
	Technical requirements
	Beginning with an example
	Arrays
	Pointer structures
		Nodes
			Finding endpoints
		Node class
			Other node types
	Introducing lists
		Singly linked lists
			Singly linked list class
			The append operation
			A faster append operation
			Getting the size of the list
			Improving list traversal
			Deleting nodes
			List search
			Clearing a list
		Doubly linked lists
			A doubly linked list node
			Doubly linked list class
			Append operation
			The delete operation
			List search
		Circular lists
			Appending elements
			Deleting an element in a circular list
			Iterating through a circular list
	Summary
Chapter 5: Stacks and Queues
	Technical requirements
	Stacks
		Stack implementation
		Push operation
		Pop operation
		Peek operation
		Bracket-matching application
	Queues
		List-based queues
			The enqueue operation
			The dequeue operation
		Stack-based queues
			Enqueue operation
			Dequeue operation
		Node-based queues
			Queue class
			The enqueue operation
			The dequeue operation
		Application of queues
			Media player queues
	Summary
Chapter 6: Trees
	Technical requirements
	Terminology
	Tree nodes
	Tree traversal
		Depth-first traversal
			In-order traversal and infix notation
			Pre-order traversal and prefix notation
			Post-order traversal and postfix notation
		Breadth-first traversal
	Binary trees
		Binary search trees
		Binary search tree implementation
		Binary search tree operations
			Finding the minimum and maximum nodes
		Inserting nodes
		Deleting nodes
		Searching the tree
		Benefits of a binary search tree
		Balancing trees
		Expression trees
			Parsing a reverse Polish expression
	Heaps
	Ternary search tree
	Summary
Chapter 7: Hashing and Symbol Tables
	Technical requirements
	Hashing
		Perfect hashing functions
	Hash tables 
		Storing elements in a hash table
		Retrieving elements from the hash table
		Testing the hash table
		Using [] with the hash table
		Non-string keys
		Growing a hash table
		Open addressing
		Chaining
	Symbol tables
	Summary
Chapter 8: Graphs and Other Algorithms
	Technical requirements
	Graphs
	Directed and undirected graphs
	Weighted graphs
	Graph representations
		Adjacency lists
		Adjacency matrices
	Graph traversals
		Breadth-first traversal 
		Depth-first search
	Other useful graph methods
	Priority queues and heaps
		Insert operation
		Pop operation
		Testing the heap
	Selection algorithms
	Summary
Chapter 9: Searching
	Technical requirements
	Introduction to searching
		Linear search
		Unordered linear search
		Ordered linear search
	Binary search
	Interpolation search
		Choosing a search algorithm
	Summary
Chapter 10: Sorting
	Technical requirements
	Sorting algorithms
	Bubble sort algorithms
	Insertion sort algorithms
	Selection sort algorithms
	Quick sort algorithms
		List partitioning
			Pivot selection
		An illustration with an example
		Implementation
	Heap sort algorithms
	Summary
Chapter 11: Selection Algorithms
	Technical requirements
	Selection by sorting
	Randomized selection
		Quick select
			Understanding the partition step
	Deterministic selection
		Pivot selection
		Median of medians
		Partitioning step
	Summary
Chapter 12: String Algorithms and Techniques
	Technical requirements
	String notations and concepts
	Pattern matching algorithms
		The brute-force algorithm
		The Rabin-Karp algorithm
			Implementing the Rabin-Karp algorithm
		The Knuth-Morris-Pratt algorithm
			The prefix function
			Understanding KMP algorithms
			Implementing the KMP algorithm
		The Boyer-Moore algorithm
			Understanding the Boyer-Moore algorithm
			Bad character heuristic
			Good suffix heuristic
			Implementing the Boyer-Moore algorithm
	Summary
Chapter 13: Design Techniques and Strategies
	Technical requirements
	Classification of algorithms
		Classification by implementation
			Recursion
			Logic
			Serial or parallel algorithms
			Deterministic versus nondeterministic algorithms
		Classification by complexity
			Complexity curves
		Classification by design
			Divide and conquer
			Dynamic programming
			Greedy algorithms
	Technical implementation
		Implementation using dynamic programming
			Memoization
			Tabulation
		The Fibonacci series
			The memoization technique
			The tabulation technique
		Implementation using divide and conquer
			Divide
			Conquer
			Merge
			Merge sort
		Implementation using greedy algorithms
			Coin-counting problem
			Shortest path algorithm
	Complexity classes
		P versus NP
		NP-Hard
		NP-Complete
	Summary
Chapter 14: Implementations, Applications, and Tools
	Technical requirements
	Knowledge discovery in data
	Data preprocessing
		Processing raw data
		Missing data
		Feature scaling
			Min-max scalar form of normalization
			Standard scalar
			Binarizing data
	Learning about machine learning
		Types of machine learning
		The hello classifier
		A supervised learning example
			Gathering data
			Bag of words
			Prediction
		An unsupervised learning example
			K-means algorithm
			Prediction
	Data visualization
		Bar chart
		Multiple bar charts
		Box plot
		Pie chart
		Bubble chart
	Summary
Other Books You May Enjoy
Index