Lecture 2 - Computational Complexity / Parsing and String Manipulation

Additional resources can be found here.

Computational Complexity

• Describes the "difficulty" of a problem
• States resource usage as a function of the given problem's "size"
  • Usually time or memory

Big-O Notation

• Describes the asymptotic behavior of a function

• can be arbitrarily "loose"

  • If $f(x)$ is $O(n^2)$, it is also $O(n^3)$, $O(n^4)$, $O(2^n)$, etc.

• Definition $$ f(n) = O(g(n)) \text{ if there exist constants } c > 0 \text{ and } n_0 > 0 \text{ such that } 0 \leq f(n) \leq c \cdot g(n) \text{ for all } n \geq n_0 $$

When is O(n²) Better than O(n)?

• 4n² < 1000n whenever n < 250.
  • When n is known to be small and the O(n²) algorithm has a lower constant factor than the O(n) algorithm.
  • In such cases, even though O(n²) grows faster with larger n, the actual performance for small n can be better than the O(n) algorithm due to a smaller constant factor.

Big-O Examples

• Checking whether an item is present in a linked list: O(n)

  • Scan through the entire list until the item is found (on average n/2 checks)

• Checking whether an item is present in an unordered binary tree: O(n)

• Checking whether an item is present in a binary search tree: O(H)

  • If the tree is degenerate (like a linked list), H = n
  • If the tree is balanced, H = log n

Big-O Sanity-Checking

• Determine the least conceivable work or space needed to accomplish the task
  • Can NOT be O(log n) or faster than O(n) to examine every single item of input
  • Can NOT be faster than O(n²) for quadratic working memory

Amortized Time

• Additional resources can be found here.

Parsing and String Manipulation

Java String Functions: Access

Java String Functions: Testing

Java String Functions: Modification

Java String Functions: Assembly/Disassembly

Java String Functions: Comparison

Regular Expressions

Building Blocks of Regular Expressions

1. Character Literal: Matches a specific character

   • "a": Matches the letter a

2. Character Wildcard (.): Matches any single character

   • ".": Matches any character

3. Character Set ([...]): Matches any one of the characters within the brackets

   • "[aeiou]": Matches any vowel
   • ([^...]): Matches anything not in the set
   • [^0-9]: Matches any character that is not a digit

4. Repetition:

   • X?: Matches 0 or 1 occurrence of X (X is optional)
   • X*: Matches 0 or more occurrences of X
   • X+: Matches 1 or more occurrences of X

5. Concatenation: Combines multiple expressions

   • XY: Matches X followed by Y

6. Alternation (|): Matches either the expression before or after |

   • X|Y: Matches X or Y

Anchors

• ^ (Caret): Matches the start of the string

  • ^abc: Matches abc only at the start

• $ (Dollar): Matches the end of the string

  • abc$: Matches abc only at the end

Extended Regular Expressions

1. Finer Control Over Repetition:

   • X{m,n}: Matches at least m and at most n occurrences of X
   • X{m,}: Matches at least m consecutive occurrences of X
   • X{,n}: Matches at most n consecutive occurrences of X

2. Grouping and Capture:

   • (X...): Groups expressions to be treated as a single unit
   • ...(X)...: Captures matched text for later reference

Special Use of Backslash (\)

1. Escape Special Characters: Makes a special character literal

   • \[ : Matches [

2. Referencing Matches:

   • \1, \2, etc., refer to previously captured groups

3. Shortcut Expressions:

   • \s: Matches any whitespace
   • \d: Matches any digit ([0-9])
   • \D: Matches any non-digit
   • \w: Matches any word character ([a-zA-Z0-9_])

4. Literal Backslash:

   • Use \\ to match a single backslash

Regular Expression Examples

Regex Functions in Java

• String.split

  • String.split is a convenience function that internally uses Pattern.compile(re).split(str).

    String[] parts = "a,b,c".split(",");
    

• Efficient Re-use of Regex

  • More efficient to compile once and reuse the Pattern object.

    Pattern p = Pattern.compile(regex);
    

• Processing Multiple Matches

  • Create a Matcher object to find multiple matches within a string.

    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(string);
    

    • m.matches():
      • Equivalent to string.matches(regex), checks if the entire string matches the pattern.
    • m.find():
      • Looks for the next match in the string, returns true if found.
    • m.group():
      • Returns the string that was matched by the most recent find().

• Usage Example

  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  public class RegexTest {
      public static void main(String[] args) {
          // Define the regex pattern
          String regex = "\\bword\\b"; // "\\b" represents word boundary
          
          // Compile the pattern
          Pattern pattern = Pattern.compile(regex);
          
          // Input string to match against
          String input = "This is a word in a sentence. Another word appears here.";
  
          // Create a Matcher object
          Matcher matcher = pattern.matcher(input);
          
          // Check if the entire string matches the pattern
          if (matcher.matches()) {
              System.out.println("The entire string matches the pattern.");
          } else {
              System.out.println("The entire string does not match the pattern.");
          }
  
          // Find and print all occurrences of the pattern
          while (matcher.find()) {
              System.out.println("Found a match: " + matcher.group() + " at position " + matcher.start());
          }
      }
  }
  
  /*
  Outputs:
  Found a match: word at position 10
  Found a match: word at position 38
  */
  

Back to Home Next Lecture