每个程序员都应该知道的八大算法

在编程开发中，算法是用于解决特定问题或完成特定任务的一组指令或过程。算法可以用任何编程语言表示，可以像一系列基本操作一样简单，也可以像涉及不同数据结构和逻辑的多步骤过程一样复杂。

算法的主要目标是接收输入、处理它并提供预期的输出。算法可以根据时间和空间复杂性、用于解决问题的技术以及解决问题的类型进行分类。算法的例子有排序、搜索、图形遍历、字符串操作、数学运算等等。

这些算法广泛用于各种应用程序，程序员对它们有深刻的理解很重要，所以我会尽力解释它们。

我们将要讨论的8大算法如下：

1、排序算法：

1).Quicksort：Quicksort 是一种分而治之的算法，它从数组中选择一个“主元”元素，然后根据其他元素是小于还是大于主元将它们分成两个子数组。然后对子数组进行递归排序。

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

print(quicksort([3,6,8,10,1,2,1]))

2).归并排序：归并排序算法是一种分而治之的算法，它将一个数组一分为二，对两半进行排序，然后将它们归并在一起。

def merge_sort(arr):
     len(arr)  :
         arr
    mid  len(arr) 
    left  merge_sort(arr[:mid])
    right  merge_sort(arr[mid:])
     merge(left, right)

def merge(left, right):
    result  []
    i  
    j  
     i  len(left) and j  len(right):
         left[i]  right[j]:
            result.(left[i])
            i  
        :
            result.(right[j])
            j  
    result  left[i:]
    result  right[j:]
     result
print(merge_sort([,,,,,,]))

3).堆排序：堆排序算法是一种基于比较的排序算法，它将输入元素构建一个堆，然后从堆中反复提取最大元素，并将其放在排序后的输出数组的末尾。

def heap_sort(arr):
    n  len(arr)
     i  range(n, , ):
        heapify(arr, n, i)
     i  range(n, , ):
        arr[i], arr[]  arr[], arr[i]
        heapify(arr, i, )

def heapify(arr, n, i):
    largest  i
    l    i  
    r    i  
     l  n and arr[i]  arr[l]:
        largest  l
     r  n and arr[largest]  arr[r]:
        largest  r
     largest  i:
        arr[i], arr[largest]  arr[largest], arr[i]
        heapify(arr, n, largest)
print(heap_sort([,,,,,,]))

2.搜索算法：

1).二分搜索：二分搜索是一种从已排序的项目列表中查找项目的有效算法。它的工作原理是将要搜索的数组部分重复def binary_search(arr, x):
分成两半，直到找到目标值。

def binary_search(arr, x):
    low  
    high  len(arr)  
    mid  
     low  high:
        mid  (high  low) 
         arr[mid]  x:
            low  mid  
        elif arr[mid]  x:
            high  mid  
        :
             mid
     
print(binary_search([,,,,,,], ))

2).哈希表：哈希表是一种将键映射到值的数据结构，使用哈希函数计算到桶或槽数组的索引，从中可以找到所需的值。

 :
    def __init__(self):
        self.  
        self.  [None]  self.
        self.  [None]  self.

  def put(self, key, data):
        index  self.(key)
         self.[index] is not None:
             self.[index]  key:
                self.[index]  data  # update
                
            index  (index  )  self.
        self.[index]  key
        self.[index]  data

    def get(self, key):
        index  self.(key)
         self.[index] is not None:
             self.[index]  key:
                 self.[index]
            index  (index  )  self.
         None

    def hash_function(self, key):
        sum  
         pos  range(len(key)):
            sum  sum  ord(key[pos])
         sum  self.

t  HashTable()
t.(, )
t.(, )
t.(, )
print(t.())

3.图算法：

1).Dijkstra 最短路径算法：Dijkstra 最短路径算法是一种寻找图中节点之间最短路径的算法。

 

def dijkstra(graph, start):
    heap  [(, start)]
    visited  set()
     heap:
        (cost, v)  heapq.(heap)
         v not  visited:
            visited.(v)
             u, c  graph[v].():
                 u not  visited:
                    heapq.(heap, (cost  c, u))
     visited

graph  {
    : {: , : },
    : {: , : },
    : {: },
    : {: },
    : {: , : },
    : {: },
    : {},
    : {}
}
print(dijkstra(graph, ))

4.动态规划：

斐波那契数列：斐波那契数列是可以使用动态规划解决的问题的经典示例。

def fibonacci(n):
     n  :
         
    elif n  :
         
    :
         fibonacci(n)  fibonacci(n)


print(fibonacci())

5. 贪婪算法：

霍夫曼编码：霍夫曼编码是一种无损数据压缩算法，它使用贪婪算法为给定的一组符号构造前缀码。

from collections  , 

def huffman_encoding(data):
    
    Generates a Huffman encoded string of the input data
    
    # Create a frequency counter  the data
    freq_counter  Counter(data)
    # Create a namedtuple  the Huffman tree nodes
    HuffmanNode  namedtuple(, [, ])
    # Create a priority queue  the Huffman tree
    priority_queue  PriorityQueue()
    # Add all characters to the priority queue
     char, freq  freq_counter.():
        priority_queue.(HuffmanNode(char, freq))
    # Combine nodes until only the root node remains
     priority_queue.()  :
        left_node  priority_queue.()
        right_node  priority_queue.()
        combined_freq  left_node.  right_node.
        combined_node  HuffmanNode(None, combined_freq)
        priority_queue.(combined_node)
    # Generate the Huffman code  each character
    huffman_code  {}
    generate_code(priority_queue.(), , huffman_code)
    # Encode the input data
    encoded_data  
     char  data:
        encoded_data  huffman_code[char]
     encoded_data, huffman_code
print(huffman_encoding())

6.分治法：

归并排序：上面已经解释过了

7.回溯：

The N-Queens Problem：这是一个可以使用回溯法解决的经典问题。 目标是将 N 个问题放在 NxN 的棋盘上，使得任何皇后都不能攻击任何其他皇后。

def solveNQueens(n):
    def could_place(row, col):
        # check  a queen can be placed on board[row][col]
        # check   row is not under attack from any previous queen  that column
         i  range(row):
             board[i]  col or abs(board[i]  col)  abs(i  row):
                 False
         True

def backtrack(row, count):
         col  range(n):
             could_place(row, col):
                board[row]  col
                 row    n:
                    count  
                :
                    count  backtrack(row  , count)
         count
    board  [  x  range(n)]
     backtrack()
print(solveNQueens())

该算法开始将皇后放置在第一行，并且对于每个放置的皇后，它检查它是否受到任何先前皇后的攻击。

如果不是，它将继续到下一行并重复该过程。 如果将皇后置于受到攻击的位置，算法会回溯并尝试不同的位置。 这一直持续到所有皇后都被放置在棋盘上且没有任何相互攻击。

8. 随机算法：— 随机快速排序：随机选择主元的快速排序算法的一种变体。

 

def randomized_quicksort(arr):
     len(arr)  :
         arr
    pivot  random.(arr)
    left  [x  x  arr  x  pivot]
    middle  [x  x  arr  x  pivot]
    right  [x  x  arr  x  pivot]
     randomized_quicksort(left)  middle  randomized_quicksort(right)

print(randomized_quicksort([,,,,,,]))

这些是每个程序员都应该熟悉的一些最常用的算法。 了解这些算法与它的实现可以帮助程序员在设计和实现高效解决方案时做出更好的决策。