This document describes the implementation of a linked list data structure in C++. It defines a Node struct to hold each element and a LinkedList class to manage the list. The LinkedList class implements common list operations like insert, retrieve, find, replace through methods that traverse the linked nodes. A current pointer tracks the active node during operations like getNext to iterate through the list sequentially. The implementation allows storing and accessing elements by value or key in a flexible linked list.
An Introduction to Part of C++ STL for OI. Introduced the common use of STL algorithms and containers, especially those are helpful to OI.
Also with some examples.
Clojure is a new language that combines the power of Lisp with an existing hosted VM ecosystem (the Java VM). Clojure is a dynamically typed, functional, compiled language with performance on par with Java.
At the heart of all programming lies the need for abstraction, be it abstraction over our data or abstraction over the processes that operate upon it. Clojure provides a core set of powerful abstractions and ways to compose them. These abstractions are based in a heritage of Lisp but also cover many aspects of object-oriented programming as well.
This talk will examine these abstractions and introduce you to both Clojure and functional programming. Attendees are not expected to be familiar with either Clojure or FP.
Implementation details and performance traits of generics in .NET, Java and C++. Presentation for the Jerusalem .NET/C++ User Group by Sasha Goldshtein.
An Introduction to Part of C++ STL for OI. Introduced the common use of STL algorithms and containers, especially those are helpful to OI.
Also with some examples.
Clojure is a new language that combines the power of Lisp with an existing hosted VM ecosystem (the Java VM). Clojure is a dynamically typed, functional, compiled language with performance on par with Java.
At the heart of all programming lies the need for abstraction, be it abstraction over our data or abstraction over the processes that operate upon it. Clojure provides a core set of powerful abstractions and ways to compose them. These abstractions are based in a heritage of Lisp but also cover many aspects of object-oriented programming as well.
This talk will examine these abstractions and introduce you to both Clojure and functional programming. Attendees are not expected to be familiar with either Clojure or FP.
Implementation details and performance traits of generics in .NET, Java and C++. Presentation for the Jerusalem .NET/C++ User Group by Sasha Goldshtein.
Java 8 Stream API. A different way to process collections.David Gómez García
A look on one of the features of Java 8 hidden behind the lambdas. A different way to iterate Collections. You'll never see the Collecions the same way.
These are the slides I used on my talk at the "Tech Thursday" by Oracle in June in Madrid.
Talk is about simple data structures like queue and Tree and their possible implementation in Scala. It also talks about binary search trees and their traversals.
Java 8 Stream API. A different way to process collections.David Gómez García
A look on one of the features of Java 8 hidden behind the lambdas. A different way to iterate Collections. You'll never see the Collecions the same way.
These are the slides I used on my talk at the "Tech Thursday" by Oracle in June in Madrid.
Talk is about simple data structures like queue and Tree and their possible implementation in Scala. It also talks about binary search trees and their traversals.
singly link list project in dsa.....by rohit malavRohit malav
Singly Linked Lists are a type of data structure. In a singly linked list, each node in the list stores the contents and a pointer or reference to the next node in the list. It does not store any pointer or reference to the previous node. ... The last node in a single linked list points to nothing.
Array is a container which can hold a fix number of items and these items should be of the same type. Most of the data structures make use of arrays to implement their algorithms. Following are the important terms to understand the concept of array.
we are innovative,we are different,we are genius so they call us idiots
Visit us for movies,videos,documentaries,sports,funny pics and many more join www.globalidiots.com
Similar to Lecture07 the linked-list_as_a_data_structure_v3 (20)
2. The List ADT
• A list is a list of elements.
• The list of elements consist of the data
acted upon by list operations.
• A current position (or active position) in the
list is also acted upon by list operations.
2
3. List ADT Operations
• insert, to insert a new item into the list; there is
no current position after an insertion.
• an iterator, for retrieving (by copy instead of
removal) each item from the list, one at a time;
at any particular moment when an item is
retrieved, that item becomes the current position
in the list.
• find, to determine whether or not a certain item
exists in a list; if the item exists, it becomes the
current position.
• retrieve, to retrieve (by copy instead of removal)
a certain item; that item becomes the current
position.
• more…
3
4. List ADT Operations
(cont.)
• replace, to replace the item at the current
position with another item; the current position
remains unchanged.
• remove, to remove an item from a list; there is
no current position after a removal.
• an operation to determine whether or not the list
is empty; the current position is unchanged.
• an operation to empty out the list; the current
position is lost.
4
5. Retrieving Elements
• When the client needs to retrieve an
element in the list, the main practical
reason is because it contains information
that the client doesn’t have.
• Yet, the clients must know something
about it; otherwise, they would not be able
to tell the List object to look for it.
• The clients know about the key...
5
6. Keys
• A key is a value that uniquely identifies an
object
– If objects are people, a good key would be the
SSN
– books – ISBN key
– parts – part number key
• The elements in a list ADT are usually
objects – the key is just a single data
member of the object.
6
7. An Example
• A customer of an insurance company has
a problem with the amount paid by the
insurance company for an operation.
• The customer calls the insurance
company.
• The insurance company asks the
customer for the claim number (the key).
• The customer provides the claim number.
7
8. An Example (cont.)
• The insurance company representative
types the claim number (key) into the
computer.
• The claim number is typed into a program
which is using one or more data
structures.
• The retrieve function of a data structure is
called, passing in the claim number (key).
8
9. An Example (cont.)
• The retrieve function searches the data
structure for the object that has the key.
• The retrieve function finds the object and
returns the object.
• All the data in the object is now provided
to the main program.
• The main program shows all the data on
the screen.
9
10. An Example (cont.)
• The insurance company representative
looks at the data.
• The insurance company representative
can now see what the customer is
complaining about.
10
11. List Implementation
• In C++, lists can be implemented with arrays or
linked lists.
• Recall 2 advantages of linked lists
– conserve memory for large objects (such as objects
with keys).
– can easily remove an element from the middle.
• So, we’ll focus on using the linked list.
• Instead of saying “linked-list implementation of a
list”, we’ll just say “linked list”.
11
12. Retrieve Function
Implementation
• How should we pass a key into the retrieve
function and return the object?
• Approach 1: Pass in a key as a parameter and
pass in an object as a reference parameter (to
return the object result).
• Approach 2: Pass in an object by reference
which has its key set to the key to search for;
when the object is found in the linked list, it is
assigned to the object passed in by reference.
12
13. Advantages of
Approach 2
• The client must declare an object, which will hold
the data retrieved from the linked list.
– approach 2 relieves the client of also having to
declare a key; a key is already in the object.
• If approach 1 is used, two T’s are needed
(say, T1 and T2) for the object type and the key
type
• approach 2 will also be used for the find and
remove functions.
13
14. The Retrieval Process
• An object is created in the main program.
• The representative asks the customer for the
key.
• The representative types in the key.
• The object’s data member is set to the key
value; no other data members in the object are
set.
• The object (let’s say obj1) is passed into the
retrieve function by reference.
14
15. The Retrieval Process
(cont.)
• The struct for obj1 has an overloaded
operator, used by the retrieve function for finding
the object with the key:
Example: if ( obj1 == ptr->info ) // found
• The other information is placed in obj1
obj1 = ptr->info;
• The retrieve function returns true (indicating a
find) and obj1 is returned by reference
parameter.
15
16. The Iterator
• first – returns the first element in the linked list.
• getNext – returns the next element in the linked
list, after the first function call or previous
getNext function call
– Implemented by maintaining a current pointer in the
private section.
– The current pointer is advanced every time getNext is
called.
– Returns false when the client tries to get an element
beyond the end of the list (otherwise returns true).
16
17. Find and Replace
Functions
• find – returns true only if an element with
the key was found – the element itself is
not returned.
• replace – replaces the element at the
current position with the element passed in
– find and replace functions will often be used
together.
17
18. LinkedList
Implementation
• A general linked list is more involved than
the linked list queue or the linked list stack.
• The client must be able to
access, change, or remove any element in
the linked list at any time.
• It should be implemented to handle key-
oriented types of objects, but also be
general enough to handle other objects
without keys, like strings.
18
22. insert
30 void insert( const T & element )
31 {
32 current = NULL;
33 Node<T> *newNode = new Node<T>;
34 newNode->info = element;
35 newNode->next = start;
36 start = newNode;
Inserting at the
37 }
beginning of the
linked list.
22
23. first
49 bool first( T & listEl )
50 {
51 if ( start == NULL )
52 return false;
53
54 current = start;
55 listEl = start->info;
56 return true;
57 }
23
24. getNext
60 bool getNext( T & listEl )
61 {
62 if ( current == NULL )
63 return false;
64 if ( current->next == NULL ) {
65 current = NULL;
66 return false;
67 }
68 current = current->next;
69 listEl = current->info;
70 return true;
71 }
24
25. find
73 bool find( const T & element )
75 {
76 T item;
77 if ( !first( item ) ) Overloaded
78 return false; operator if T is
79 do if ( item == element ) a struct object
80 return true;
81 while ( getNext( item ) );
82
83 return false;
84 }
25
26. retrieve
87 bool retrieve( T & element )
88 {
89 if ( !find( element ) )
90 return false;
91 element = current->info;
92 return true;
93 }
26
28. remove
105 bool remove( T & element )
106 {
107 current = NULL;
108 if ( start == NULL )
109 return false; We need to keep
110 Node<T> *ptr = start; ptr one node in
111 if ( ptr->info == element ) { front of the node to
112 start = start->next; remove, so the first
113 delete ptr; node is a special
114 return true; case.
115 }
remove continued…
28