Line segment intersection (I): Orthogonal line segment intersection. Computational Geometry [csci 3250] Laura Toma Bowdoin College
|
|
|
- Marsha Parks
- 5 years ago
- Views:
Transcription
1 Line segment intersection (I): Orthogonal line segment intersection Computational Geometry [csci 3250] Laura Toma Bowdoin College
2 Outline The problem (what) Applications (why) Algorithms (how) A special case: Orthogonal line segments General case: Bentley-Otman line sweep algorithm
3 Line segment intersection Problem: Given a set of line segments in 2D, find all their pairwise intersections.
4 Line segment intersection Problem: Given a set of line segments in 2D, find all their pairwise intersections.
5 Line segment intersection Problem: Given a set of line segments in 2D, find all their pairwise intersections. +
6 Line segment intersection: Applications
7 Applications Graphics: rendering => hidden surfaces ==> intersections
8 Applications Motion planning and collision detection in autonomous systems/robotics R
9 Applications Geographic data: River networks, road networks, railways,..
10 Applications Map overlay in GIS from:
11 Applications Map overlay in GIS from:
12 Applications Geographic data: River networks, road networks, railways,..
13 Computing line segment intersection: Algorithms
14 Naive Notation n: size of the input (number of segments) k: size of output (number of intersections) Problem: Given a set of n line segments in 2D, find all their pairwise intersections. Class work: Give upper and lower bounds for k, draw examples that achieve these bounds. Give a straightforward algorithm that computes all intersections and analyze its running time. Give scenarios when this algorithm is efficient/inefficient. What is your intuition of an upper bound for this problem? (how fast would you hope to be able to solve it?)
15 A special case: Orthogonal line segment intersection Problem: Given a set of orthogonal line segments in 2D, find all their pairwise intersections.
16 A special case: Orthogonal line segment intersection Problem: Given a set of orthogonal line segments in 2D, find all their pairwise intersections. Exercises Come up with a straightforward algorithm and analyze its time Can you do better?
17 Balanced Binary Search Trees - crash course -
18 Binary Search Trees (BST) Operations insert delete search successor, predecessor traversals (in order,..) min, max
19 Balanced Binary Search Trees (BBST) Binary search trees + invariants that constrain the tree to be balanced (and thus have logarithmic height) These invariants have to be maintained when inserting and deleting we can think of the tree as self-balancing BBST variants red-black trees AVL trees B-trees (a,b) trees
20 Example: Red-Black trees Binary search tree, and Each node is Red or Black The children of a Red node must be Black The number of Black nodes on any path from the root to any node that does not have two children must be the same Note: easier to conceptualize the tree as containing explicit NULL leaves, all Black the number of Black nodes on any root-to-leaf path must be the same
21 Example: Red-Black trees Theorem: A Red-Black tree of n nodes has height Theta( lg n).
22 Example: Red-Black trees Theorem: After an insertion or a deletion, the RB tree invariants can be maintained in additional O(lg n) time. This is done by performing rotations and recoloring nodes on the path from the inserted/deleted node to the root.
23 Binary Search Trees Operations insert delete search successor, predecessor traversals (in order,..) min, max range search (1D)
24 1D Range Searching Given a set of values P = {x1, x2, x3, xn } Pre-process it in order to answer rangesearch(a,b): return all elements in P in interval (a,b) a b
25 1D Range Searching Given a set of values P = {x1, x2, x3, xn } Pre-process it in order to answer rangesearch(a,b): return all elements in P in interval (a,b) If P is static a P is known ahead and does not change b
26 1D Range Searching Given a set of values P = {x1, x2, x3, xn } Pre-process it in order to answer rangesearch(a,b): return all elements in P in interval (a,b) a b If P is static sort, then binary search for a and walk. O( lg n + k) per query
27 1D Range Searching Given a set of values P = {x1, x2, x3, xn } Pre-process it in order to answer rangesearch(a,b): return all elements in P in interval (a,b) If P is dynamic use a BBST a P changes by adding and deleting values b
28 1D range searching with Binary Search Trees Example: range_search(21, 53): return 21, 34, 35, 46, 51,
29 1D range searching with Binary Search Trees Example: range_search(21, 53): return 21, 34, 35, 46, 51,
30 1D range searching with Binary Search Trees Example: range_search(21, 53): return 21, 34, 35, 46, 51,
31 1D range searching with Binary Search Trees Example: range_search(21, 53): return 21, 34, 35, 46, 51,
32 1D Range Searching with Red-Black Trees Example: range_search(10, 16): return 11, 13,
33 1D range searching with Binary Search Trees Range search (a,b): a b
34 1D range searching with Binary Search Trees Range search (a,b): Can be answered in O( lg n+k), where k = O(n) is the size of output a b
35 Balanced Binary Search Trees - end -
36 Orthogonal line segment intersection
37 Orthogonal line segment intersection Events beginning of a horizontal segment end of a horizontal segment vertical segment Let X be the set of x-coordinates of all segments: these are the events xstart xend x
38 Orthogonal line segment intersection line sweep technique Events: Let X be the set of x-coordinates of all segments. Sort X. Traverse the events in sorted order
39 Orthogonal line segment intersection 1 line sweep technique Events: Let X be the set of x-coordinates of all segments. Sort X. Traverse the events in sorted order
40 Orthogonal line segment intersection 2 line sweep technique Events: Let X be the set of x-coordinates of all segments. Sort X. Traverse the events in sorted order
41 Orthogonal line segment intersection line sweep technique 3 Events: Let X be the set of x-coordinates of all segments. Sort X. Traverse the events in sorted order
42 Orthogonal line segment intersection line sweep technique 4 Events: Let X be the set of x-coordinates of all segments. Sort X. Traverse the events in sorted order
43 Orthogonal line segment intersection 5 line sweep technique Events: Let X be the set of x-coordinates of all segments. Sort X. Traverse the events in sorted order
44 Orthogonal line segment intersection Line sweep technique Traverse events in order and maintain an Active Structure (AS) AS contains objects that are active (started but not ended) in other words they are intersected by the current sweep line at some events, insert in AS at some events, delete from AS at some events, query AS Events beginning of a horizontal segment end of a horizontal segment vertical segment
45 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
46 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
47 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
48 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
49 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
50 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
51 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
52 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
53 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
54 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
55 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
56 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
57 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active AS=? in order to do this efficiently delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
58 Orthogonal line segment intersection Let X be the set of x-coordinates of all segments //the events Initialize AS = {} Pick an example and simulate the algorithm How do you implement the AS? Analysis? Sort X and traverse the events in sorted order; let x be the next event in X if x is start of horizontal segment (x, x, y): //segment becomes active insert segment (x,x,y) in AS if x is end of horizontal segment (x, x, y): //segment stops being active delete segment (x,x,y) from AS if x corresponds to a vertical segment (y, y,x): //All active segments start before x and end after x. We need those whose y is in [y,y ] search AS for all segments with y-value in given range [y,y ] and report intersections
59 d e b f c a
60 Line sweep
61 Line sweep algorithms Powerful, elegant, frequently used technique Line can be horizontal or vertical or radial or. Traverse events in order and maintain an Active Structure (AS) AS contains objects that are active (started but not ended) in other words they are intersected by the current sweep line at some events, insert in AS at some events, delete from AS at some events, query AS
Orthogonal line segment intersection. Computational Geometry [csci 3250] Laura Toma Bowdoin College
![Orthogonal line segment intersection. Computational Geometry [csci 3250] Laura Toma Bowdoin College](/thumbs/81/84720426.jpg "Orthogonal line segment intersection. Computational Geometry [csci 3250] Laura Toma Bowdoin College")
Orthogonal line segment intersection Computational Geometry [csci 3250] Laura Toma Bowdoin College Line segment intersection The problem (what) Applications (why) Algorithms (how) A special case: Orthogonal
Orthogonal line segment intersection
Computtionl Geometry [csci 3250] Line segment intersection The prolem (wht) Computtionl Geometry [csci 3250] Orthogonl line segment intersection Applictions (why) Algorithms (how) A specil cse: Orthogonl
Computational Geometry [csci 3250]
![Computational Geometry [csci 3250]](/thumbs/81/83356206.jpg "Computational Geometry [csci 3250]")
Computational Geometry [csci 3250] Laura Toma Bowdoin College Range Trees The problem Given a set of n points in 2D, preprocess into a data structure to support fast range queries. The problem n: size
CS350: Data Structures Red-Black Trees
Red-Black Trees James Moscola Department of Engineering & Computer Science York College of Pennsylvania James Moscola Red-Black Tree An alternative to AVL trees Insertion can be done in a bottom-up or
Sorted Arrays. Operation Access Search Selection Predecessor Successor Output (print) Insert Delete Extract-Min
Binary Search Trees FRIDAY ALGORITHMS Sorted Arrays Operation Access Search Selection Predecessor Successor Output (print) Insert Delete Extract-Min 6 10 11 17 2 0 6 Running Time O(1) O(lg n) O(1) O(1)
CMPS 2200 Fall 2017 Red-black trees Carola Wenk
CMPS 2200 Fall 2017 Red-black trees Carola Wenk Slides courtesy of Charles Leiserson with changes by Carola Wenk 9/13/17 CMPS 2200 Intro. to Algorithms 1 Dynamic Set A dynamic set, or dictionary, is a
Range searching. with Range Trees
Range searching Computational Geometry [csci 3250] Range searching with Range Trees Given a set of points, preprocess them into a data structure to support fast range queries. 2D Laura Toma Bowdoin College
Module 4: Index Structures Lecture 13: Index structure. The Lecture Contains: Index structure. Binary search tree (BST) B-tree. B+-tree.
The Lecture Contains: Index structure Binary search tree (BST) B-tree B+-tree Order file:///c /Documents%20and%20Settings/iitkrana1/My%20Documents/Google%20Talk%20Received%20Files/ist_data/lecture13/13_1.htm[6/14/2012
Balanced Binary Search Trees. Victor Gao
Balanced Binary Search Trees Victor Gao OUTLINE Binary Heap Revisited BST Revisited Balanced Binary Search Trees Rotation Treap Splay Tree BINARY HEAP: REVIEW A binary heap is a complete binary tree such
Lecture 6: Analysis of Algorithms (CS )
Lecture 6: Analysis of Algorithms (CS583-002) Amarda Shehu October 08, 2014 1 Outline of Today s Class 2 Traversals Querying Insertion and Deletion Sorting with BSTs 3 Red-black Trees Height of a Red-black
Heaps. Heapsort. [Reading: CLRS 6] Laura Toma, csci2000, Bowdoin College
![Heaps. Heapsort. [Reading: CLRS 6] Laura Toma, csci2000, Bowdoin College](/thumbs/71/65822704.jpg "Heaps. Heapsort. [Reading: CLRS 6] Laura Toma, csci2000, Bowdoin College")
Heaps. Heapsort. [Reading: CLRS 6] Laura Toma, csci000, Bowdoin College So far we have discussed tools necessary for analysis of algorithms (growth, summations and recurrences) and we have seen a couple
Search Trees. Undirected graph Directed graph Tree Binary search tree
Search Trees Undirected graph Directed graph Tree Binary search tree 1 Binary Search Tree Binary search key property: Let x be a node in a binary search tree. If y is a node in the left subtree of x, then
Computational Geometry. Lecture 17
Computational Geometry Lecture 17 Computational geometry Algorithms for solving geometric problems in 2D and higher. Fundamental objects: Basic structures: point line segment line point set polygon L17.2
CMPS 2200 Fall 2015 Red-black trees Carola Wenk
CMPS 2200 Fall 2015 Red-black trees Carola Wenk Slides courtesy of Charles Leiserson with changes by Carola Wenk 9/9/15 CMPS 2200 Intro. to Algorithms 1 ADT Dictionary / Dynamic Set Abstract data type
Data Structures and Algorithms CMPSC 465
Data Structures and Algorithms CMPSC 465 LECTURE 24 Balanced Search Trees Red-Black Trees Adam Smith 4/18/12 A. Smith; based on slides by C. Leiserson and E. Demaine L1.1 Balanced search trees Balanced
Algorithms. Deleting from Red-Black Trees B-Trees
Algorithms Deleting from Red-Black Trees B-Trees Recall the rules for BST deletion 1. If vertex to be deleted is a leaf, just delete it. 2. If vertex to be deleted has just one child, replace it with that
Red-Black Trees. Based on materials by Dennis Frey, Yun Peng, Jian Chen, and Daniel Hood
Red-Black Trees Based on materials by Dennis Frey, Yun Peng, Jian Chen, and Daniel Hood Quick Review of Binary Search Trees n Given a node n... q All elements of n s left subtree are less than n.data q
Lecture: Analysis of Algorithms (CS )
Lecture: Analysis of Algorithms (CS583-002) Amarda Shehu Fall 2017 1 Binary Search Trees Traversals, Querying, Insertion, and Deletion Sorting with BSTs 2 Example: Red-black Trees Height of a Red-black
Treaps. 1 Binary Search Trees (BSTs) CSE341T/CSE549T 11/05/2014. Lecture 19
CSE34T/CSE549T /05/04 Lecture 9 Treaps Binary Search Trees (BSTs) Search trees are tree-based data structures that can be used to store and search for items that satisfy a total order. There are many types
Motivation for B-Trees
1 Motivation for Assume that we use an AVL tree to store about 20 million records We end up with a very deep binary tree with lots of different disk accesses; log2 20,000,000 is about 24, so this takes
Range Reporting. Range Reporting. Range Reporting Problem. Applications
Philip Bille Problem problem. Preprocess at set of points P R 2 to support report(x1, y1, x2, y2): Return the set of points in R P, where R is rectangle given by (x1, y1) and (x2, y2). Applications Relational
Algorithms for GIS:! Quadtrees
Algorithms for GIS: Quadtrees Quadtree A data structure that corresponds to a hierarchical subdivision of the plane Start with a square (containing inside input data) Divide into 4 equal squares (quadrants)
CS 372: Computational Geometry Lecture 3 Line Segment Intersection
CS 372: Computational Geometry Lecture 3 Line Segment Intersection Antoine Vigneron King Abdullah University of Science and Technology September 9, 2012 Antoine Vigneron (KAUST) CS 372 Lecture 3 September
Quiz 1 Solutions. (a) f(n) = n g(n) = log n Circle all that apply: f = O(g) f = Θ(g) f = Ω(g)
Introduction to Algorithms March 11, 2009 Massachusetts Institute of Technology 6.006 Spring 2009 Professors Sivan Toledo and Alan Edelman Quiz 1 Solutions Problem 1. Quiz 1 Solutions Asymptotic orders
We assume uniform hashing (UH):
We assume uniform hashing (UH): the probe sequence of each key is equally likely to be any of the! permutations of 0,1,, 1 UH generalizes the notion of SUH that produces not just a single number, but a
Advanced Algorithm Design and Analysis (Lecture 12) SW5 fall 2005 Simonas Šaltenis E1-215b
Advanced Algorithm Design and Analysis (Lecture 12) SW5 fall 2005 Simonas Šaltenis E1-215b simas@cs.aau.dk Range Searching in 2D Main goals of the lecture: to understand and to be able to analyze the kd-trees
CS 3343 Fall 2007 Red-black trees Carola Wenk
CS 3343 Fall 2007 Red-black trees Carola Wenk Slides courtesy of Charles Leiserson with small changes by Carola Wenk CS 334 Analysis of Algorithms 1 Search Trees A binary search tree is a binary tree.
Planar convex hulls (I) Computational Geometry [csci 3250] Laura Toma Bowdoin College
![Planar convex hulls (I) Computational Geometry [csci 3250] Laura Toma Bowdoin College](/thumbs/86/93358306.jpg "Planar convex hulls (I) Computational Geometry [csci 3250] Laura Toma Bowdoin College")
Planar convex hulls (I) Computational Geometry [csci 3250] Laura Toma Bowdoin College Convex Hull Given a set P of points in 2D, their convex hull is the smallest convex polygon that contains all points
Algorithms. AVL Tree
Algorithms AVL Tree Balanced binary tree The disadvantage of a binary search tree is that its height can be as large as N-1 This means that the time needed to perform insertion and deletion and many other
CSE2331/5331. Topic 6: Binary Search Tree. Data structure Operations CSE 2331/5331
CSE2331/5331 Topic 6: Binary Search Tree Data structure Operations Set Operations Maximum Extract-Max Insert Increase-key We can use priority queue (implemented by heap) Search Delete Successor Predecessor
Lecture 3 February 9, 2010
6.851: Advanced Data Structures Spring 2010 Dr. André Schulz Lecture 3 February 9, 2010 Scribe: Jacob Steinhardt and Greg Brockman 1 Overview In the last lecture we continued to study binary search trees
Theory & Algorithms 15/01/04. Red-Black Trees. Nicolas Wack, Sylvain Le Groux
Theory & Algorithms Red-Black Trees 15/01/04 Nicolas Wack, Sylvain Le Groux Balanced search trees Balanced search tree: A search-tree data structure for which a height of O(lg n) is guaranteed when implementing
CS 251, LE 2 Fall MIDTERM 2 Tuesday, November 1, 2016 Version 00 - KEY
CS 251, LE 2 Fall 2016 MIDTERM 2 Tuesday, November 1, 2016 Version 00 - KEY W1.) (i) Show one possible valid 2-3 tree containing the nine elements: 1 3 4 5 6 8 9 10 12. (ii) Draw the final binary search
Chapter 12 Advanced Data Structures
Chapter 12 Advanced Data Structures 2 Red-Black Trees add the attribute of (red or black) to links/nodes red-black trees used in C++ Standard Template Library (STL) Java to implement maps (or, as in Python)
CS 758/858: Algorithms
CS 758/858: Algorithms http://www.cs.unh.edu/~ruml/cs758 1 handout: slides Wheeler Ruml (UNH) Class 7, CS 758 1 / 16 BST Deletion Single Child Immed. Succ. Deep Succ. Break Wheeler Ruml (UNH) Class 7,
CSE2331/5331. Topic 7: Balanced search trees. Rotate operation Red-black tree Augmenting data struct. CSE 2331/5331
CSE2331/5331 Topic 7: Balanced search trees Rotate operation Red-black tree Augmenting data struct. Set Operations Maximum Extract-Max Insert Increase-key Search Delete Successor Predecessor Motivation
CIS265/ Trees Red-Black Trees. Some of the following material is from:
CIS265/506 2-3-4 Trees Red-Black Trees Some of the following material is from: Data Structures for Java William H. Ford William R. Topp ISBN 0-13-047724-9 Chapter 27 Balanced Search Trees Bret Ford 2005,
Computational Optimization ISE 407. Lecture 16. Dr. Ted Ralphs
Computational Optimization ISE 407 Lecture 16 Dr. Ted Ralphs ISE 407 Lecture 16 1 References for Today s Lecture Required reading Sections 6.5-6.7 References CLRS Chapter 22 R. Sedgewick, Algorithms in
Range Reporting. Range reporting problem 1D range reporting Range trees 2D range reporting Range trees Predecessor in nested sets kd trees
Range Reporting Range reporting problem 1D range reporting Range trees 2D range reporting Range trees Predecessor in nested sets kd trees Philip Bille Range Reporting Range reporting problem 1D range reporting
1. [1 pt] What is the solution to the recurrence T(n) = 2T(n-1) + 1, T(1) = 1
![1. [1 pt] What is the solution to the recurrence T(n) = 2T(n-1) + 1, T(1) = 1](/thumbs/85/92778785.jpg "1. [1 pt] What is the solution to the recurrence T(n) = 2T(n-1) + 1, T(1) = 1")
Asymptotics, Recurrence and Basic Algorithms 1. [1 pt] What is the solution to the recurrence T(n) = 2T(n-1) + 1, T(1) = 1 2. O(n) 2. [1 pt] What is the solution to the recurrence T(n) = T(n/2) + n, T(1)
CSC 172 Data Structures and Algorithms. Fall 2017 TuTh 3:25 pm 4:40 pm Aug 30- Dec 22 Hoyt Auditorium
CSC 172 Data Structures and Algorithms Fall 2017 TuTh 3:25 pm 4:40 pm Aug 30- Dec 22 Hoyt Auditorium Announcement Coming week: Nov 19 Nov 25 No Quiz No Workshop No New Lab Monday and Tuesday: regular Lab
Algorithms in Systems Engineering ISE 172. Lecture 16. Dr. Ted Ralphs
Algorithms in Systems Engineering ISE 172 Lecture 16 Dr. Ted Ralphs ISE 172 Lecture 16 1 References for Today s Lecture Required reading Sections 6.5-6.7 References CLRS Chapter 22 R. Sedgewick, Algorithms
Self-Balancing Search Trees. Chapter 11
Self-Balancing Search Trees Chapter 11 Chapter Objectives To understand the impact that balance has on the performance of binary search trees To learn about the AVL tree for storing and maintaining a binary
Problem Set 6 Solutions
Introduction to Algorithms October 29, 2001 Massachusetts Institute of Technology 6.046J/18.410J Singapore-MIT Alliance SMA5503 Professors Erik Demaine, Lee Wee Sun, and Charles E. Leiserson Handout 24
Search Trees. COMPSCI 355 Fall 2016
Search Trees COMPSCI 355 Fall 2016 2-4 Trees Search Trees AVL trees Red-Black trees Splay trees Multiway Search Trees (2, 4) Trees External Search Trees (optimized for reading and writing large blocks)
COMP Analysis of Algorithms & Data Structures
COMP 3170 - Analysis of Algorithms & Data Structures Shahin Kamali Lecture 9 - Jan. 22, 2018 CLRS 12.2, 12.3, 13.2, read problem 13-3 University of Manitoba COMP 3170 - Analysis of Algorithms & Data Structures
External-Memory Algorithms with Applications in GIS - (L. Arge) Enylton Machado Roberto Beauclair
External-Memory Algorithms with Applications in GIS - (L. Arge) Enylton Machado Roberto Beauclair {machado,tron}@visgraf.impa.br Theoretical Models Random Access Machine Memory: Infinite Array. Access
Trees. Eric McCreath
Trees Eric McCreath 2 Overview In this lecture we will explore: general trees, binary trees, binary search trees, and AVL and B-Trees. 3 Trees Trees are recursive data structures. They are useful for:
Computational Geometry csci3250. Laura Toma. Bowdoin College
Computational Geometry csci3250 Laura Toma Bowdoin College Motion Planning Input: a robot R and a set of obstacles S = {O 1, O 2, } start position p start end position p end Find a path from start to end
Computing intersections in a set of line segments: the Bentley-Ottmann algorithm
Computing intersections in a set of line segments: the Bentley-Ottmann algorithm Michiel Smid October 14, 2003 1 Introduction In these notes, we introduce a powerful technique for solving geometric problems.
CPS 616 TRANSFORM-AND-CONQUER 7-1
CPS 616 TRANSFORM-AND-CONQUER 7-1 TRANSFORM AND CONQUER Group of techniques to solve a problem by first transforming the problem into one of: 1. a simpler/more convenient instance of the same problem (instance
CS 380 ALGORITHM DESIGN AND ANALYSIS
CS 380 ALGORITHM DESIGN AND ANALYSIS Lecture 12: Red-Black Trees Text Reference: Chapters 12, 13 Binary Search Trees (BST): Review Each node in tree T is a object x Contains attributes: Data Pointers to
Analysis of Algorithms
Analysis of Algorithms Trees-I Prof. Muhammad Saeed Tree Representation.. Analysis Of Algorithms 2 .. Tree Representation Analysis Of Algorithms 3 Nomenclature Nodes (13) Size (13) Degree of a node Depth
COMP Analysis of Algorithms & Data Structures
COMP 3170 - Analysis of Algorithms & Data Structures Shahin Kamali Lecture 9 - Jan. 22, 2018 CLRS 12.2, 12.3, 13.2, read problem 13-3 University of Manitoba 1 / 12 Binary Search Trees (review) Structure
Binary Search Tree (2A) Young Won Lim 5/17/18
Binary Search Tree (2A) Copyright (c) 2015-2018 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or
Lower Bound on Comparison-based Sorting
Lower Bound on Comparison-based Sorting Different sorting algorithms may have different time complexity, how to know whether the running time of an algorithm is best possible? We know of several sorting
Computer Science 210 Data Structures Siena College Fall Topic Notes: Binary Search Trees
Computer Science 10 Data Structures Siena College Fall 018 Topic Notes: Binary Search Trees Possibly the most common usage of a binary tree is to store data for quick retrieval. Definition: A binary tree
Properties of red-black trees
Red-Black Trees Introduction We have seen that a binary search tree is a useful tool. I.e., if its height is h, then we can implement any basic operation on it in O(h) units of time. The problem: given
1 The range query problem
CS268: Geometric Algorithms Handout #12 Design and Analysis Original Handout #12 Stanford University Thursday, 19 May 1994 Original Lecture #12: Thursday, May 19, 1994 Topics: Range Searching with Partition
ECE250: Algorithms and Data Structures Midterm Review
ECE250: Algorithms and Data Structures Midterm Review Ladan Tahvildari, PEng, SMIEEE Associate Professor Software Technologies Applied Research (STAR) Group Dept. of Elect. & Comp. Eng. University of Waterloo
Balanced Trees Part Two
Balanced Trees Part Two Outline for Today Recap from Last Time Review of B-trees, 2-3-4 trees, and red/black trees. Order Statistic Trees BSTs with indexing. Augmented Binary Search Trees Building new
2-3 Tree. Outline B-TREE. catch(...){ printf( "Assignment::SolveProblem() AAAA!"); } ADD SLIDES ON DISJOINT SETS
Outline catch(...){ printf( "Assignment::SolveProblem() AAAA!"); } Balanced Search Trees 2-3 Trees 2-3-4 Trees Slide 4 Why care about advanced implementations? Same entries, different insertion sequence:
Balanced Binary Search Trees
Balanced Binary Search Trees Pedro Ribeiro DCC/FCUP 2017/2018 Pedro Ribeiro (DCC/FCUP) Balanced Binary Search Trees 2017/2018 1 / 48 Motivation Let S be a set of comparable objects/items: Let a and b be
Jana Kosecka. Red-Black Trees Graph Algorithms. Many slides here are based on E. Demaine, D. Luebke slides
Jana Kosecka Red-Black Trees Graph Algorithms Many slides here are based on E. Demaine, D. Luebke slides Binary Search Trees (BSTs) are an important data structure for dynamic sets In addition to satellite
B Tree. Also, every non leaf node must have at least two successors and all leaf nodes must be at the same level.
B Tree If there is just one item in the node, then the B Tree is organised as a binar search tree: all items in the left sub tree must be less than the item in the node, and all items in the right sub
Trees. Dr. Ronaldo Menezes Hugo Serrano Ronaldo Menezes, Florida Tech
Trees Dr. Ronaldo Menezes Hugo Serrano (hbarbosafilh2011@my.fit.edu) Introduction to Trees Trees are very common in computer science They come in different variations They are used as data representation
Using Bounding Volume Hierarchies Efficient Collision Detection for Several Hundreds of Objects
Part 7: Collision Detection Virtuelle Realität Wintersemester 2007/08 Prof. Bernhard Jung Overview Bounding Volumes Separating Axis Theorem Using Bounding Volume Hierarchies Efficient Collision Detection
Computational Geometry [csci 3250]
![Computational Geometry [csci 3250]](/thumbs/93/112686747.jpg "Computational Geometry [csci 3250]")
Computational Geometry [csci 3250] Laura Toma Bowdoin College Polygon Triangulation Polygon Triangulation The problem: Triangulate a given polygon. (output a set of diagonals that partition the polygon
Polygon Triangulation
Polygon Triangulation The problem: Triangulate a given polygon. (output a set of diagonals that partition the polygon into triangles). Computational Geometry [csci 3250] Polygon Triangulation Laura Toma
CMSC 754 Computational Geometry 1
CMSC 754 Computational Geometry 1 David M. Mount Department of Computer Science University of Maryland Fall 2005 1 Copyright, David M. Mount, 2005, Dept. of Computer Science, University of Maryland, College
Lecture 8: Orthogonal Range Searching
CPS234 Comutational Geometry Setember 22nd, 2005 Lecture 8: Orthogonal Range Searching Lecturer: Pankaj K. Agarwal Scribe: Mason F. Matthews 8.1 Range Searching The general roblem of range searching is
The Art Gallery Problem
The Art Gallery Problem Imagine an art gallery whose floor plan is a simple polygon, and a guard (a point) inside the gallery. Computational Geometry [csci 3250] The Art Gallery Problem Laura Toma Bowdoin
DDS Dynamic Search Trees
DDS Dynamic Search Trees 1 Data structures l A data structure models some abstract object. It implements a number of operations on this object, which usually can be classified into l creation and deletion
Search Trees - 1 Venkatanatha Sarma Y
Search Trees - 1 Lecture delivered by: Venkatanatha Sarma Y Assistant Professor MSRSAS-Bangalore 11 Objectives To introduce, discuss and analyse the different ways to realise balanced Binary Search Trees
CSCI Trees. Mark Redekopp David Kempe
CSCI 104 2-3 Trees Mark Redekopp David Kempe Trees & Maps/Sets C++ STL "maps" and "sets" use binary search trees internally to store their keys (and values) that can grow or contract as needed This allows
A set of nodes (or vertices) with a single starting point
Binary Search Trees Understand tree terminology Understand and implement tree traversals Define the binary search tree property Implement binary search trees Implement the TreeSort algorithm 2 A set of
CSC Design and Analysis of Algorithms
CSC : Lecture 7 CSC - Design and Analysis of Algorithms Lecture 7 Transform and Conquer I Algorithm Design Technique CSC : Lecture 7 Transform and Conquer This group of techniques solves a problem by a
Binary Search Trees. Analysis of Algorithms
Binary Search Trees Analysis of Algorithms Binary Search Trees A BST is a binary tree in symmetric order 31 Each node has a key and every node s key is: 19 23 25 35 38 40 larger than all keys in its left
CISC 235: Topic 4. Balanced Binary Search Trees
CISC 235: Topic 4 Balanced Binary Search Trees Outline Rationale and definitions Rotations AVL Trees, Red-Black, and AA-Trees Algorithms for searching, insertion, and deletion Analysis of complexity CISC
Binary Trees. Recursive definition. Is this a binary tree?
Binary Search Trees Binary Trees Recursive definition 1. An empty tree is a binary tree 2. A node with two child subtrees is a binary tree 3. Only what you get from 1 by a finite number of applications
CS60020: Foundations of Algorithm Design and Machine Learning. Sourangshu Bhattacharya
CS62: Foundations of Algorithm Design and Machine Learning Sourangshu Bhattacharya Binary Search Tree - Best Time All BST operations are O(d), where d is tree depth minimum d is d = ëlog for a binary tree
Search Trees. The term refers to a family of implementations, that may have different properties. We will discuss:
Search Trees CSE 2320 Algorithms and Data Structures Alexandra Stefan Based on slides and notes from: Vassilis Athitsos and Bob Weems University of Texas at Arlington 1 Search Trees Preliminary note: "search
CS60020: Foundations of Algorithm Design and Machine Learning. Sourangshu Bhattacharya
CS62: Foundations of Algorithm Design and Machine Learning Sourangshu Bhattacharya Balanced search trees Balanced search tree: A search-tree data structure for which a height of O(lg n) is guaranteed when
Computational Geometry [csci 3250]
![Computational Geometry [csci 3250]](/thumbs/75/72526151.jpg "Computational Geometry [csci 3250]")
Computational Geometry [csci 3250] Laura Toma Bowdoin College The Art Gallery Problem The Art Gallery Problem Imagine an art gallery whose floor plan is a simple polygon, and a guard (a point) inside the
CSCI 136 Data Structures & Advanced Programming. Lecture 25 Fall 2018 Instructor: B 2
CSCI 136 Data Structures & Advanced Programming Lecture 25 Fall 2018 Instructor: B 2 Last Time Binary search trees (Ch 14) The locate method Further Implementation 2 Today s Outline Binary search trees
CS350: Data Structures AA Trees
AA Trees James Moscola Department of Engineering & Computer Science York College of Pennsylvania James Moscola Introduction to AA Trees A type of balanced binary search tree Developed as a simpler alternative
CSC Design and Analysis of Algorithms. Lecture 7. Transform and Conquer I Algorithm Design Technique. Transform and Conquer
// CSC - Design and Analysis of Algorithms Lecture 7 Transform and Conquer I Algorithm Design Technique Transform and Conquer This group of techniques solves a problem by a transformation to a simpler/more
ECE 242 Data Structures and Algorithms. Trees IV. Lecture 21. Prof.
ECE 22 Data Structures and Algorithms http://www.ecs.umass.edu/~polizzi/teaching/ece22/ Trees IV Lecture 2 Prof. Eric Polizzi Summary previous lectures Implementations BST 5 5 7 null 8 null null 7 null
Binary search trees. Binary search trees are data structures based on binary trees that support operations on dynamic sets.
COMP3600/6466 Algorithms 2018 Lecture 12 1 Binary search trees Reading: Cormen et al, Sections 12.1 to 12.3 Binary search trees are data structures based on binary trees that support operations on dynamic
Binary search trees 3. Binary search trees. Binary search trees 2. Reading: Cormen et al, Sections 12.1 to 12.3
Binary search trees Reading: Cormen et al, Sections 12.1 to 12.3 Binary search trees 3 Binary search trees are data structures based on binary trees that support operations on dynamic sets. Each element
Trees. (Trees) Data Structures and Programming Spring / 28
Trees (Trees) Data Structures and Programming Spring 2018 1 / 28 Trees A tree is a collection of nodes, which can be empty (recursive definition) If not empty, a tree consists of a distinguished node r
Binary Search Tree (3A) Young Won Lim 6/2/18
Binary Search Tree (A) /2/1 Copyright (c) 2015-201 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
Analysis of Algorithms
Analysis of Algorithms Concept Exam Code: 16 All questions are weighted equally. Assume worst case behavior and sufficiently large input sizes unless otherwise specified. Strong induction Consider this
Geometric and Thematic Integration of Spatial Data into Maps
Geometric and Thematic Integration of Spatial Data into Maps Mark McKenney Department of Computer Science, Texas State University mckenney@txstate.edu Abstract The map construction problem (MCP) is defined
TREES. Trees - Introduction
TREES Chapter 6 Trees - Introduction All previous data organizations we've studied are linear each element can have only one predecessor and successor Accessing all elements in a linear sequence is O(n)
Computational Geometry
Windowing queries Windowing Windowing queries Zoom in; re-center and zoom in; select by outlining Windowing Windowing queries Windowing Windowing queries Given a set of n axis-parallel line segments, preprocess
Trees. Truong Tuan Anh CSE-HCMUT
Trees Truong Tuan Anh CSE-HCMUT Outline Basic concepts Trees Trees A tree consists of a finite set of elements, called nodes, and a finite set of directed lines, called branches, that connect the nodes
Ensures that no such path is more than twice as long as any other, so that the tree is approximately balanced
13 Red-Black Trees A red-black tree (RBT) is a BST with one extra bit of storage per node: color, either RED or BLACK Constraining the node colors on any path from the root to a leaf Ensures that no such
Lecture 3 February 23, 2012
6.851: Advanced Data Structures Spring 2012 Prof. Erik Demaine Lecture 3 February 23, 2012 1 Overview In the last lecture we saw the concepts of persistence and retroactivity as well as several data structures
Introduction to Algorithms March 11, 2009 Massachusetts Institute of Technology Spring 2009 Professors Sivan Toledo and Alan Edelman Quiz 1
Introduction to Algorithms March 11, 2009 Massachusetts Institute of Technology 6.006 Spring 2009 Professors Sivan Toledo and Alan Edelman Quiz 1 Quiz 1 Do not open this quiz booklet until directed to