Post on 18-Jan-2016
Programmer-defined Linked List Class
Data members (could be different types) stored in (usually) contiguous block of memory– One of the data members is a pointer variable
Address stored points to the next object
Data member that has address creates link between objects
Each object referred to as a node
Lesson 16.1
Linked List Representation
Lesson 16.1
Head node
Object 2
Object 3
Object 4
Objects in linked list
linkPointer variable valueFact that addresspoints to next object
Actions on Linked List
Must go node to node from head node Can delete node by making address that points
to one to be deleted to next object Can insert node by changing address stored in
pointer variable for node preceding location of insertion
Can move node from one location to another Must keep track of current node and head
node
Lesson 16.1
Linked List Classes
Use two classes to create linked list– Node class
Holds only the data All data members public because no function
members
– Second used to manipulate nodes One variable holds address of first object in list Another variable holds current node address
Lesson 16.1
Node Class
General form:
Lesson 16.1
class Node{ public: type member1; type member2; … Node* next_node;};
Class name
Data types(not necessarily all the same)
Identifiers representingnode dataName for storing
address of next node in list
Second Class
Used to manipulate the nodes
Data only pointer variables used to hold addresses
Lesson 16.1
class Llist{ private: Node* head; Node* current; public: void make_list ( ); void show_list ( );};
Address of nodebeing manipulated
Address offirst object
Stack
Data structure created using linked list model With stack can perform only two fundamental
operations– Push
Insert node immediately after the head
– Pop Retrieve and delete node immediately after head
Only work with nodes at top
Lesson 16.2
Stack Classes
Two classes create stack– One class holds only data
Same form as linked list one member must be pointer variable
– Second class used to manipulate nodes Data only pointer variables used to hold addresses
of nodes Nodes of interest for stack are head and tail Function members initialize, push and pop items
Lesson 16.2
Stack Class
Lesson 16.2
class Stack{ private: Node* head; Node* tail; public: Stack ( ); void push (int); int pop ( );};
Address of head node and last node
Stack Classes
Create empty stack by initializing a head and tail node– Allow finding top and bottom of stack
Should not pop from an empty stack LIFO
– Last In First Out Last node pushed is first node popped off
Lesson 16.2
Queue Class
Can create with linked list form– Must have a head and tail node
FIFO– First node inserted into queue is first node
removed Nodes are inserted at tail of queue and
removed from head of queue
Lesson 16.3
Queue Class
Lesson 16.3
class Queue{ private: Node* head; Node* tail; public: Queue ( ); void insert (int); int remov ( );};
Class Node{ public: type member; Node* next_node;};
Types of Queues Dequeue - "double-ended queue"
– Nodes can be inserted at either end and removed from either end
Output restricted dequeue– Insertion allowed at both ends but removal
allowed at only one end Input restricted dequeue
– Removal allowed at both ends, insertion allowed at only one end
Priority queue– Priority for each node – highest priority
processed first
Lesson 16.3
Binary Tree
Tree is particular type of graph– Binary tree is
particular type of tree Graph is data structure
that includes nodes– each node can have
more than one pointer
Lesson 16.4
Linked List Graph
Graph Terminology Nodes can also be called vertices or points Connections between nodes called edges or
arcs Two nodes considered adjacent of neighbors
if edge connects them Path between one node and another indicated
by list of connect nodes between two Simple path is path with no repeated nodes
Lesson 16.4
Graphs Weighted graph
– Assign length or cost of each edge Tree
– graph with characteristic that there is only one path between any two nodes
– Rooted tree Tree with one node specified to be root Root traditionally shown at top of diagram
– Binary tree Tree in which no node has more than two children
Lesson 16.4
Tree Class
Similar to linked list and stack classes
Two classes– One class holds
content of nodes– Second class
manipulates the nodes
Lesson 16.4
class Tree_node{ public: type member; Tree_node* left_child; Tree_node* right_child;};
Recursion
Within function body there is call to function with identical name and signature
Basic action which is repeated until it reaches the final iteration of the basic action
Lesson 16.5