Download presentation

Presentation is loading. Please wait.

1
**Data Structures: Trees and Grammars**

Readings: Sections 6.1, (more from Ch. 6 later)

2
**Continue focus on data structures and algorithms **

Goals for this Unit Continue focus on data structures and algorithms Understand concepts of reference-based data structures (e.g. linked lists, binary trees) Some implementation for binary trees Understand usefulness of trees and hierarchies as useful data models Recursion used to define data organization

3
**Taxonomy of Data Structures**

From the text: Data type: collection of values and operations Compare to Abstract Data Type! Simple data types vs. composite data types Book: Data structures are composite data types Definition: a collection of elements that are some combination of primitive and other composite data types

4
**Book’s Classification of Data Structures**

Four groupings: Linear Data Structures Hierarchical Graph Sets and Tables When defining these, note an element has: one or more information fields relationships with other elements

5
**Note on Our Book and Our Course**

Our book’s strategy In Ch. 6, discuss principles of Lists Give an interface, then implement from scratch In Ch. 7, discuss principles of Trees Later, in Ch. 9, see what Java gives us Our course’s strategy We did Ch. 9 first. Saw List interfaces and operations Then, Ch. 8 on maps and sets Now, trees with some implementation too

6
**Trees Represent… Concept of a tree very common and important.**

Tree terminology: Nodes have one parent A node’s children Leaf nodes: no children Root node: top or start; no parent Data structures that store trees Execution or processing that can be expressed as a tree E.g. method calls as a program runs Searching a maze or puzzle

7
**Trees are Important Trees are important for cognition and computation**

computer science language processing (human or computer) parse trees knowledge representation (or modeling of the “real world”) E.g. family trees; the Linnaean taxonomy (kingdom, phylum, …, species); etc.

8
**Another Tree Example: File System**

C:\ lab2 CS216 lab1 lab3 MyMail school CS120 pers list.h calc.cpp list.cpp What about file links (Unix) or shortcuts (Windows)?

9
**Another Tree Example: XML and HTML documents**

<HEAD>…</HEAD> <BODY> <H1>My Page</H1> <P> Blah <PRE>blah blah</PRE> End </P> </BODY> </HTML> How is this a tree? What are the leaves?

10
**Tree Data Structures Why this now? Very useful in coding**

TreeMap in Java Collections Framework Example of recursive data structures Methods are recursive algorithms

11
**Tree Definitions and Terms**

First, general trees vs. binary trees Each node in a binary tree has at most two children General tree definition: Set of nodes T (possibly empty?) with a distinguished node, the root All other nodes form a set of disjoint subtrees Ti each a tree in its own right each connected to the root with an edge Note the recursive definition Each node is the root of a subtree

12
**Picture of Tree Definition**

And all subtrees are recursively defined as: a node with… subtrees attached to it

13
**Tree Terminology A node’s parent A node’s children**

Binary tree: left child and right child Sibling nodes Descendants, ancestors A node’s degree (how many children) Leaf nodes or terminal nodes Internal or non-terminal nodes

14
**Recursive Data Structure**

Recursive Data Structure: a data structure that contains a pointer or reference to an instance of itself: public class TreeNode<T> { T nodeItem; TreeNode<T> left, right; TreeNode<T> parent; … } Recursion is a natural way to express many algorithms. For recursive data-structures, recursive algorithms are a natural choice

15
**General Trees Representing general trees is a bit harder**

Each node has a list of child nodes Turns out that: Binary trees are simpler and still quite useful From now on, let’s focus on binary-trees only

16
**ADT Tree Remember definition on an ADT?**

Model of information: we just covered that Operations? See pages in textbook Many are similar to ADT List or any data structure The “CRUD” operations: create, replace, update, delete Important about this list of operations some are in terms of one specified node, e.g. hasParent() others are “tree-wide”, e.g. size(), traversal

17
**Classes for Binary Trees (pp. 416-431)**

class LinkedBinaryTree (p. 425, bottom) reference to root BinaryTreeNode methods: tree-level operations class BinaryTreeNode (p. 416) data: an object (of some type) left: references root of left-subtree (or null) right: references root of right-subtree (or null) parent: references this node’s parent node Could this be null? When should it be? methods: node-level operations

18
**Two-class Strategy for Recursive Data Structures**

Common design: use two classes for a Tree or List “Top” class has reference to “first” node other things that apply to the whole data-structure object (e.g. the tree-object) both methods and fields Node class Recursive definitions are here as references to other node objects Also data (of course) Methods defined in this class are recursive

19
**Binary Tree and Node Class**

LinkedBinaryTree class has: reference to root node reference to a current node, a cursor non-recursive methods like: boolean find(tgt) // see if tgt is in the whole tree Node class has: data, references to left and right subtrees recursive versions of methods like find: boolean find(tgt) // is tgt here or in my subtrees? Note: BinaryTree.find() just calls Node.find() on the root node! Other methods work this way too

20
**Why Does This Matter Now?**

This illustrates (again) important design ideas The tree itself is what we’re interested in There are tree-level operations on it (“ADT level” operations) The implementation is a recursive data structure There are recursive methods inside the lower-level classes that are closely related (same name!) to the ADT-level operation Principles? abstraction (hiding details), delegation (helper classes, methods)

21
**ADT Tree Operations: “Navigation”**

