Data Structures, Search and Sort Algorithms

1 / 20

# Data Structures, Search and Sort Algorithms - PowerPoint PPT Presentation

Data Structures, Search and Sort Algorithms. Kar-Hai Chu [email protected] Data structures. Storage Insertion, deletion Searching Sorting Big O. Stacks. LIFO Push, pop O(1) operations. Linked lists v. Arrays. Linked lists: Resizable Insertion/deletion Arrays: Faster index

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'Data Structures, Search and Sort Algorithms' - fidelio

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### Data Structures, Search and Sort Algorithms

Kar-Hai Chu

[email protected]

Data structures
• Storage
• Insertion, deletion
• Searching
• Sorting
• Big O
Stacks
• LIFO
• Push, pop
• O(1) operations
• Resizable
• Insertion/deletion
• Arrays:
• Faster index
• O(1) lookup
• Preset size
Hash tables
• Keys and values
• O(1) lookup
• Hash function
• Good v fast
• Clustering
• Databases
Selection sort :-(
• O(n2)
• Algorithm:
• Find the minimum value
• Swap with 1st position value
• Repeat with 2nd position down
Insertion sort :-)
• O(n2)
• O(1) space
• Great with small number of elements (becomes relevant later)
• Algorithm:
• Move element from unsorted to sorted list
Bubble sort :-(
• O(n2)
• Algorithm:
• Iterate through each n, and sort with n+1 element
• Maybe go n-1 steps every iteration?
• Great for big numbers, bad for small
• Totally useless?
Merge sort :-)
• O(nlogn)
• Requires O(n) extra space
• Parallelizable
• Algorithm:
• Break list into 2 sublists
• Sort sublist
• Merge
Quick sort :-)
• Average O(nlogn), worst O(n2)
• O(n) extra space (can optimized for O(logn))
• Algorithm:
• pick a pivot
• put all x < pivot in less, all x > pivot in more
• Concat and recurse through less, pivot, and more
• Advantages also based on caching, registry (single pivot comparison)
• Variations: use fat pivot
Linear search :-(
• O(n)
• Examines every item
Binary search :-)
• Requires a sorted list
• O(log n)
• Divide and conquer
Trees
• Traverse: Pre-order v. Post-order v. In-order
• Node, edge, sibling/parent/child, leaf
Binary trees
• 0, 1, or 2 children per node
• Binary Search Tree: a binary tree where node.left_child < node.value and node.right_child >= node.value
Balanced binary trees
• Minimizes the level of nodes
• Compared with “bad” binary tree?
• Lookup, insertion, removal: O(log n)
Heaps (binary)
• Complete: all leafs are at n or n-1, toward the left
• Node.value >= child.value
• In binary min/max heap
• Insert = O(logn) .. add to bottom, bubble-up
• deleteMax = O(logn) .. Move last to root and bubble-down
Heapsort
• O(nlogn)
• Algorithm:
• Build a heap
• deleteMax (or Min) repeatedly
Why bother?
• Tries (say trees)
• Position determines the key
• Great for lots of short words
• Prefix matching
• But..
• Long strings..
• Complex algorithms
Chess!
• Minimax:
• Alpha-beta pruning - pick a bag!
• ordering
Useful
• http://www.cs.pitt.edu/~kirk/cs1501/animations/Sort3.html