Lec 4

List Using Linked Memory
 Various cells of memory are not

allocated consecutively in memory.
 Not enough to store the elements of
the list.
the list.
 With arrays, the second element was
right next to the first element.
the list.
 Now the first element must explicitly
tell us where to look for the second
element.
 Not enough to store the elements of the
list.
 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
 Need a head to point to the first node
of the list. Otherwise we won’t know
 The current here is a pointer, not an
index.
Linked List
 Need a head to point to the first node of
the list. Otherwise we won’t know
 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;
};
The Node class
 class Node {
public:

private:
int object;
Node *nextNode;
};
The Node class
class Node {
 public:

private:
int object;
Node *nextNode;
};
The Node class
class Node {
public:
 int get() { return object; };

private:
int object;
Node *nextNode;
};
The Node class
class Node {
public:
 void set(int object) { this->object = object; };

private:
int object;
Node *nextNode;
};
The Node class
class Node {
public:
 Node *getNext() { return nextNode; };

private:
int object;
Node *nextNode;
};
The Node class
class Node {
public:

 void setNext(Node *nextNode)
private:
int object;
Node *nextNode;
};
The Node class
class Node {
public:

 private:
int object;
Node *nextNode;
};
The Node class
class Node {
public:

private:
 int object;
Node *nextNode;
};
The Node class
class Node {
public:

private:
int object;
 Node *nextNode;
};
#include <stdlib.h>
#include "Node.cpp"
class List {
public:
// Constructor
List() {
headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
size = 0;
};
 #include <stdlib.h>
#include "Node.cpp"
class List {
public:
// Constructor
List() {
currentNode = NULL;
size = 0;
};
#include <stdlib.h>
 #include "Node.cpp"
class List {
public:
// Constructor
List() {
currentNode = NULL;
size = 0;
};
#include <stdlib.h>
#include "Node.cpp"
 class List {
public:
// Constructor
List() {
currentNode = NULL;
size = 0;
};
#include <stdlib.h>
#include "Node.cpp"
class List {
 public:
// Constructor
List() {
currentNode = NULL;
size = 0;
};
#include <stdlib.h>
#include "Node.cpp"
class List {
public:
// Constructor
 List() {
currentNode = NULL;
size = 0;
};
#include <stdlib.h>
#include "Node.cpp"
class List {
public:
// Constructor
List() {
 headNode = new Node();
currentNode = NULL;
size = 0;
};
#include <stdlib.h>
#include "Node.cpp"
class List {
public:
// Constructor
List() {
 headNode->setNext(NULL);
currentNode = NULL;
size = 0;
};
#include <stdlib.h>
#include "Node.cpp"
class List {
public:
// Constructor
List() {
 currentNode = NULL;
size = 0;
};
#include <stdlib.h>
#include "Node.cpp"
class List {
public:
// Constructor
List() {
currentNode = NULL;
 size = 0;
};
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;
}
size++;
};
 void add(int addObject) {
>getNext());
}
else {
}
size++;
};
 Node* newNode = new Node();
>getNext());
}
else {
}
size++;
};
 newNode->set(addObject);
>getNext());
}
else {
}
size++;
};
 if( currentNode != NULL ){
>getNext());
}
else {
}
size++;
};
 newNode->setNext(currentNode-
>getNext());
}
else {
}
size++;
};
>getNext());

}
else {
}
size++;
};
>getNext());

}
else {
}
size++;
};
>getNext());

}
else {
}
size++;
};
>getNext());
}

else {
}
size++;
};
>getNext());
}
else {

}
size++;
};
>getNext());
}
else {

}
size++;
};
>getNext());
}
else {

}
size++;
};
>getNext());
}
else {

}
size++;
};
>getNext());
}
else {
}

size++;
};
>getNext());
}
else {
}
 size++;
};
Building a Linked List
List list; headNode size=0
currentNode
list.add(2); headNode 2 size=1
lastcurrentNode
currentNode
list.add(2); headNode 2 size=1
lastcurrentNode
currentNode
list.add(6); headNode 2 6 size=2
lastcurrentNode
List.add(8); list.add(7); list.add(1);
currentNode
headNode 2 6 8 7 1 size=5
lastcurrentNode
int get() {
if (currentNode != NULL)
return currentNode->get();
};
bool next() {
if (currentNode == NULL) return false;
currentNode = currentNode->getNext();
if (currentNode == NULL || size == 0)
return false;
else
return true;
};

Lec 4

Uploaded by

Copyright:

Available Formats

Lec 4

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lec 4

Uploaded by

Copyright:

Available Formats

List Using Linked Memory

 Various cells of memory are not

 The object field will hold the actual list

Node *getNext() { return nextNode; };

Node *getNext() { return nextNode; };

Node *getNext() { return nextNode; };

Node *getNext() { return nextNode; };

Node *getNext() { return nextNode; };

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

Node *getNext() { return nextNode; };

Node *getNext() { return nextNode; };

Node *getNext() { return nextNode; };

Node *getNext() { return nextNode; };

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

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

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

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

You might also like