Nível de abstração

Autor: Zen e a arte da programação de computadores

1. Introdução

Os níveis de abstração são um importante tópico de pesquisa em ciência da computação. Divide as diversas funções e comportamentos do sistema informático de acordo com diferentes níveis, tais como a sua estrutura organizacional, elementos estruturais e módulos funcionais. Por meio de um design de nível de abstração razoável, podemos compreender melhor o princípio de funcionamento do sistema, melhorar a eficiência do desenvolvimento de software, reduzir a dificuldade de manutenção e aumentar a portabilidade e adaptabilidade do software. Existem também algumas diferenças entre os diferentes níveis de abstração. Por exemplo, as linguagens de programação funcionais têm um nível de abstração mais alto do que as linguagens de programação imperativas. A divisão dos níveis de abstração também afetará o desempenho e o consumo de recursos do software, reduzirá a complexidade do sistema e melhorará a velocidade de execução. Este artigo discutirá a definição, classificação e aplicação de níveis de abstração de software sob a perspectiva da engenharia de software.

2. Explicação de conceitos e termos básicos

2.1 Abstração

A essência da abstração é “ocultar informações”, ou seja, ocultar as partes inobserváveis de coisas ou fenômenos reais, deixando apenas os elementos, características, atributos, processos ou mudanças que precisam ser utilizados. No processo de abstração, os modelos ou fenômenos do mundo real são classificados e descritos de acordo com determinados padrões para apreender suas principais características, comportamentos e características, estabelecendo assim uma compreensão simplificada do modelo ou sistema do mundo real.

2.2 Nível de abstração

Os níveis de abstração na ciência da computação sempre foram um tema digno de exploração e pesquisa. De modo geral, existem cinco tipos de níveis de abstração:

Nível da Máquina: O nível de abstração de um sistema de hardware de computador.
Nível do sistema operacional: O nível de abstração dos serviços fornecidos pelo sistema operacional, como gerenciamento de arquivos, agendamento de processos, memória virtual, etc.
Nível do Programa: O nível abstrato da estrutura lógica de um sistema de software, como classes, métodos, módulos, etc.
Nível de estrutura de dados: O nível de abstração de estruturas de dados e algoritmos, como listas vinculadas, pilhas, filas, árvores, etc.
Nível de Domínio: O nível de abstração de um campo específico, como pedidos, estoque, pagamento, logística, etc.

2.3 Objetivos abstratos

O objetivo da abstração é simplificar a análise de problemas, o design e a implementação de soluções. Os objetivos abstratos incluem os seguintes aspectos:

Melhorar a eficiência do desenvolvimento: A abstração pode reduzir a dificuldade dos desenvolvedores em compreender o mecanismo subjacente, melhorando assim a eficiência do desenvolvimento e economizando tempo e custos.
Melhorar a legibilidade do sistema: A abstração pode tornar a estrutura geral do software clara e fácil de ler e compreender, facilitando assim a manutenção posterior.
Reduzir a dificuldade de manutenção: A abstração pode reduzir a possibilidade de os desenvolvedores introduzirem erros ao modificar o código e reduzir a dificuldade de manutenção.
Melhorar a portabilidade e adaptabilidade do software: A abstração pode melhorar a portabilidade e adaptabilidade do software e reduzir a dependência de plataformas específicas.
Melhorar o desempenho do software: a abstração pode melhorar o desempenho do software e aumentar a velocidade de execução, otimizando hardware ou software.

3. Explicação dos princípios básicos do algoritmo, etapas operacionais específicas e fórmulas matemáticas

3.1 Algoritmo de árvore geradora mínima (MST)

Definição: Em um grafo não direcionado, em um subgrafo conectado com o número de nós não superior a $V$, o subgrafo que conecta quaisquer dois vértices e tem a menor soma de pesos é chamado de Árvore Geradora Mínima (MST).

3.1.1 Algoritmo de Kruskal

O algoritmo de Kruskal é um algoritmo ganancioso para encontrar o MST. Sua ideia principal é selecionar uma aresta com o menor peso de cada vez e adicioná-la ao MST até que todas as arestas sejam adicionadas. Na implementação, este algoritmo usa um método de fusão baseado em classificação para determinar se dois conjuntos pertencem ao mesmo bloco conectado.

Etapa 1: classifique todas as arestas por peso, de pequena a grande

edges = [(7, 1), (9, 2), (8, 3), (5, 4), (3, 5)] # example edges list
sorted_edges = sorted(edges, key=lambda x:x[0]) # sort by weight
print(sorted_edges)

Saída:[(3, 5), (5, 4), (7, 1), (8, 3), (9, 2)]

Etapa 2: adicione o MST começando pela primeira borda

Selecione um nó na árvore como nó pai (definido como 1).
Conecte 7 e 1 e selecione um deles como nó pai na árvore. Neste momento, 7 está selecionado porque já é o nó raiz.
Conecte 9 e 2 e selecione um deles como nó pai na árvore. Neste caso, 2 é selecionado porque está conectado a 1.
Conecte 8 e 3 e selecione um deles como nó pai na árvore. Neste caso, 3 é selecionado porque está conectado a 2.
Conecte 5 e 4 e selecione um deles como nó pai na árvore. Neste caso, 5 é selecionado porque está conectado a 3.
Neste momento, o número de arestas é 5 e o tamanho da árvore é 4, atendendo às condições. Retornar resultados.

Implementação de código em Python

def find(parent, i):
    if parent[i]!= -1:
        return find(parent, parent[i])
    else:
        return i

def union(parent, rank, x, y):
    xroot = find(parent, x)
    yroot = find(parent, y)

    if rank[xroot] < rank[yroot]:
        parent[xroot] = yroot
    elif rank[xroot] > rank[yroot]:
        parent[yroot] = xroot
    else :
        parent[yroot] = xroot
        rank[xroot] += 1

def mst_kruskal(n, e, edges):
    result = []

    # Sort the given edges with respect to their weights
    sorted_edges = sorted(edges, key=lambda x:x[2]) 

    # Initialize Disjoint Set and Rank Arrays 
    parent = [-1]*n
    rank = [0]*n  

    for u, v, w in sorted_edges:  
        x = find(parent, u-1) 
        y = find(parent, v-1) 

        # If including this edge does't cause cycle, include it in result and join two sets. Else, discard it.
        if x!= y:
            result.append([u,v,w])
            union(parent,rank,x,y)

    return result

# Example Usage
vertices = 6 # Number of vertices
edges = [[1, 2, 1], [1, 3, 4], [2, 3, 2], [1, 4, 3], [3, 5, 2], [4, 5, 1]] # Edges List
result = mst_kruskal(vertices, len(edges), edges)
for s, t, c in result:
    print("Edge", "({}, {})".format(s,t), "- Weight:",c)

Saída:

Edge (1, 3) - Weight: 4
Edge (2, 3) - Weight: 2
Edge (3, 5) - Weight: 2