feat: add Longest Increasing Subsequence (#197)

* Added framework and some tests for longest_increasing_subsequence

* Added test cases and fixed logic

* fix: cargo fmt the code

Co-authored-by: imp <imp07@qq.com>

Author: ColeSeverson

DIRECTORY.md

@@ -20,6 +20,7 @@
     * [Fibonacci](https://github.com/TheAlgorithms/Rust/blob/master/src/dynamic_programming/fibonacci.rs)
     * [Knapsack](https://github.com/TheAlgorithms/Rust/blob/master/src/dynamic_programming/knapsack.rs)
     * [Longest Common Subsequence](https://github.com/TheAlgorithms/Rust/blob/master/src/dynamic_programming/longest_common_subsequence.rs)
+    * [Longest Increasing Subsequence](https://github.com/TheAlgorithms/Rust/blob/master/src/dynamic_programming/longest_increasing_subsequence.rs)
     * [Maximum Subarray](https://github.com/TheAlgorithms/Rust/blob/master/src/dynamic_programming/maximum_subarray.rs)
   * General
     * [Convex Hull](https://github.com/TheAlgorithms/Rust/blob/master/src/general/convex_hull.rs)

README.md

@@ -32,7 +32,7 @@ These are for demonstration purposes only.
 - [x] [0-1 Knapsack](./src/dynamic_programming/knapsack.rs)
 - [x] [Edit Distance](./src/dynamic_programming/edit_distance.rs)
 - [x] [Longest common subsequence](./src/dynamic_programming/longest_common_subsequence.rs)
-- [ ] Longest increasing subsequence
+- [x] [Longest increasing subsequence](./src/dynamic_programming/longest_increasing_subsequence.rs)
 - [x] [K-Means Clustering](./src/general/kmeans.rs)
 - [x] [Coin Change](./src/dynamic_programming/coin_change.rs)
 - [ ] Rod cut

src/dynamic_programming/longest_increasing_subsequence.rs

@@ -0,0 +1,68 @@
+pub fn longest_increasing_subsequence<T: Ord>(input_array: &[T]) -> &[T] {
+    let length: usize = input_array.len();
+
+    //Handle the base cases
+    if length <= 1 {
+        return input_array;
+    }
+
+    //Create the array to store the longest subsequence at each location
+    let mut tracking_vec = vec![1; length];
+
+    //Iterate through the input and store longest subsequences at each location in the vector
+    for i in (0..length - 1).rev() {
+        if input_array[i] < input_array[i + 1] {
+            tracking_vec[i] = tracking_vec[i + 1] + 1;
+        }
+    }
+
+    //Find the longest subsequence
+    let mut max_index: usize = 0;
+    let mut max_value: i32 = 0;
+    for (index, value) in tracking_vec.iter().enumerate() {
+        if value > &max_value {
+            max_value = *value;
+            max_index = index;
+        }
+    }
+
+    &input_array[max_index..max_index + max_value as usize]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::longest_increasing_subsequence;
+
+    #[test]
+    fn test_longest_increasing_subsequence() {
+        //Base Cases
+        let base_case_array: [i32; 0] = [];
+        assert_eq!(&longest_increasing_subsequence(&base_case_array), &[]);
+        assert_eq!(&longest_increasing_subsequence(&[1]), &[1]);
+
+        //Normal i32 Cases
+        assert_eq!(
+            &longest_increasing_subsequence(&[1, 2, 3, 4]),
+            &[1, 2, 3, 4]
+        );
+        assert_eq!(
+            &longest_increasing_subsequence(&[1, 2, 2, 3, 4, 2]),
+            &[2, 3, 4]
+        );
+        assert_eq!(&longest_increasing_subsequence(&[5, 4, 3, 2, 1]), &[5]);
+        assert_eq!(
+            &longest_increasing_subsequence(&[5, 4, 3, 4, 2, 1]),
+            &[3, 4]
+        );
+
+        //Non-Numeric case
+        assert_eq!(
+            &longest_increasing_subsequence(&['a', 'b', 'c']),
+            &['a', 'b', 'c']
+        );
+        assert_eq!(
+            &longest_increasing_subsequence(&['d', 'c', 'd']),
+            &['c', 'd']
+        );
+    }
+}

src/dynamic_programming/mod.rs

@@ -4,6 +4,7 @@ mod egg_dropping;
 mod fibonacci;
 mod knapsack;
 mod longest_common_subsequence;
+mod longest_increasing_subsequence;
 mod maximum_subarray;
 
 pub use self::coin_change::coin_change;
@@ -13,4 +14,5 @@ pub use self::fibonacci::fibonacci;
 pub use self::fibonacci::recursive_fibonacci;
 pub use self::knapsack::knapsack;
 pub use self::longest_common_subsequence::longest_common_subsequence;
+pub use self::longest_increasing_subsequence::longest_increasing_subsequence;
 pub use self::maximum_subarray::maximum_subarray;