{"id":4125,"date":"2023-04-18T10:41:53","date_gmt":"2023-04-18T13:41:53","guid":{"rendered":"https:\/\/elemarjr.com\/clube-de-estudos\/?p=4125"},"modified":"2023-10-21T21:40:24","modified_gmt":"2023-10-22T00:40:24","slug":"big-o-como-medir-a-eficiencia-dos-seus-algoritmos","status":"publish","type":"artigos","link":"https:\/\/elemarjr.com\/clube-de-estudos\/artigos\/big-o-como-medir-a-eficiencia-dos-seus-algoritmos\/","title":{"rendered":"Big-O: como medir a efici\u00eancia dos seus algoritmos"},"content":{"rendered":"\n

O Big-O \u00e9 um conceito fundamental na ci\u00eancia da computa\u00e7\u00e3o que nos ajuda a entender o desempenho dos algoritmos. Em termos simples, o Big-O nos ajuda a medir a rapidez com que um algoritmo cresce \u00e0 medida que o tamanho da entrada aumenta. Essa medida nos permite comparar a efici\u00eancia de diferentes algoritmos e selecionar a melhor op\u00e7\u00e3o para uma determinada tarefa.<\/p>\n\n\n\n

Compreendendo o Big-O<\/h2>\n\n\n\n

O Big-O \u00e9 representado por uma fun\u00e7\u00e3o matem\u00e1tica que descreve o crescimento do tempo de execu\u00e7\u00e3o do algoritmo em rela\u00e7\u00e3o ao tamanho da entrada. O Big-O nos d\u00e1 uma ideia geral da efici\u00eancia do algoritmo e nos ajuda a prever o tempo de execu\u00e7\u00e3o com base no tamanho da entrada.<\/p>\n\n\n\n

Por exemplo, um algoritmo com tempo de execu\u00e7\u00e3o O(n) cresce linearmente \u00e0 medida que o tamanho da entrada aumenta. Isso significa que, se o tamanho da entrada for dobrado, o tempo de execu\u00e7\u00e3o tamb\u00e9m ser\u00e1 dobrado. <\/p>\n\n\n\n

\"\"
Exemplo da nota\u00e7\u00e3o O-grande: f<\/em>(x<\/em>) \u2208 O(g<\/em>(x<\/em>)) de forma que existem c<\/em> > 0 (e.g., c<\/em> = 1) e x<\/em>0<\/sub> (e.g., x<\/em>0<\/sub> = 5) tal que f<\/em>(x<\/em>) \u2264 cg<\/em>(x<\/em>) sempre que x<\/em> \u2265 x<\/em>0<\/sub> – Fonte: Wikipedia<\/a><\/figcaption><\/figure>\n\n\n\n

Por outro lado, um algoritmo com tempo de execu\u00e7\u00e3o O(n\u00b2) cresce exponencialmente \u00e0 medida que o tamanho da entrada aumenta. Isso significa que, se o tamanho da entrada for dobrado, o tempo de execu\u00e7\u00e3o ser\u00e1 quadruplicado.<\/p>\n\n\n\n

Exemplos de Big-O<\/h2>\n\n\n\n

Veja alguns exemplos de algoritmos com seus respectivos Big-Os:<\/p>\n\n\n\n

O(1)<\/strong>: algoritmos de tempo constante, como acessar um elemento em um array ou fazer uma opera\u00e7\u00e3o matem\u00e1tica simples:<\/p>\n\n\n\n

C#<\/span><\/path><\/path><\/svg><\/span>
public<\/span> <\/span>static<\/span> T <\/span>AccessFirstElement<\/span><<\/span>T<\/span>>(<\/span>T<\/span>[]<\/span> array<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>return<\/span> <\/span>array<\/span>[<\/span>0<\/span>]<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Java<\/span><\/path><\/path><\/svg><\/span>
public<\/span> <\/span>static<\/span> <\/span><<\/span>T<\/span>><\/span> <\/span>T<\/span> <\/span>accessFirstElement<\/span>(<\/span>T<\/span>[]<\/span> array<\/span>)<\/span> <\/span>{<\/span><\/span>\n    <\/span>return<\/span> array<\/span>[<\/span>0<\/span>]<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Python<\/span><\/path><\/path><\/svg><\/span>
def<\/span> <\/span>access_first_element<\/span>(<\/span>array<\/span>):<\/span><\/span>\n    <\/span>return<\/span> array<\/span>[<\/span>0<\/span>]<\/span><\/span>\n<\/span>\n# Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
O(n)<\/strong>: algoritmos de tempo linear, como percorrer um array ou lista:<\/p>\n\n\n\n
C#<\/span><\/path><\/path><\/svg><\/span>
void<\/span> <\/span>PrintList<\/span>(<\/span>int<\/span>[]<\/span> array<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>foreach<\/span> <\/span>(<\/span>int<\/span> item <\/span>in<\/span> <\/span>array<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>item<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Java<\/span><\/path><\/path><\/svg><\/span>
void<\/span> <\/span>printList<\/span>(<\/span>int<\/span>[]<\/span> array<\/span>)<\/span> <\/span>{<\/span><\/span>\n    <\/span>for<\/span> <\/span>(<\/span>int<\/span> <\/span>item<\/span> <\/span>:<\/span> array<\/span>)<\/span> <\/span>{<\/span><\/span>\n        <\/span>System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>item<\/span>)<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Python<\/span><\/path><\/path><\/svg><\/span>
def<\/span> <\/span>print_list<\/span>(<\/span>array<\/span>):<\/span><\/span>\n    <\/span>for<\/span> item <\/span>in<\/span> array<\/span>:<\/span><\/span>\n        <\/span>print<\/span>(<\/span>item<\/span>)<\/span><\/span>\n<\/span>\n# Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
O(n log n)<\/strong>: algoritmos de tempo quase-linear, como mergesort e quicksort:<\/p>\n\n\n\n
C#<\/span><\/path><\/path><\/svg><\/span>
public<\/span> <\/span>static<\/span> <\/span>int<\/span>[]<\/span> <\/span>MergeSort<\/span>(<\/span>int<\/span>[]<\/span> array<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>if<\/span> <\/span>(<\/span>array<\/span>.<\/span>Length<\/span> <\/span><=<\/span> <\/span>1<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>return<\/span> <\/span>array<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>int<\/span> mid <\/span>=<\/span> <\/span>array<\/span>.<\/span>Length<\/span> <\/span>\/<\/span> <\/span>2<\/span>;<\/span><\/span>\n    <\/span>int<\/span>[]<\/span> left <\/span>=<\/span> <\/span>array<\/span>.<\/span>Take<\/span>(<\/span>mid<\/span>).<\/span>ToArray<\/span>()<\/span>;<\/span><\/span>\n    <\/span>int<\/span>[]<\/span> right <\/span>=<\/span> <\/span>array<\/span>.<\/span>Skip<\/span>(<\/span>mid<\/span>).<\/span>ToArray<\/span>()<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> <\/span>Merge<\/span>(<\/span>MergeSort<\/span>(<\/span>left<\/span>),<\/span> <\/span>MergeSort<\/span>(<\/span>right<\/span>))<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\npublic<\/span> <\/span>static<\/span> <\/span>int<\/span>[]<\/span> <\/span>Merge<\/span>(<\/span>int<\/span>[]<\/span> left<\/span>,<\/span> <\/span>int<\/span>[]<\/span> right<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>int<\/span>[]<\/span> result <\/span>=<\/span> <\/span>new<\/span> <\/span>int<\/span>[<\/span>left<\/span>.<\/span>Length<\/span> <\/span>+<\/span> <\/span>right<\/span>.<\/span>Length<\/span>]<\/span>;<\/span><\/span>\n    <\/span>int<\/span> i <\/span>=<\/span> <\/span>0<\/span>,<\/span> j <\/span>=<\/span> <\/span>0<\/span>,<\/span> k <\/span>=<\/span> <\/span>0<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>while<\/span> <\/span>(<\/span>i<\/span> <\/span><<\/span> <\/span>left<\/span>.<\/span>Length<\/span> <\/span>&&<\/span> <\/span>j<\/span> <\/span><<\/span> <\/span>right<\/span>.<\/span>Length<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>if<\/span> <\/span>(<\/span>left<\/span>[<\/span>i<\/span>]<\/span> <\/span><=<\/span> <\/span>right<\/span>[<\/span>j<\/span>])<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>result<\/span>[<\/span>k<\/span>++<\/span>]<\/span> <\/span>=<\/span> <\/span>left<\/span>[<\/span>i<\/span>++<\/span>]<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>else<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>result<\/span>[<\/span>k<\/span>++<\/span>]<\/span> <\/span>=<\/span> <\/span>right<\/span>[<\/span>j<\/span>++<\/span>]<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>while<\/span> <\/span>(<\/span>i<\/span> <\/span><<\/span> <\/span>left<\/span>.<\/span>Length<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>result<\/span>[<\/span>k<\/span>++<\/span>]<\/span> <\/span>=<\/span> <\/span>left<\/span>[<\/span>i<\/span>++<\/span>]<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>while<\/span> <\/span>(<\/span>j<\/span> <\/span><<\/span> <\/span>right<\/span>.<\/span>Length<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>result<\/span>[<\/span>k<\/span>++<\/span>]<\/span> <\/span>=<\/span> <\/span>right<\/span>[<\/span>j<\/span>++<\/span>]<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> <\/span>result<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Java<\/span><\/path><\/path><\/svg><\/span>
public<\/span> <\/span>static<\/span> <\/span>int<\/span>[]<\/span> <\/span>mergeSort<\/span>(<\/span>int<\/span>[]<\/span> array<\/span>)<\/span> <\/span>{<\/span><\/span>\n    <\/span>if<\/span> <\/span>(<\/span>array<\/span>.<\/span>length<\/span> <\/span><=<\/span> <\/span>1<\/span>)<\/span> <\/span>{<\/span><\/span>\n        <\/span>return<\/span> array<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n    <\/span><\/span>\n    <\/span>int<\/span> <\/span>mid<\/span> <\/span>=<\/span> <\/span>array<\/span>.<\/span>length<\/span> <\/span>\/<\/span> <\/span>2<\/span>;<\/span><\/span>\n    <\/span>int<\/span>[]<\/span> <\/span>left<\/span> <\/span>=<\/span> <\/span>mergeSort<\/span>(<\/span>Arrays<\/span>.<\/span>copyOfRange<\/span>(<\/span>array<\/span>,<\/span> <\/span>0<\/span>,<\/span> mid<\/span>))<\/span>;<\/span><\/span>\n    <\/span>int<\/span>[]<\/span> <\/span>right<\/span> <\/span>=<\/span> <\/span>mergeSort<\/span>(<\/span>Arrays<\/span>.<\/span>copyOfRange<\/span>(<\/span>array<\/span>,<\/span> mid<\/span>,<\/span> <\/span>array<\/span>.<\/span>length<\/span>))<\/span>;<\/span><\/span>\n    <\/span><\/span>\n    <\/span>return<\/span> <\/span>merge<\/span>(<\/span>left<\/span>,<\/span> right<\/span>)<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\npublic<\/span> <\/span>static<\/span> <\/span>int<\/span>[]<\/span> <\/span>merge<\/span>(<\/span>int<\/span>[]<\/span> left<\/span>,<\/span> <\/span>int<\/span>[]<\/span> right<\/span>)<\/span> <\/span>{<\/span><\/span>\n    <\/span>int<\/span>[]<\/span> <\/span>result<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>int<\/span>[<\/span>left<\/span>.<\/span>length<\/span> <\/span>+<\/span> <\/span>right<\/span>.<\/span>length<\/span>]<\/span>;<\/span><\/span>\n    <\/span>int<\/span> <\/span>i<\/span> <\/span>=<\/span> <\/span>0<\/span>,<\/span> j <\/span>=<\/span> <\/span>0<\/span>,<\/span> k <\/span>=<\/span> <\/span>0<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>while<\/span> <\/span>(<\/span>i <\/span><<\/span> <\/span>left<\/span>.<\/span>length<\/span> <\/span>&&<\/span> j <\/span><<\/span> <\/span>right<\/span>.<\/span>length<\/span>)<\/span> <\/span>{<\/span><\/span>\n        <\/span>if<\/span> <\/span>(<\/span>left<\/span>[<\/span>i<\/span>]<\/span> <\/span><=<\/span> right<\/span>[<\/span>j<\/span>])<\/span> <\/span>{<\/span><\/span>\n            result<\/span>[<\/span>k<\/span>++<\/span>]<\/span> <\/span>=<\/span> left<\/span>[<\/span>i<\/span>++<\/span>]<\/span>;<\/span><\/span>\n        <\/span>}<\/span> <\/span>else<\/span> <\/span>{<\/span><\/span>\n            result<\/span>[<\/span>k<\/span>++<\/span>]<\/span> <\/span>=<\/span> right<\/span>[<\/span>j<\/span>++<\/span>]<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>while<\/span> <\/span>(<\/span>i <\/span><<\/span> <\/span>left<\/span>.<\/span>length<\/span>)<\/span> <\/span>{<\/span><\/span>\n        result<\/span>[<\/span>k<\/span>++<\/span>]<\/span> <\/span>=<\/span> left<\/span>[<\/span>i<\/span>++<\/span>]<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>while<\/span> <\/span>(<\/span>j <\/span><<\/span> <\/span>right<\/span>.<\/span>length<\/span>)<\/span> <\/span>{<\/span><\/span>\n        result<\/span>[<\/span>k<\/span>++<\/span>]<\/span> <\/span>=<\/span> right<\/span>[<\/span>j<\/span>++<\/span>]<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> result<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Python<\/span><\/path><\/path><\/svg><\/span>
def<\/span> <\/span>merge_sort<\/span>(<\/span>array<\/span>):<\/span><\/span>\n    <\/span>if<\/span> <\/span>len<\/span>(<\/span>array<\/span>)<\/span> <\/span><=<\/span> <\/span>1<\/span>:<\/span><\/span>\n        <\/span>return<\/span> array<\/span><\/span>\n    <\/span><\/span>\n    mid <\/span>=<\/span> <\/span>len<\/span>(<\/span>array<\/span>)<\/span> <\/span>\/\/<\/span> <\/span>2<\/span><\/span>\n    left <\/span>=<\/span> <\/span>merge_sort<\/span>(<\/span>array<\/span>[:<\/span>mid<\/span>])<\/span><\/span>\n    right <\/span>=<\/span> <\/span>merge_sort<\/span>(<\/span>array<\/span>[<\/span>mid<\/span>:])<\/span><\/span>\n    <\/span><\/span>\n    <\/span>return<\/span> <\/span>merge<\/span>(<\/span>left<\/span>,<\/span> right<\/span>)<\/span><\/span>\n<\/span>\n# Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
O(n\u00b2)<\/strong>: algoritmos de tempo quadr\u00e1tico, como bubble sort e selection sort:<\/p>\n\n\n\n
C#<\/span><\/path><\/path><\/svg><\/span>
public<\/span> <\/span>static<\/span> <\/span>int<\/span>[]<\/span> <\/span>BubbleSort<\/span>(<\/span>int<\/span>[]<\/span> array<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>int<\/span> n <\/span>=<\/span> <\/span>array<\/span>.<\/span>Length<\/span>;<\/span><\/span>\n    <\/span>for<\/span> <\/span>(<\/span>int<\/span> i <\/span>=<\/span> <\/span>0<\/span>;<\/span> <\/span>i<\/span> <\/span><<\/span> <\/span>n<\/span>;<\/span> <\/span>i<\/span>++<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>for<\/span> <\/span>(<\/span>int<\/span> j <\/span>=<\/span> <\/span>0<\/span>;<\/span> <\/span>j<\/span> <\/span><<\/span> <\/span>n<\/span> <\/span>-<\/span> <\/span>i<\/span> <\/span>-<\/span> <\/span>1<\/span>;<\/span> <\/span>j<\/span>++<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>if<\/span> <\/span>(<\/span>array<\/span>[<\/span>j<\/span>]<\/span> <\/span>><\/span> <\/span>array<\/span>[<\/span>j<\/span> <\/span>+<\/span> <\/span>1<\/span>])<\/span><\/span>\n            <\/span>{<\/span><\/span>\n                <\/span>int<\/span> temp <\/span>=<\/span> <\/span>array<\/span>[<\/span>j<\/span>]<\/span>;<\/span><\/span>\n                <\/span>array<\/span>[<\/span>j<\/span>]<\/span> <\/span>=<\/span> <\/span>array<\/span>[<\/span>j<\/span> <\/span>+<\/span> <\/span>1<\/span>]<\/span>;<\/span><\/span>\n                <\/span>array<\/span>[<\/span>j<\/span> <\/span>+<\/span> <\/span>1<\/span>]<\/span> <\/span>=<\/span> <\/span>temp<\/span>;<\/span><\/span>\n            <\/span>}<\/span><\/span>\n        <\/span>}<\/span><\/span>\n    <\/span>}<\/span><\/span>\n    <\/span>return<\/span> <\/span>array<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Java<\/span><\/path><\/path><\/svg><\/span>
public<\/span> <\/span>static<\/span> <\/span>int<\/span>[]<\/span> <\/span>bubbleSort<\/span>(<\/span>int<\/span>[]<\/span> array<\/span>)<\/span> <\/span>{<\/span><\/span>\n    <\/span>int<\/span> <\/span>n<\/span> <\/span>=<\/span> <\/span>array<\/span>.<\/span>length<\/span>;<\/span><\/span>\n    <\/span>for<\/span> <\/span>(<\/span>int<\/span> <\/span>i<\/span> <\/span>=<\/span> <\/span>0<\/span>;<\/span> i <\/span><<\/span> n<\/span>;<\/span> i<\/span>++<\/span>)<\/span> <\/span>{<\/span><\/span>\n        <\/span>for<\/span> <\/span>(<\/span>int<\/span> <\/span>j<\/span> <\/span>=<\/span> <\/span>0<\/span>;<\/span> j <\/span><<\/span> n <\/span>-<\/span> i <\/span>-<\/span> <\/span>1<\/span>;<\/span> j<\/span>++<\/span>)<\/span> <\/span>{<\/span><\/span>\n            <\/span>if<\/span> <\/span>(<\/span>array<\/span>[<\/span>j<\/span>]<\/span> <\/span>><\/span> array<\/span>[<\/span>j <\/span>+<\/span> <\/span>1<\/span>])<\/span> <\/span>{<\/span><\/span>\n                <\/span>int<\/span> <\/span>temp<\/span> <\/span>=<\/span> array<\/span>[<\/span>j<\/span>]<\/span>;<\/span><\/span>\n                array<\/span>[<\/span>j<\/span>]<\/span> <\/span>=<\/span> array<\/span>[<\/span>j <\/span>+<\/span> <\/span>1<\/span>]<\/span>;<\/span><\/span>\n                array<\/span>[<\/span>j <\/span>+<\/span> <\/span>1<\/span>]<\/span> <\/span>=<\/span> temp<\/span>;<\/span><\/span>\n            <\/span>}<\/span><\/span>\n        <\/span>}<\/span><\/span>\n    <\/span>}<\/span><\/span>\n    <\/span>return<\/span> array<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Python<\/span><\/path><\/path><\/svg><\/span>
def<\/span> <\/span>bubble_sort<\/span>(<\/span>array<\/span>):<\/span><\/span>\n    n <\/span>=<\/span> <\/span>len<\/span>(<\/span>array<\/span>)<\/span><\/span>\n    <\/span>for<\/span> i <\/span>in<\/span> <\/span>range<\/span>(<\/span>n<\/span>):<\/span><\/span>\n        <\/span>for<\/span> j <\/span>in<\/span> <\/span>range<\/span>(<\/span>0<\/span>,<\/span> n<\/span>-<\/span>i<\/span>-<\/span>1<\/span>):<\/span><\/span>\n            <\/span>if<\/span> array<\/span>[<\/span>j<\/span>]<\/span> <\/span>><\/span> array<\/span>[<\/span>j<\/span>+<\/span>1<\/span>]:<\/span><\/span>\n                array<\/span>[<\/span>j<\/span>],<\/span> array<\/span>[<\/span>j<\/span>+<\/span>1<\/span>]<\/span> <\/span>=<\/span> array<\/span>[<\/span>j<\/span>+<\/span>1<\/span>],<\/span> array<\/span>[<\/span>j<\/span>]<\/span><\/span>\n    <\/span>return<\/span> array<\/span><\/span>\n<\/span>\n# Fonte: Chat GPT<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Escolhendo o melhor algoritmo<\/h2>\n\n\n\n
Como voc\u00ea pode ver, o Big-O \u00e9 um conceito poderoso que nos permite comparar e escolher algoritmos com base em sua efici\u00eancia. Ao escolher um algoritmo, \u00e9 importante considerar o tamanho da entrada e como ele afetar\u00e1 o tempo de execu\u00e7\u00e3o.<\/p>\n\n\n\n
Por exemplo, se voc\u00ea tiver um grande conjunto de dados para classificar, seria mais eficiente usar o mergesort (O(n log n)) do que o bubble sort (O(n\u00b2)). No entanto, se o conjunto de dados for pequeno, a diferen\u00e7a de tempo de execu\u00e7\u00e3o entre os algoritmos pode ser insignificante.<\/p>\n\n\n\n
Esse conte\u00fado \u00e9 parte do material disponibilizado para os participantes do meu grupo de estudos de Algoritmos e Estruturas de Dados<\/a><\/strong>. Se voc\u00ea se interessou pelo tema, conhe\u00e7a tamb\u00e9m o meu curso de Introdu\u00e7\u00e3o \u00e0 An\u00e1lise de Algoritmos e Big-O<\/a><\/strong>.<\/p>\n","protected":false},"featured_media":4126,"parent":0,"template":"","cursos":[5],"class_list":["post-4125","artigos","type-artigos","status-publish","has-post-thumbnail","hentry","cursos-algortimos"],"acf":[],"_links":{"self":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/artigos\/4125","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/artigos"}],"about":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/types\/artigos"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/media\/4126"}],"wp:attachment":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/media?parent=4125"}],"wp:term":[{"taxonomy":"cursos","embeddable":true,"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/cursos?post=4125"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}