Upload
cecilia-reyner
View
224
Download
1
Embed Size (px)
Citation preview
CS1020 Lab 3(Linked List)Problem 1: BallsProblem 2: JosephineProblem 3: Alternating List
Problem 1: Balls
Problem:- Given N balls labeled from 1 to N and
M operations, determine the last state after doing M operations.
Input◦ The first line contains two integers, ◦ N (1<= N <= 1,000) and
M (1<= M <= 1,000)◦ The next M lines contain the
operations.
#1: Balls
Sample Input
10 5 A 2 1 A 10 1 A 5 6 B 6 9 R 3
Operations:1. A x y: move the ball labeled with number x to
the left of the ball labeled with number y.2. B x y: move the ball labeled with number x to
the right of the ball labeled with number y.3. R x: Remove the ball labeled with number x
from our list.Output: Output the final arrangement of the N balls
from left to right. Each number is followed by a whitespace.
1. What kind of data structure can we use to solve this problem?
Discussion (1)
1. Hint: use List- Q: What kind of List (Singly-Linked List/
Doubly-Linked List/ Circular-Linked List)?- A: Use Doubly-Linked List
Why?
Discussion (2)
2.
Simplest implementation:-Traversing all the nodes (to find the correct node) for removing and moving
Better implementation:- Without traversing through the nodes (will be discussed later)
Discussion (3)
ListNode stores:1. Number/Id2. Previous Ball3. Next Ball
Discussion (4)
ID
int ID
ListNode next
ListNode prev
Remove:1. Find position of x2. Update the affected ListNode.
Discussion (5)
Rough steps:◦ Iterate though the list to find the node with label
x, and remember which node it is (point to it from a variable)
◦ Adjust the pointers
Removing
Remove node X from position
Adjusting pointers for removing
X
next
prev
Next of X
next
prev
Previous of X
next
prev
Remove node X from position
Adjusting pointers for removing
X
next
prev
Next of X
next
prev
Previous of X
next
prev
X.next.prev = X.prevX.prev.next = X.next
Must handle special case of 1st and last nodeswhen X.prev == null or X.next == null
Rough steps:◦ Iterate though the list to find the node with labels
x and y, and store them in two variables.◦ Remove node X◦ Insert node X left/right of node Y
- (practice using back the same node removed and insert it back, rather than creating a new node)
Moving
Insert X on the left of Y
Insert node
Y
next
prev
Previous of Y
next
prev
Insert X on the left of Y
Insert node
X
next
prev
Y
next
prev
Previous of Y
next
prev
X.prev = Y.prevX.next = YY.prev.next = XY.prev = X
Must handle special case of inserting X before the 1st node when Y.prev == null
Do it in the right order – don’t “lose” the previous of Y node
Insert X on the left of Y
Insert node
X
next
prev
Y
next
prev
Previous of Y
next
prev
X.prev = Y.prevX.next = YY.prev.next = XY.prev = X
Must handle special case of inserting X before the 1st node when Y.prev == null
Do it in the right order – don’t “lose” the previous of Y node
Insert X to the right of Y
Insert node
Next of Y
next
prev
Y
next
prev
Insert X to the right of Y
Insert node
X
next
prev
Next of Y
next
prev
Y
next
prev
X.next = Y.nextX.prev = YY.next.prev = XY.next = X
Must handle special case of inserting X after the last node when Y.next == null
Do it in the right order – don’t “lose” the previous of Y node
Insert X to the right of Y
Insert node
X
next
prev
Next of Y
next
prev
Y
next
prev
X.next = Y.nextX.prev = YY.next.prev = XY.next = X
Must handle special case of inserting X after the last node when Y.next == null
Do it in the right order – don’t “lose” the previous of Y node
An idea to improve performance:1. We store a “reference” of all balls
(ListNodes) in an array, so that we don’t need to traverse the Linked List to find the balls every time.
Discussion (7)
1 2 4 3 5head
1 2 3 4 5
Problem 2: Josephine
Problem:- Given N candidates in circle, we want to
keep removing the K-th candidate until we find the number of people in the circle equals to 1. Output the removed candidate for each remove operation.
#2: Josephine
Input ◦ The first line consists of T, the number of test
cases, T <= 100. ◦ The following T lines describe T test cases,
each line containing two integers, N and K. Output
◦ Output the final arrangement of the N balls from left to right. Each number is followed by a whitespace.
#2: Josephine
Sample Input23 14 2
Sample Output1 2 32 4 3 1
1. What kind of data structure can we use to solve this problem?
Discussion (1)
1. Hint:- Use Circular Linked List
Why?Simulates the problem!
Discussion (2)
Keep removing K-th person by iterating K times from current position.
Update the State of ListNode. More or less similar to Previous Problem but
using different type of LinkedList.
Discussion (3)
Removing a node:◦ Since you don’t have the previous pointer in a
singly-linked circular linked list, you need to keep track of the previous node when you traverse the list!
Circular linked list
1 2 4 3 5head
Problem 3: Alternating List
Problem: Given a list of integers, and a list of
operations, determine whether it is alternating after each operation
Definition of Alternating:-Adjacent integers have different signs
List of one or zero elements is alternating
#3: ALTERNATING LIST
Input 1 <= N <= 100 1 <= Q <= 100 N is the size of the original linked list Q the number of operations
Output For each operation print “YES” if the
updated linked list is alternating, otherwise print “NO”.
#3: ALTERNATING LISTSample Input4 4 1 -2 3 -4 M 1 3 A 1 1 14 R 2 2 A 2 1 -11 Sample OutputYES NONOYES
1. What kind of data structure can we use to solve this problem?
Discussion (1)
1. Hint: use List- Q: What kind of List (Singly-Linked List/
Doubly-Linked List/ Circular-Linked List)?- A: Use (Singly) Linked List
Why?
Discussion (2)
M [index] [size]Move “size” number of elements starting from index to the end of list
Discussion (2) - Operations
Index 1 2 3 4 5
-4 3 -2 1 2
M 2 3
Index 1 5 2 3 4
-4 2 3 -2 1
Pseudo-code:function Move (int index, int size) { for i=1 to size { temp remove element at index insert temp to the end of list }}
Why removing at the index only works?
Discussion (2) - Operations
R [index] [size] Remove “size” number of elements starting
from index.
Discussion (2) - Operations
Index 1 2 3 4 5
-4 3 -2 1 2
R 2 3
Index 1 5
-4 2
Pseudo-code:fun Remove (int index, int size) { for i=1 to size { remove element at index }}
Can you use this to implement Move?
Discussion (2) - Operations
A [index] [size] [value] add the elements between index [index]
and [index + size - 1] (inclusive) with [value].
Discussion (2) - Operations
Index 1 2 3 4 5
-4 3 -2 1 2
A 2 3 5
Index 1 2 3 4 5
-4 8 3 6 2
+5 +5 +5
Pseudo-code:fun AddValue (int index, int size, int value) { for i=1 to size { temp remove value at index+i-1 insert (temp+value) to index+i-1 }}
How do we get the (index+i-1) ?
(or we can cheat and just modify the number in listNode…)
Discussion (2) - Operations
List of 1 element : YES
Loop through list: once two adjacent elements with same sign found, return “NO” i.e. ◦ Keep track of “previousSign”, and then check
every iteration if “previousSign == currentSign”
Return “YES” if loop completes without returning
Discussion (3) - Check Alternating
The EndAny Questions?