Positioning: toRoot(), toParent(), toLeftChild(), toRightChild(), find(Object o) Checking: hasParent(), hasLeftChild(), etc. equals(Object tree2) Book calls this a “deep compare” Do two distinct objects have the same structure and contents?

22
**ADT Tree Operations: Mutators**

insertRight(Object o), insertLeft(Object o) create a new node containing new data make this new node be the child of the current node Important: We use these to build trees! prune() delete the subtree rooted by the current node

23
**Next: Implementation Next (in the book) But for us:**

How to implement Java classes for binary trees Class for node, another class for BinTree Interface for both, then two implementations (array and reference) But for us: We’ll skip some of this, particularly the array version We’ll only look at reference-base implementation After that: concept of a binary search tree

24
**Understanding Implementations**

Let’s review some of the methods on pp (Done in class, looking at code in book.) Some topics discussed: Node class. Parent reference or not? Are two trees equal? Traversal strategies: Section in book visit() method and callback (also 7.3.2)

25
**Binary Search Trees We often need collections that store items**

Maybe a long series of inserts or deletions We want fast lookup, and often we want to access in sorted order Lists: O(n) lookup Could sort them for O(lg n) lookup Cost to sort is O(n lg n) and we might need to re-sort often as we insert, remove items Solution: search tree

26
Binary Search Trees Associated with each node is a key value that can be compared. Binary search tree property: every node in the left subtree has key whose value is less than the value of the root’s key value, and every node in the right subtree has key whose value is greater than the value of the root’s key value.

27
Example 5 4 8 1 7 11 3 BINARY SEARCH TREE

28
Counterexample 8 5 11 2 7 6 10 18 4 15 20 NOT A BINARY SEARCH TREE 21

29
**Find and Insert in BST Find: look for where it should be**

If not there, that’s where you insert

30
**Recursion and Tree Operations**

Recursive code for tree operations is simple, natural, elegant Example: pseudo-code for Node.find() boolean find(Comparable tgt) { Node next = null; if (this.data matches tgt) return true else if (tgt’s data < this.data) next = this.leftChild else // tgt’s data > this.data next = this.rightChild // next points to left or right subtree if (next == null ) return false // no subtree else return next.find(tgt) // search on }

31
Order in BSTs How could we traverse a BST so that the nodes are visited in sorted order? Does one of our traversal strategies work? A very useful property about BSTs Consider Java’s TreeSet and TreeMap A search tree (not a BST, but be one of its better “cousins”) In CS2150: AVL trees, Red-Black trees Guarantee: search times are O(lg n)

32
**Deleting from a BST Removing a node requires**

Moving its left and right subtrees Not hard if one not there But if both there? Answer: not too tough, but wait for CS2150 to see! In CS2110, we’ll not worry about this

33
**Next: Grammars, Trees, Recursion**

Languages are governed by a set of rules called a grammar Is a statement legal ? Generate or derive a new legal statement Natural language grammars Language processing by computers But, grammars used a lot in computing Grammar for a programming language Grammar for valid inputs, messages, data, etc.

34
Backus-Naur Form BNF is a widely-used notation for describing the grammar or formal syntax of programming languages or data BNF specifics a grammar as a set of derivation rules of this form: <symbol> ::= <expression with symbols> Look at website and example there (also on next slide) How are trees involved here? Is it recursive?

35
**BNF for Postal Address Example: Ann Marie G. Jones**

<postal-address> ::= <name-part> <street-address> <zip-part> <personal-part> ::= <first-name> | <initial> "." <name-part> ::= <personal-part> <last-name> [<jr-part>] <EOL> | <personal-part> <name-part> <street-address> ::= [<apt>] <house-num> <street-name> <EOL> <zip-part> ::= <town-name> "," <state-code> <ZIP-code> <EOL> Example: Ann Marie G. Jones 123 Main St. Hooville, VA 22901 Where’s the recursion?

36
**Grammars in Language Rule-based grammars describe**

how legal statements can be produced how to tell if a statement is legal Study textbook, pp , to see rule-based grammar for simple Java-like arithmetic expressions four rules for expressions, terms, factors, and letter Study how a (possibly) legal statement is parsed to generate a parse tree

37
**Computing Parse-Tree Example**

Expression: a * b + c

38
**Grammar Terms and Concepts**

First, this is what’s called a context-free grammar For CS2110, let’s not worry about what this means! (But in CS2102, you learn this.) A CFG has a set of variables (AKA non-terminals) a set of terminal symbols a set of productions a starting symbol

39
**Previous Parse Tree Terminal symbols:**

<operator> could be: + * <letter> could be: a b c Production: <factor> <letter> | <number>

40
**Natural Language Parse Tree**

Statement: The man bit the dog

41
**How Can We Use Grammars? Parsing Production**

Is a given statement a valid statement in the language? (Is the statement recognized by the grammar?) Note this is what the Java compiler does as a first step toward creating an executable form of your program. (Find errors, or build executable.) Production Generate a legal statement for this grammar Demo: generate random statements! See link on website next to slides

42
**Demo’s Poem-grammar data file**

{ <start> The <object> <verb> tonight } <object> waves big yellow flowers slugs { <verb> sigh <adverb> portend like <object> die <adverb> } <adverb> warily grumpily Note: no recursive productions in this example!

Similar presentations

OK

How to convert a left linear grammar to a right linear grammar

How to convert a left linear grammar to a right linear grammar

© 2018 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google