Scribd
Upload
29 views55 pages

Lec 4

Uploaded by

Hamza Sadaat
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
29 views55 pages

Lec 4

Uploaded by

Hamza Sadaat
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 55

List Using Linked Memory

 Various cells of memory are not


allocated consecutively in memory.
List Using Linked Memory
 Various cells of memory are not
allocated consecutively in memory.
 Not enough to store the elements of
the list.
List Using Linked Memory
 Various cells of memory are not
allocated consecutively in memory.
 Not enough to store the elements of
the list.
 With arrays, the second element was
right next to the first element.
List Using Linked Memory
 Various cells of memory are not
allocated consecutively in memory.
 Not enough to store the elements of
the list.
 With arrays, the second element was
right next to the first element.
 Now the first element must explicitly
tell us where to look for the second
element.
List Using Linked Memory
 Various cells of memory are not
allocated consecutively in memory.
 Not enough to store the elements of the
list.
 With arrays, the second element was
right next to the first element.
 Now the first element must explicitly tell
us where to look for the second element.
 Do this by holding the memory address
of the second element
Linked List
 Create a structure called a Node.

object next

 The object field will hold the actual list


element.
 The next field in the structure will hold the
starting location of the next node.
 Chain the nodes together to form a linked list.
Linked List
 Picture of our list (2, 6, 7, 8, 1) stored
as a linked list:

head

2 6 8 7 1 size=5

current
Linked List
Note some features of the list:
 Need a head to point to the first node
of the list. Otherwise we won’t know
where the start of the list is.
Linked List
Note some features of the list:
 Need a head to point to the first node
of the list. Otherwise we won’t know
where the start of the list is.
 The current here is a pointer, not an
index.
Linked List
Note some features of the list:
 Need a head to point to the first node of
the list. Otherwise we won’t know
where the start of the list is.
 The current here is a pointer, not an
index.
 The next field in the last node points to
nothing. We will place the memory
address NULL which is guaranteed to
be inaccessible.
Linked List
 Actual picture in memory:
1051 6
1052 1063
current 1053 1063
1054 2
head 1055 1051
1056
2 6 8 7 1 1057 7
1058 1060
current 1059
1060 1
1061 0
head 1062 1054
1063 8
1064 1057
1065
Linked List Operations
 add(9): Create a new node in memory to hold ‘9’
Node* newNode = new Node(9); newNo 9
de
Linked List Operations
 add(9): Create a new node in memory to hold ‘9’
Node* newNode = new Node(9); newNo 9
de
 Link the new node into the list

head

2 6 8 7 1 size=5 6

current 2 1
3
9

newNo
de
C++ Code for Linked List
The Node class
class Node {
public:
int get() { return object; };
void set(int object) { this->object = object; };

Node *getNext() { return nextNode; };


void setNext(Node *nextNode)
{ this->nextNode = nextNode; };
private:
int object;
Node *nextNode;
};
C++ Code for Linked List
The Node class
 class Node {
public:
int get() { return object; };
void set(int object) { this->object = object; };

Node *getNext() { return nextNode; };


void setNext(Node *nextNode)
{ this->nextNode = nextNode; };
private:
int object;
Node *nextNode;
};
C++ Code for Linked List
The Node class
class Node {
 public:
int get() { return object; };
void set(int object) { this->object = object; };

Node *getNext() { return nextNode; };


void setNext(Node *nextNode)
{ this->nextNode = nextNode; };
private:
int object;
Node *nextNode;
};
C++ Code for Linked List
The Node class
class Node {
public:
 int get() { return object; };
void set(int object) { this->object = object; };

Node *getNext() { return nextNode; };


void setNext(Node *nextNode)
{ this->nextNode = nextNode; };
private:
int object;
Node *nextNode;
};
C++ Code for Linked List
The Node class
class Node {
public:
int get() { return object; };
 void set(int object) { this->object = object; };

Node *getNext() { return nextNode; };


void setNext(Node *nextNode)
{ this->nextNode = nextNode; };
private:
int object;
Node *nextNode;
};
C++ Code for Linked List
The Node class
class Node {
public:
int get() { return object; };
void set(int object) { this->object = object; };

