Ctec2909 Data Structures and Algorithms: Lecture 2 Arrays & Linked Lists

CTEC2909 DATA STRUCTURES AND
ALGORITHMS
Lecture 2 Arrays & Linked Lists
Arrays
Arrays are used for storing sequences of values.
All the elements in an array are the same type – e.g. integers,
booleans, doubles, Strings, etc.
34 47 5 74 19 elements
0 1 2 3 4 indices
The above array is declared as: int[] values = new int[5];

array declaration creation of the array
Iterating through arrays
Iterating through an array: The length of the array
for (int i = 0; i < names.length; i++){
System.out.println(names[i]);
}
Accesses the element at position i
Any operation that iterates through the whole array takes

O(n) time, where n is the length of the array.
Array operations
An advantage of arrays is that accessing an element can
be done in constant time.
e.g. numbers[4]
Inserting or removing an element from the middle is
more difficult. The elements after it have to be shifted.
34 47 5 74
0 1 2 3 4
70
Array operations
In the worst case, all
34 47 5 74
the elements might
0 1 2 3 4 have to move.
Therefore it is O(n)
34 47 5 74 complexity, where n is
0 1 2 3 4 the length of the array.
34 47 70 5 74
0 1 2 3 4
Array operations
Searching for a particular element also requires
searching through the whole array in the worst case –
the worst case is when the element is not in the array.
for (int i = 0; i < values.length; i++){

if (values[i] == searchItem){
return true;
}
}
return false;
Linked Lists
Linked lists are another type of data structure for storing
sequences. null
34 47 5 74
head tail
This time, each element is stored as a separate object, with a
link to the next element.
Implementation of a Linked List
red blue orange green
A Node has some data (in this case a String) and a link to the next node.
In C++ the link could be a pointer. In Java it is a reference to the next

node, so it is another Node object.
There has to be a way of getting the data and setting the data, and
getting the next link and setting the next link.
public class Node{ This could be other types e.g. int, depending
private String item; on what you want to store in the list.
private Node nextItem;
public Node(String s){ This is a constructor. It states how to

item = s; initialise the instance of the class.
}
}
public void setItem(String s){
public class Node{
item = s;
private String item;
}
private Node nextItem;
public Node next(){
public Node(String s, Node n){
return nextItem;
item = s;
}
nextItem = n;
}
public void setNext(Node n){
nextItem = n;
public String getItem(){
}
return item;
} // End of class.
}
To create the above list:

null
Node n4 = new Node(“green”, null);
Node n3 = new Node(“orange”, n4);
Node n2 = new Node(“blue”, n3);
Node n1 = new Node(“red”, n2);
What is the output of the following: null

Node n = n1.next(); This returns the next node, n2.
String s = n1.next().getItem();
n1.next() gives n2 so then it becomes:
n2 n2.getItem(), which gives “blue”.
What is the output of the following: null

n = n1.next().next(); n1.next() gives n2 so then it becomes:
n2.next(), which gives the node n3.
s = n1.next().next().getItem();
n1.next().next() gives n3 so then it becomes:
n3.getItem() which gives “orange”.
n2
n3
Problem: How do we have the reference to the first node? null

Solution: It is stored as a head variable in a LinkedList class.
The LinkedList class represents the list, but we don’t need to store
all the nodes in it.
Each node has a link to the next, so we only need a link to the first
node.
null
public class LinkedList(){ public getHead(){
private Node head; return head;
}
public LinkedList(Node n){ public setHead(Node n){
head = n; head = n;
} }
}// end of class
Now we can create a LinkedList: null

Node n4 = new Node(“green”, null);
Node n3 = new Node(“orange”, n4);
Node n2 = new Node(“blue”, n3);
Node n1 = new Node(“red”, n2); This sets the head of the
linked list to n1.
LinkedList list = new LinkedList(n1);
head Implementation of a Linked List
Now we can get the head node like this: null
Node theHead = list.getHead(); This returns the node n1.
n = theHead.next(); This returns the node n2.
theHead.next().next().setItem(“yellow”);
This changes the 3rd node to “yellow”.
Linked Lists Insertion
Inserting after a given node:
Node newItem = new Node(“white”, null);

newItem.setNext(n1.next());
white
n1.setNext(newItem);
This is just O(1)!
Linked Lists Deletion
What about deletion (delete after)?
This is just O(1) again.

