ref: let saddleback search check if the input is sorted

Author: sozelfist

src/searching/saddleback_search.rs

@@ -3,35 +3,85 @@ use std::cmp::Ordering;
 /// Custom error type to represent errors related to matrix validation.
 #[derive(Debug, PartialEq, Eq)]
 pub enum MatrixError {
-    NonRectangularMatrix,
+    NonRectangularInput,
+    NotSorted,
 }
 
-/// Performs Saddleback search on a sorted 2D matrix.
+/// Checks if the given matrix (vector of vectors) is sorted row-wise and column-wise.
+///
+/// A matrix is considered sorted if
+///
+/// * Each row is sorted in non-decreasing order.
+/// * Each column is sorted in non-decreasing order.
+///
+/// # Arguments
+///
+/// * `matrix` - A vector of vectors representing the matrix to check.
+///
+/// # Returns
+///
+/// Returns `true` if the matrix is sorted both row-wise and column-wise. Otherwise, returns `false`.
+fn is_sorted(matrix: &[Vec<isize>]) -> bool {
+    if matrix.is_empty() || matrix.iter().all(|row| row.is_empty()) {
+        return true;
+    }
+
+    let rows = matrix.len();
+    let cols = matrix[0].len();
+
+    // Check if rows are sorted.
+    for row in matrix {
+        if row.windows(2).any(|w| w[0] > w[1]) {
+            return false;
+        }
+    }
+
+    // Check if columns are sorted.
+    for col in 0..cols {
+        for row in 1..rows {
+            if matrix[row - 1][col] > matrix[row][col] {
+                return false;
+            }
+        }
+    }
+
+    true
+}
+
+/// Performs Saddleback search on a sorted matrix represented as a vector of vectors.
 ///
 /// The Saddleback search algorithm finds the position of a target element in a matrix where
 /// each row and each column is sorted in ascending order. The search starts from the top-right
 /// corner of the matrix and moves left or down based on comparisons with the target element.
 ///
+/// Optionally, the matrix can be validated for being sorted before the search starts.
+///
 /// # Arguments
 ///
-/// * `matrix` - A 2D vector representing the sorted matrix.
+/// * `matrix` - A vector of vectors representing the sorted matrix.
 /// * `element` - The target element to search for.
+/// * `check_sorted` - If true, verifies that the matrix is sorted before performing the search.
 ///
 /// # Returns
 ///
 /// Returns `Ok(Some((row, column)))` where both indices are 0-based if the element is found.
 /// Returns `Ok(None)` if the element is not found.
-/// Returns `Err(MatrixError)` if the matrix is not rectangular.
+/// Returns `Err(MatrixError)` if the matrix is not rectangular or not sorted.
 pub fn saddleback_search(
     matrix: &[Vec<isize>],
     element: isize,
+    check_sorted: bool,
 ) -> Result<Option<(usize, usize)>, MatrixError> {
     if matrix.is_empty() || matrix.iter().all(|row| row.is_empty()) {
         return Ok(None);
     }
 
     if matrix.iter().any(|row| row.len() != matrix[0].len()) {
-        return Err(MatrixError::NonRectangularMatrix);
+        return Err(MatrixError::NonRectangularInput);
+    }
+
+    if check_sorted && !is_sorted(matrix) {
+        return Err(MatrixError::NotSorted);
     }
 
     let mut left_index = 0;
@@ -66,7 +116,7 @@ mod tests {
                 #[test]
                 fn $name() {
                     let (matrix, element, expected) = $tc;
-                    assert_eq!(saddleback_search(&matrix, element), expected);
+                    assert_eq!(saddleback_search(&matrix, element, true), expected);
                 }
             )*
         };
@@ -171,7 +221,7 @@ mod tests {
                 vec![3, 30, 300],
             ],
             20,
-            Err::<Option<(usize, usize)>, MatrixError>(MatrixError::NonRectangularMatrix),
+            Err::<Option<(usize, usize)>, MatrixError>(MatrixError::NonRectangularInput),
         ),
         test_empty_row: (
             vec![
@@ -180,7 +230,7 @@ mod tests {
                 vec![4, 5, 6],
             ],
             3,
-            Err::<Option<(usize, usize)>, MatrixError>(MatrixError::NonRectangularMatrix),
+            Err::<Option<(usize, usize)>, MatrixError>(MatrixError::NonRectangularInput),
         ),
         test_full_empty_rows: (
             vec![
@@ -192,5 +242,14 @@ mod tests {
             1,
             Ok(None::<(usize, usize)>),
         ),
+        test_unsorted_matrix_with_check: (
+            vec![
+                vec![1, 10, 100],
+                vec![20, 200, 2],
+                vec![3, 30, 300],
+            ],
+            200,
+            Err::<Option<(usize, usize)>, MatrixError>(MatrixError::NotSorted),
+        ),
     }
 }