Програмиране 51 - Сложност на Алгоритми

Когато говорим за алгоритми, обикновенно говорим за тяхната "скорост"

Трябва ни начин, по който да сравняваме алгоритми.

Броене на стъпки ~ Броене на инструкции

Броене на инструкции

1. Деклариране на променлива и смяна на стойност.

2. Индексиране на масив.

3. Сравнение на стойности.

4. Аритметичните операции.

5. Викане на функция / метод

Броене на инструкции

package com.hackbulgaria.datastructures;

public class Examples {

  public static double average(int[] numbers) {
    double sum = 0;
    int i = 0;
    int n = numbers.length;

    while (i < n) {
      sum = sum + numbers[i];
      i = i + 1;
    }

    return sum / n;
  }

  public static void main(String[] args) {
    int[] array = { 1, 2, 3, 4 };
    System.out.println(String.format("Average: %.2f", average(array)));

  }
}

Броене на инструкции

Дължината на входа е много важна!

• Ако искате да знаем "колко бърз" е даден алгоритъм, броим стъпките, които му трябват, за да приключи.

• Тези стъпки обикновенно се дефинират като  функция от дължината на входа.

• 5 + 6n означава 605 стъпки, за да сметнем средното аритметично от масив с n = 100 елемента.

Counting instructions

package com.hackbulgaria.datastructures;

public class Examples {

  public static boolean sumToZero(int[] numbers) {
    boolean result = false;
    int n = numbers.length;
    
    for(int i = 0; i < n; i += 1) {
      for(int j = 0; j < n; j += 1) {
        if(numbers[i] + numbers[j] == 0) {
          result = true;
          break;
        }
      }
    }
    
    return result;
  }

  public static void main(String[] args) {
    int[] array = { 2, 3, 4, -1, 1 };
    System.out.println(String.format("To zero: %b", 
                                     sumToZero(array)));

  }
}

Counting instructions

Броене на инструкции

Броене на инструкции

• Не се интересуваме от c2. Няма да видим съществена разлика в бързодействието.

• Този начин на броене е труден и не особено интуитивен.

• Представете си какво ще се случи, ако имаме if-ове.

Кой алгоритъм е по-бърз?

vs.

"По-мързелив" подход за оценяване на алгоритми

vs.

Complexity Analysis

Complexity Analysis - сравняване на функции

Класове от функции - Линейни

Класове от функции - Квадратни

Квадратните ф-и са "по-бавни" от линейните

Сложност на алгоритъм

• Сложността на един алгоритъм ще е основният начин, по който ще го измерваме.

• Може да имаме "сложност по време" - това ни дава приближение за скоростта на алгоритъма.

• Може да имаме и "сложност по памет" - това ни дава приближение колко памет ще заеме алгоритъма.

• Ще се фокусираме върху "сложност по време"

Сложност на алгоритъм & Дължина на входа

• Дължината на входа е основната, върху която може да определим сложността на дадем алгоритъм.

• Обикновенно, когато обхождаме масив, дължината на входа е дължината на масива.

• Ще разглеждаме и много други случаи.

Нека напишем търсене.

public class Example {
  public static boolean search(int element, int[] items) {
    for (int item : items) {
      if (item == element) {
        return true;
      }
    }

    return false;
  }
 
 public static void main(String[] args) {
    int[] array = { 2, 3, 4, -1 };
    int[] largeArray = new int[1000000];
    largeArray[1000000 - 1] = 2;
    System.out.println(search(2, array)); // 1 step
    System.out.println(search(2, largeArray)); // 999999 steps

  }
}

За сложност на алгоритъм, ще се интересуваме от "най-лошия случай"

Big Oh Notation

O(n) - Примери

• Линейното търсене е O(n)
• Сумата на всички елементи в масив е O(n)
• Всеки алгоритъм, който се нужда от едно пълно обхождане на даден масив е O(n)

Квадратични алгоритми

package com.hackbulgaria.datastructures;

public class Examples {

  public static boolean sumToZero(int[] numbers) {
    boolean result = false;
    int n = numbers.length;
    
    for(int i = 0; i < n; i += 1) {
      for(int j = 0; j < n; j += 1) {
        if(numbers[i] + numbers[j] == 0) {
          result = true;
          break;
        }
      }
    }
    
    return result;
  }

  public static void main(String[] args) {
    int[] array = { 1, 2, 3, 4, -1 };
    System.out.println(String.format("To zero: %b", 
                                     sumToZero(array)));

  }
}

• Стъпките, които му трябват са пропорционални на квадрата на дължината на входа.

• Много по-бавни от линейните.

• Два вложени цикъла обикновенно дават квадратичен алгоритъм.

• Така нареченото "константно" време, което не зависи от дължината на входа.

• Операциите в езика обикновенно са константни.

• Достъпване на индекси, викане на функции / методи и други.

• Може да го считате като "става веднага"

Сравняване на алгоритми по тяхната сложност

Ще сравняваме нашите алгоритми използвайки "Big-Oh" нотацията.