 Node *getNext() { return nextNode; };


void setNext(Node *nextNode)
{ this->nextNode = nextNode; };
private:
int object;
Node *nextNode;
};
C++ Code for Linked List
The Node class
class Node {
public:
int get() { return object; };
void set(int object) { this->object = object; };

Node *getNext() { return nextNode; };


 void setNext(Node *nextNode)
{ this->nextNode = nextNode; };
private:
int object;
Node *nextNode;
};
C++ Code for Linked List
The Node class
class Node {
public:
int get() { return object; };
void set(int object) { this->object = object; };

Node *getNext() { return nextNode; };


void setNext(Node *nextNode)
{ this->nextNode = nextNode; };
 private:
int object;
Node *nextNode;
};
C++ Code for Linked List
The Node class
class Node {
public:
int get() { return object; };
void set(int object) { this->object = object; };

Node *getNext() { return nextNode; };


void setNext(Node *nextNode)
{ this->nextNode = nextNode; };
private:
 int object;
Node *nextNode;
};
C++ Code for Linked List
The Node class
class Node {
public:
int get() { return object; };
void set(int object) { this->object = object; };

Node *getNext() { return nextNode; };


void setNext(Node *nextNode)
{ this->nextNode = nextNode; };
private:
int object;
 Node *nextNode;
};
C++ Code for Linked List

#include <stdlib.h>
#include "Node.cpp"

class List {
public:
// Constructor
List() {
headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
size = 0;
};
C++ Code for Linked List

 #include <stdlib.h>
#include "Node.cpp"

class List {
public:
// Constructor
List() {
headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
size = 0;
};
C++ Code for Linked List

#include <stdlib.h>
 #include "Node.cpp"

class List {
public:
// Constructor
List() {
headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
size = 0;
};
C++ Code for Linked List

#include <stdlib.h>
#include "Node.cpp"

 class List {
public:
// Constructor
List() {
headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
size = 0;
};
C++ Code for Linked List

#include <stdlib.h>
#include "Node.cpp"

class List {
 public:
// Constructor
List() {
headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
size = 0;
};
C++ Code for Linked List

#include <stdlib.h>
#include "Node.cpp"

class List {
public:
// Constructor
 List() {
headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
size = 0;
};
C++ Code for Linked List

#include <stdlib.h>
#include "Node.cpp"

class List {
public:
// Constructor
List() {
 headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
size = 0;
};
C++ Code for Linked List

#include <stdlib.h>
#include "Node.cpp"

class List {
public:
// Constructor
List() {
headNode = new Node();
 headNode->setNext(NULL);
currentNode = NULL;
size = 0;
};
C++ Code for Linked List

#include <stdlib.h>
#include "Node.cpp"

class List {
public:
// Constructor
List() {
headNode = new Node();
headNode->setNext(NULL);
 currentNode = NULL;
size = 0;
};
C++ Code for Linked List

#include <stdlib.h>
#include "Node.cpp"

class List {
public:
// Constructor
List() {
headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
 size = 0;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
 void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
 Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
 newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
 if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
 newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());

currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );

lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;

currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}

else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {

newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);

headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);

lastCurrentNode = headNode;
currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;

currentNode = newNode;
}
size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}

size++;
};
C++ Code for Linked List
void add(int addObject) {
Node* newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL ){
newNode->setNext(currentNode-
>getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else {
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
 size++;
};
Building a Linked List
List list; headNode size=0
Building a Linked List
List list; headNode size=0

currentNode

list.add(2); headNode 2 size=1

lastcurrentNode
Building a Linked List
List list; headNode size=0

currentNode

list.add(2); headNode 2 size=1

lastcurrentNode

currentNode

list.add(6); headNode 2 6 size=2

lastcurrentNode
Building a Linked List

List.add(8); list.add(7); list.add(1);

currentNode

headNode 2 6 8 7 1 size=5

lastcurrentNode
C++ Code for Linked List

int get() {
if (currentNode != NULL)
return currentNode->get();
};
C++ Code for Linked List
bool next() {
if (currentNode == NULL) return false;

lastCurrentNode = currentNode;
currentNode = currentNode->getNext();
if (currentNode == NULL || size == 0)
return false;
else
return true;
};

You might also like