Skip to main content
ICT
Lesson AB25 - Order of Algorithms
 
Main Previous Next
Title Page >  
Summary >  
Lesson A1 >  
Lesson A2 >  
Lesson A3 >  
Lesson A4 >  
Lesson A5 >  
Lesson A6 >  
Lesson A7 >  
Lesson A8 >  
Lesson A9 >  
Lesson A10 >  
Lesson A11 >  
Lesson A12 >  
Lesson A13 >  
Lesson A14 >  
Lesson A15 >  
Lesson A16 >  
Lesson A17 >  
Lesson A18 >  
Lesson A19 >  
Lesson A20 >  
Lesson A21 >  
Lesson A22 >  
Lesson AB23 >  
Lesson AB24 >  
Lesson AB25 >  
Lesson AB26 >  
Lesson AB27 >  
Lesson AB28 >  
Lesson AB29 >  
Lesson AB30 >  
Lesson AB31 >  
Lesson AB32 >  
Lesson AB33 >  
Vocabulary >  
 

D. Linear Algorithms, O(N) page 6 of 11

  1. This is an algorithm where the number of steps is directly proportional to the size of the data set, seen in line C on the Order of Algorithms graph. As N increases, the number of steps also increases.

    public long sumData(ArrayList <Integer> list){
      long total = 0;

      Iterator <Integer> itr = list.iterator();
      while(itr.hasNext()){
        total += itr.next();
      }

      return total;
    }

  2. In the above example, as the size of the array increases, the number of steps increases at the same rate.

  3. A non-recursive linear algorithm, O(N), always has a loop involved.

  4. Recursive algorithms, in which the looping concept is developed through recursive calls, are usually linear. For example, the recursive factorial function is a linear function.

    public long fact (int n) {
    // precondition: n > 0

      if (1 == n)
        return 1;
      else
        return n * fact(n - 1);
    }

    The number of calls of fact will be n. Inside of the function is one basic step, an if/else. So we are executing one statement n times.

 

 

Main Previous Next
Contact
 © ICT 2006, All Rights Reserved.