n1.setNext(n1.next().next()); Compare that to deletion in
arrays – all the elements
n2 beyond it have to be moved
This is equivalent to: back.
n1.setNext(n3); n3
Linked Lists Searching
34 47 5 74
public boolean find(String item){
bool found = false; Searching is not so easy.
Node current = head;
while (!found && current != null){
To find a particular
if (current.getItem().equals(searchItem)){ element, the whole
found = true; list has to be
} traversed in the
current = current.next(); worst case.
return found; Therefore it is O(n).
}
Linked Lists vs Arrays
Arrays have fast access to any element. Linked lists must
traverse the list to reach elements.
Linked lists have fast insertion (inserting after a node) and

deletion anywhere in the list. Arrays must shift elements to
make room or fill up spaces.
Searching is the same for both.
Arrays have a fixed size. Linked lists can be increased or

decreased as needed.
Doubly Linked Lists
Inserting after a given node is easy but inserting before requires
traversing the list to get to the node before.
Solution: Have previous links as well.
public class Node{ null

public Node next(){…}
public Node previous(){…}
Doubly Linked Lists Insertion
Inserting after a given node:

white newItem.setPrevious(n1);
n1.next().setPrevious(newItem);
Doubly Linked Lists Insertion
Inserting before a given node:

newItem.setNext(n2);
white newItem.setPrevious(n2.getPrevious());
n2.previous().setNext(newItem);
n2.setPrevious(newItem);
Now this is O(1) too!
Doubly Linked Lists Deletion
Previously we only looked at deleting after a given node.
n1.next().next().setPrevious(n1);
n3 n1.setNext(n1.next().next());
Doubly Linked Lists Deletion
Deleting before a given node:
n3.previous().previous().setNext(n3);
n3.setPrevious(n3.previous().previous());
n1
Tail Element
Doubly-linked lists have a tail element as well as the head.
head null
tail
This allows the list to be traversed from either end, using the
previous links from the tail or the next links from the head.
Singly-linked lists can also have a tail. This could be useful for
adding to the end of the list.
Circular Linked Lists
Instead of the last element pointing to null, it can point to the
head element.
head n = n4.next(); This gives the first node.

n4.next() == head returns true
A circular list with one element:
red The only node in the list

points to itself.
head
Adding a node to the start of the list:
Node newItem = new Node(“yellow”, head);
head = newItem;
Adding a node anywhere else:

Node newItem = new Node(“yellow”, null);
Using a sentinel or “dummy” node makes it the same for both cases:
dummy red blue green
head Inserting after a given node n:

Node newItem = new Node(“yellow”, null);
newItem.setNext(n.next());
n.setNext(newItem);

Ctec2909 Data Structures and Algorithms: Lecture 2 Arrays & Linked Lists

Uploaded by

Copyright:

Available Formats

Ctec2909 Data Structures and Algorithms: Lecture 2 Arrays & Linked Lists

Uploaded by

Document Information

Original Description:

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

Ctec2909 Data Structures and Algorithms: Lecture 2 Arrays & Linked Lists

Uploaded by

Copyright:

Available Formats

CTEC2909 DATA STRUCTURES AND

The above array is declared as: int[] values = new int[5];

Any operation that iterates through the whole array takes

for (int i = 0; i < values.length; i++){

In C++ the link could be a pointer. In Java it is a reference to the next

public Node(String s){ This is a constructor. It states how to

To create the above list:

What is the output of the following: null

What is the output of the following: null

Problem: How do we have the reference to the first node? null

Now we can create a LinkedList: null

Now we can get the head node like this: null

Node theHead = list.getHead(); This returns the node n1.

n = theHead.next(); This returns the node n2.

red blue orange green

Node newItem = new Node(“white”, null);

red blue orange green

This is just O(1) again.

Linked lists have fast insertion (inserting after a node) and

Searching is the same for both.

Arrays have a fixed size. Linked lists can be increased or

red blue orange green

public class Node{ null

red blue orange green

Node newItem = new Node(“white”, null);

red blue orange green

Node newItem = new Node(“white”, null);

red blue orange green

red blue orange green

red blue orange green

head n = n4.next(); This gives the first node.

red The only node in the list

Adding a node anywhere else:

head Inserting after a given node n:

You might also like