Swift: Efficient solutions for nested for loops - ios

Question

I am looking for a more efficient solution for exhaustively comparing objects of the same array to each in Swift. Nesting for-in loops is exhaustive, simple, and returns correct results but the time complexity is O(n^2) which nobody recommends when it comes to performance and larger data sets. I hunted around for solutions for a long time, and only found people describing the for-in loop scenario as a classic example of quadratic time complexity. Help?
EDIT (now includes func tableView(tableView: cellForRowAt:) code ) :
Ok let’s go deeper as requested.
Think of a UITableView where you have an array of Event objects.
Event is a class, and you want to exhaustively check the array’s Event objects against each other for conflicts.
The array is already sorted chronologically by each Event element’s startTike property. There could be duplicate events because maybe a user would want that (who knows why, but that’s the end user’s choice to make).
Each Event object has a DateInterval property for this check.
If a conflict is found, you will need to run logic to evaluate the conflict.
If certain criteria are met, then you set a Boolean property (isConflicted) on the Event object.
The resulting array is then used to pass the indexPath.row specific Event object to a custom UITableViewCell for presentation in the UITableView where that ‘isConflicted’ Boolean is integral to the UITableViewCell’s layout/presentation.
Here is the nested for in loop solution I have working just fine, though the run time complexity is not great.
apologies for not including code earlier. i, mistakenly, didn't think it was necessary.
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
// unwrap my custom cell
guard let cell = tableView.dequeueReusableCell(withIdentifier: "eventCell", for: indexPath) as? EventDetailTableViewCell else {
return UITableViewCell()
}
// get the relevant section's events array from EventModelController.shared.groupedEventsDictionary check for nil
guard let events = EventModelController.shared.groupedEventsDictionary[sections[indexPath.section]] else {
print("ERROR: no event value found in EventModelController.shared.groupedEventsDictionary[sections[indexPath.section]] in EventsTableViewController.swift -> tableView(cellForRowAt:) - line 117.")
return UITableViewCell()
}
var eventDictionary: [DateInterval : Event] = [:]
for event in events {
eventDictionary[event.dateInterval] = event
}
// START: - option with time complexity O(n^2) that always works
// check the array for conflicts and set relevant event's isConflicted property
for event in events {
for anotherEvent in events {
// ensure that we don't redundantly check the same events against themselves
if event != anotherEvent {
if event.dateInterval.intersects(anotherEvent.dateInterval) {
if event.stopTime == anotherEvent.startTime || event.startTime == anotherEvent.stopTime {
event.isConflicted = false
} else {
event.isConflicted = true
}
}
}
}
}
// END: - option with time complexity O(n^2) that always works
// Configure the cell...
cell.event = events[indexPath.row]
return cell
}

Answer 1

There is a suggestion.
extension Array where Element: Hashable {
var containsDouplicated: Bool {
Set<Element>.init(self).count < self.count
}
}
I created this extension in order to use power of Sets to eliminate duplicated values, and after that I checked if the set (which has only unique values) has the same number of elements.
I think this is O(2n) so O(n).
There is an example of how to use it.
let a1 = [1,2,3]
let a2 = [1,2,3,4,1]
a1.containsDouplicated // false
a2.containsDouplicated // true
extension Array where Element: Hashable {
var containsDouplicated: Bool {
Set<Element>.init(self).count < self.count
}
}
EDIT: After your edit I suggest you to make Event : Hashable and implement a kind of:
extension Array where Element: Hashable {
var containsDouplicates: Bool {
Set<Element>.init(self).count < self.count
}
var orderedUniqueElements: [Element] {
var uniq: Set<Element> = .init(self)
let filtered: [Element] = self.filter { element -> Bool in
if !uniq.contains(element) {
return false
} else {
uniq.remove(element)
}
return true
}
return filtered
}
}
in order to preserve indexPath.