Цикл статей: Алгоритмы, изучение, примеры на C и Python, нюансы использования

#include <stdio.h>

int binary_search(int arr[], int size, int target) {
    int left = 0, right = size - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;

        if (arr[mid] == target)
            return mid;  // нашли!
        else if (arr[mid] < target)
            left = mid + 1;
        else
            right = mid - 1;
    }

    return -1;  // не найден
}

int main() {
    int numbers[] = {3, 8, 15, 23, 42, 55, 60};
    int index = binary_search(numbers, 7, 23);

    if (index >= 0)
        printf("Найдено на позиции %d\n", index);
    else
        printf("Элемент не найден\n");

    return 0;
}

 int mid = left + (right - left) / 2

mid = (left + right) // 2

def binary_search(arr, target):
    left, right = 0, len(arr) - 1

    while left <= right:
        mid = (left + right) // 2

        if arr[mid] == target:
            return mid  # найден
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1

    return -1  # не найден

nums = [3, 8, 15, 23, 42, 55, 60]
index = binary_search(nums, 23)

if index >= 0:
    print(f"Найдено на позиции {index}")
else:
    print("Элемент не найден")

// ⚠️ Ошибочный способ:
int mid = (left + right) / 2;

int mid = left + (right - left) / 2;

mid = (left + right) // 2  # безопасно

# ⚠️ Пример ошибки
while left < right:
    mid = (left + right) // 2
    if arr[mid] < target:
        left = mid  # ❌ не left + 1!
    else:
        right = mid

left = mid + 1  # если текущая середина точно меньше цели

 left, right = 0, len(arr)
# Поиск первого вхождения
while left < right:
    mid = (left + right) // 2
    if arr[mid] < target:
        left = mid + 1
    else:
        right = mid

// ❌ доступ к arr[mid + 1] без проверки
if (arr[mid + 1] == target) { ... }

if (mid + 1 < size && arr[mid + 1] == target)

# ⚠️ Нестабильный вариант
while left <= right:
    ...

while left < right:
    ...

arr = [3, 8, 13, 21]
x = arr[2]  # O(1)

int arr[] = {3, 8, 13, 21};
int x = arr[2];  // O(1)

# O(log n)
def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

максимальное количество шагов=log₂(n)+1

# O(n)
def contains(arr, target):
    for x in arr:
        if x == target:
            return True
    return False

void bubble_sort(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

void bubble_sort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

def bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        for j in range(n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

void insertion_sort(int arr[], int size) {
    for (int i = 1; i < size; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

def merge_sort(arr):
    # База рекурсии
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])

    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0

    # Сливаем два отсортированных массива
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    # Добавляем оставшиеся элементы
    result.extend(left[i:])
    result.extend(right[j:])
    return result

void merge(int arr[], int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    // Временные массивы
    int L[n1], R[n2];

    for (int i = 0; i < n1; i++) L[i] = arr[left + i];
    for (int j = 0; j < n2; j++) R[j] = arr[mid + 1 + j];

    int i = 0, j = 0, k = left;

    // Сливаем L[] и R[] обратно в arr[]
    while (i < n1 && j < n2) {
        if (L[i] <= R[j])
            arr[k++] = L[i++];
        else
            arr[k++] = R[j++];
    }

    // Добавляем оставшиеся элементы
    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = R[j++];
}

void merge_sort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;

        merge_sort(arr, left, mid);
        merge_sort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

int main() {
int arr[] = {42, 15, 3, 23, 8, 5};
int n = sizeof(arr) / sizeof(arr[0]);

merge_sort(arr, 0, n - 1);

printf("Отсортированный массив: ");
for (int i = 0; i < n; i++) {
    printf("%d ", arr[i]);
}
printf("\n");

return 0;

}

#include <stdio.h>

/* ――― вспомогательная функция слияния двух отсортированных отрезков ――― */
void merge(int a[], int left_start, int left_end,
           int right_start, int right_end)
{
    int n_left  = left_end  - left_start + 1;
    int n_right = right_end - right_start + 1;

    /* временные массивы для копирования левой и правой частей */
    int L[n_left], R[n_right];

    for (int i = 0; i < n_left;  ++i) L[i] = a[left_start  + i];
    for (int j = 0; j < n_right; ++j) R[j] = a[right_start + j];

    /* сливаем обратно в a[left_start … right_end] */
    int i = 0, j = 0, k = left_start;

    while (i < n_left && j < n_right) {
        if (L[i] <= R[j])
            a[k++] = L[i++];
        else
            a[k++] = R[j++];
    }

    /* дописываем «хвосты», если остались */
    while (i < n_left)  a[k++] = L[i++];
    while (j < n_right) a[k++] = R[j++];
}

/* ――― итеративная (без рекурсии) сортировка слиянием ――― */
void merge_sort(int a[], int n)
{
    /* длина сливаемых блоков: 1, 2, 4, 8, … */
    for (int block = 1; block < n; block *= 2) {

        /* перебираем пары блоков по всему массиву */
        for (int left_start = 0; left_start < n; left_start += 2 * block) {

            int left_end    = left_start + block - 1;
            int right_start = left_end + 1;
            int right_end   = right_start + block - 1;

            /* корректируем правую границу, чтобы не выйти за массив */
            if (right_start >= n)           continue;   /* второй блока нет */
            if (right_end   >= n) right_end = n - 1;

            /* объединяем два соседних блока */
            merge(a,
                  left_start,  left_end,
                  right_start, right_end);
        }
    }
}

/* ――― демонстрация ――― */
int main(void)
{
    int data[] = {42, 15, 3, 23, 8, 5};
    int n = sizeof data / sizeof data[0];

    printf("До  : ");
    for (int i = 0; i < n; ++i) printf("%d ", data[i]);
    puts("");

    merge_sort(data, n);

    printf("После: ");
    for (int i = 0; i < n; ++i) printf("%d ", data[i]);
    puts("");

    return 0;
}

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

void quick_sort(int arr[], int left, int right) {
    if (left >= right) return;

    int pivot = arr[(left + right) / 2];
    int i = left, j = right;

    while (i <= j) {
        while (arr[i] < pivot) i++;
        while (arr[j] > pivot) j--;

        if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++; j--;
        }
    }

    quick_sort(arr, left, j);
    quick_sort(arr, i, right);
}

#include <stdio.h>

/* свап без temp-макросов для простоты */
static inline void swap(int *a, int *b)
{
    int t = *a; *a = *b; *b = t;
}

/* итеративный quick sort */
void quick_sort_iter(int a[], int n)
{
    /* стек хранит пары [left, right] */
    int stack[n];
    int top = -1;

    /* помещаем первый диапазон (весь массив) */
    stack[++top] = 0;
    stack[++top] = n - 1;

    while (top >= 0)
    {
        /* извлекаем правую и левую границу */
        int right = stack[top--];
        int left  = stack[top--];

        if (left >= right) continue;

        /* стандартное разбиение */
        int pivot = a[(left + right) / 2];
        int i = left, j = right;

        while (i <= j)
        {
            while (a[i] < pivot) i++;
            while (a[j] > pivot) j--;

            if (i <= j)
            {
                swap(&a[i], &a[j]);
                i++;  j--;
            }
        }

        /* класть в стек сначала большую половину — экономнее по памяти */
        if (i < right) {          /* правая часть */
            stack[++top] = i;
            stack[++top] = right;
        }
        if (left < j) {           /* левая часть */
            stack[++top] = left;
            stack[++top] = j;
        }
    }
}

/* демонстрация */
int main(void)
{
    int data[] = {42, 15, 7, 23, 3, 9, 31};
    int n = sizeof data / sizeof data[0];

    printf("До   : ");
    for (int k = 0; k < n; ++k) printf("%d ", data[k]);
    puts("");

    quick_sort_iter(data, n);

    printf("После: ");
    for (int k = 0; k < n; ++k) printf("%d ", data[k]);
    puts("");
    return 0;
}

| Алгоритм           | Когда использовать                          |

|------------------  |----------------------------------------------|

| Insertion Sort     | маленькие массивы, почти отсортированные     |

| Merge Sort         | нужен гарантированный результат и стабильность |

| Quick Sort         | максимальная скорость при средних данных     |

stack = []
stack.append(10)
stack.append(20)
print(stack.pop())  # 20
print(stack[-1])    # 10 (top)

#define MAX 100
int stack[MAX], top = -1;

void push(int x) { if (top < MAX - 1) stack[++top] = x; }
int pop()        { return (top >= 0) ? stack[top--] : -1; }
int peek()       { return (top >= 0) ? stack[top] : -1; }

from collections import deque

q = deque()
q.append(1)       # enqueue
q.append(2)
print(q.popleft())  # 1
print(q[0])         # 2 (front)

#define MAX 100
int queue[MAX], front = 0, rear = 0;

void enqueue(int x) {
    if (rear < MAX) queue[rear++] = x;
}

int dequeue() {
    return (front < rear) ? queue[front++] : -1;
}

      10
      /  \
     5    15
    / \     \
   2   7     20

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def insert(head, value):
    new_node = Node(value)
    new_node.next = head
    return new_node  # новый head

def find(head, value):
    while head:
        if head.val == value:
            return True
        head = head.next
    return False

def delete(head, value):
    dummy = Node(0)
    dummy.next = head
    prev, curr = dummy, head
    while curr:
        if curr.val == value:
            prev.next = curr.next
            break
        prev, curr = curr, curr.next
    return dummy.next

typedef struct Node {
    int val;
    struct Node* next;
} Node;

Node* insert(Node* head, int value) {
    Node* n = malloc(sizeof(Node));
    n->val = value;
    n->next = head;
    return n;
}

int find(Node* head, int value) {
    while (head) {
        if (head->val == value) return 1;
        head = head->next;
    }
    return 0;
}

Node* delete(Node* head, int value) {
    Node dummy = {.next = head};
    Node* prev = &dummy;
    Node* curr = head;
    while (curr) {
        if (curr->val == value) {
            prev->next = curr->next;
            free(curr);
            break;
        }
        prev = curr;
        curr = curr->next;
    }
    return dummy.next;
}

class Node:
    def __init__(self, key):
        self.key = key
        self.left = self.right = None

def insert(root, key):
    if not root:
        return Node(key)
    if key < root.key:
        root.left = insert(root.left, key)
    else:
        root.right = insert(root.right, key)
    return root

def search(root, key):
    if not root or root.key == key:
        return root
    return search(root.left, key) if key < root.key else search(root.right, key)

def delete(root, key):
    if not root:
        return None
    if key < root.key:
        root.left = delete(root.left, key)
    elif key > root.key:
        root.right = delete(root.right, key)
    else:
        if not root.left:
            return root.right
        if not root.right:
            return root.left
        temp = root.right
        while temp.left:
            temp = temp.left
        root.key = temp.key
        root.right = delete(root.right, temp.key)
    return root

typedef struct Node {
    int key;
    struct Node *left, *right;
} Node;

Node* new_node(int key) {
    Node* node = malloc(sizeof(Node));
    node->key = key;
    node->left = node->right = NULL;
    return node;
}

Node* insert(Node* root, int key) {
    if (!root) return new_node(key);
    if (key < root->key)
        root->left = insert(root->left, key);
    else
        root->right = insert(root->right, key);
    return root;
}

Node* search(Node* root, int key) {
    if (!root || root->key == key) return root;
    return (key < root->key) ? search(root->left, key) : search(root->right, key);
}

Node* min_value_node(Node* node) {
    while (node->left) node = node->left;
    return node;
}

Node* delete(Node* root, int key) {
    if (!root) return NULL;
    if (key < root->key)
        root->left = delete(root->left, key);
    else if (key > root->key)
        root->right = delete(root->right, key);
    else {
        if (!root->left) {
            Node* temp = root->right;
            free(root); return temp;
        } else if (!root->right) {
            Node* temp = root->left;
            free(root); return temp;
        }
        Node* temp = min_value_node(root->right);
        root->key = temp->key;
        root->right = delete(root->right, temp->key);
    }
    return root;
}

graph = {}

def add_vertex(v):
    if v not in graph:
        graph[v] = []

def add_edge(u, v):
    graph[u].append(v)

def remove_edge(u, v):
    if v in graph[u]:
        graph[u].remove(v)

def has_edge(u, v):
    return v in graph.get(u, [])

#define MAX 100
typedef struct Node {
    int vertex;
    struct Node* next;
} Node;

Node* adj[MAX];

void add_edge(int u, int v) {
    Node* n = malloc(sizeof(Node));
    n->vertex = v;
    n->next = adj[u];
    adj[u] = n;
}

int has_edge(int u, int v) {
    Node* cur = adj[u];
    while (cur) {
        if (cur->vertex == v) return 1;
        cur = cur->next;
    }
    return 0;
}

void remove_edge(int u, int v) {
    Node** cur = &adj[u];
    while (*cur) {
        if ((*cur)->vertex == v) {
            Node* tmp = *cur;
            *cur = (*cur)->next;
            free(tmp);
            return;
        }
        cur = &((*cur)->next);
    }
}

#include <stdio.h>
#include <stdlib.h>

#define N 4 // кол-во вершин: A, B, C, D

typedef struct Node {
    int vertex;
    struct Node* next;
} Node;

Node* graph[N]; // массив смежности

void add_edge(int from, int to) {
    Node* n = malloc(sizeof(Node));
    n->vertex = to;
    n->next = graph[from];
    graph[from] = n;
}

void print_graph() {
    char labels[] = {'A', 'B', 'C', 'D'};
    for (int i = 0; i < N; i++) {
        printf("%c -> ", labels[i]);
       Node* temp = graph[i];
       while (temp) {
           printf("%c ", labels[temp->vertex]);
           temp = temp->next;
      }
      printf("\n");
   }
}

int main() {
    add_edge(0, 1); // A → B
    add_edge(0, 2); // A → C
    add_edge(1, 3); // B → D
    add_edge(2, 3); // C → D

    print_graph();
    return 0;

}

import heapq

def dijkstra(graph, start):
    dist = {v: float('inf') for v in graph}
    dist[start] = 0
    queue = [(0, start)]

    while queue:
        cost, u = heapq.heappop(queue)
        if cost > dist[u]:
            continue
        for v, weight in graph[u]:
            alt = dist[u] + weight
            if alt < dist[v]:
                dist[v] = alt
                heapq.heappush(queue, (alt, v))

    return dist

graph = {
    'A': [('B', 1), ('C', 4)],
    'B': [('C', 2), ('D', 5)],
    'C': [('D', 1)],
    'D': []
}

#include <stdio.h>
#include <limits.h>

#define V 4  // количество вершин

int min_distance(int dist[], int visited[]) {
    int min = INT_MAX, index = -1;
    for (int i = 0; i < V; i++) {
        if (!visited[i] && dist[i] < min) {
            min = dist[i];
            index = i;
        }
    }
    return index;
}

void dijkstra(int graph[V][V], int start) {
    int dist[V];
    int visited[V] = {0};

    for (int i = 0; i < V; i++)
        dist[i] = INT_MAX;

    dist[start] = 0;

    for (int count = 0; count < V - 1; count++) {
        int u = min_distance(dist, visited);
        visited[u] = 1;

        for (int v = 0; v < V; v++) {
            if (!visited[v] && graph[u][v] && dist[u] != INT_MAX &&
                dist[u] + graph[u][v] < dist[v])
            {
                dist[v] = dist[u] + graph[u][v];
            }
        }
    }

    printf("Кратчайшие расстояния от вершины %d:\n", start);
    for (int i = 0; i < V; i++)
        printf("До %d = %d\n", i, dist[i]);
}

int main() {
    // Матрица смежности (веса)
    int graph[V][V] = {
        {0, 1, 4, 0},
        {0, 0, 2, 5},
        {0, 0, 0, 1},
        {0, 0, 0, 0}
    };

    dijkstra(graph, 0);  // из вершины 0
    return 0;
}

f(n) = g(n) + h(n)

import heapq

def a_star(graph, start, goal, heuristic):
    open_set = [(0, start)]
    g = {start: 0}
    came_from = {}

    while open_set:
        _, current = heapq.heappop(open_set)
        if current == goal:
            break

        for neighbor, cost in graph[current]:
            tentative_g = g[current] + cost
            if neighbor not in g or tentative_g < g[neighbor]:
                g[neighbor] = tentative_g
                f = tentative_g + heuristic(neighbor, goal)
                heapq.heappush(open_set, (f, neighbor))
                came_from[neighbor] = current

    return g.get(goal, float('inf'))

def manhattan(node, goal):
    x1, y1 = node
    x2, y2 = goal
    return abs(x1 - x2) + abs(y1 - y2)

res = a_star(graph, 'A', 'D', manhattan)
print("Минимальное расстояние A → D:", res)

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>

#define N 5

typedef struct {
    int x, y;
    int g;  // стоимость от старта
    int f;  // общая стоимость (g + h)
} Node;

int goal_x = 4, goal_y = 4;

int heuristic(int x, int y) {
    return abs(goal_x - x) + abs(goal_y - y);  // Манхэттен
}

int in_bounds(int x, int y) {
    return x >= 0 && x < N && y >= 0 && y < N;
}

int is_passable(int grid[N][N], int x, int y) {
    return grid[x][y] == 1;
}

// простая очередь с приоритетом (по f)
void push(Node* open[], int* size, Node* n) {
    int i = *size;
    while (i > 0 && open[i - 1]->f > n->f) {
        open[i] = open[i - 1];
        i--;
    }
    open[i] = n;
    (*size)++;
}

Node* pop(Node* open[], int* size) {
    return open[--(*size)];
}

void a_star(int grid[N][N], int start_x, int start_y) {
    int closed[N][N] = {0};
    int came_from[N][N][2];

    Node* open[100];
    int open_size = 0;

    Node* start = malloc(sizeof(Node));
    start->x = start_x;
    start->y = start_y;
    start->g = 0;
    start->f = heuristic(start_x, start_y);

    push(open, &open_size, start);

    int dirs[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};

    while (open_size > 0) {
        Node* current = pop(open, &open_size);

        if (current->x == goal_x && current->y == goal_y) {
            printf("Путь найден:\n");
            int x = goal_x, y = goal_y;
            while (!(x == start_x && y == start_y)) {
                printf("(%d, %d) <- ", x, y);
                int px = came_from[x][y][0];
                int py = came_from[x][y][1];
                x = px;
                y = py;
            }
            printf("(%d, %d)\n", start_x, start_y);
            return;
        }

        closed[current->x][current->y] = 1;

        for (int i = 0; i < 4; i++) {
            int nx = current->x + dirs[i][0];
            int ny = current->y + dirs[i][1];

            if (!in_bounds(nx, ny) || !is_passable(grid, nx, ny) || closed[nx][ny])
                continue;

            int new_g = current->g + 1;
            Node* neighbor = malloc(sizeof(Node));
            neighbor->x = nx;
            neighbor->y = ny;
            neighbor->g = new_g;
            neighbor->f = new_g + heuristic(nx, ny);

            came_from[nx][ny][0] = current->x;
            came_from[nx][ny][1] = current->y;

            push(open, &open_size, neighbor);
        }
    }

    printf("Путь не найден.\n");
}

int main() {
    int grid[N][N] = {
        {1, 1, 1, 1, 1},
        {0, 0, 0, 1, 0},
        {1, 1, 1, 1, 1},
        {1, 0, 0, 0, 1},
        {1, 1, 1, 1, 1}
    };

    a_star(grid, 0, 0);
    return 0;
}

intervals = [(1, 3), (2, 5), (4, 6), (7, 9)]
intervals.sort(key=lambda x: x[1])  # сортировка по правому краю

res = []
end = 0

for start, finish in intervals:
    if start >= end:
        res.append((start, finish))
        end = finish

print("Выбранные интервалы:", res)

Выбранные интервалы: [(1, 3), (4, 6), (7, 9)]

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int start, end;
} Interval;

int cmp(const void* a, const void* b) {
    return ((Interval*)a)->end - ((Interval*)b)->end;
}

int main() {
    Interval intervals[] = {{1,3},{2,5},{4,6},{7,9}};
    int n = sizeof(intervals)/sizeof(intervals[0]);
    qsort(intervals, n, sizeof(Interval), cmp);

    int end = 0;
    for (int i = 0; i < n; i++) {
        if (intervals[i].start >= end) {
            printf("(%d, %d)\n", intervals[i].start, intervals[i].end);
            end = intervals[i].end;
        }
    }
    return 0;
}

# Создание хеш-таблицы
table = {}

# Вставка
table["user42"] = "Alice"
table["user17"] = "Bob"

# Чтение
print(table["user42"])  # Alice

# Удаление
del table["user17"]

class HashTable:
    def __init__(self, size=10):
        self.size = size
        self.table = [[] for _ in range(size)]

    def _hash(self, key):
        return hash(key) % self.size

    def put(self, key, value):
        idx = self._hash(key)
        for i, (k, v) in enumerate(self.table[idx]):
            if k == key:
                self.table[idx][i] = (key, value)
                return
        self.table[idx].append((key, value))

    def get(self, key):
        idx = self._hash(key)
        for k, v in self.table[idx]:
            if k == key:
                return v
        return None

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE 10

typedef struct Item {
    char* key;
    char* value;
    struct Item* next;
} Item;

Item* table[SIZE];

int hash(const char* key) {
    int sum = 0;
    while (*key) sum += *key++;
    return sum % SIZE;
}

void put(const char* key, const char* value) {
    int idx = hash(key);
    Item* node = malloc(sizeof(Item));
    node->key = strdup(key);
    node->value = strdup(value);
    node->next = table[idx];
    table[idx] = node;
}

const char* get(const char* key) {
    int idx = hash(key);
    Item* node = table[idx];
    while (node) {
        if (strcmp(node->key, key) == 0)
            return node->value;
        node = node->next;
    }
    return NULL;
}

index = hash(key) % table_size

unsigned long hash(const char *str) {
    unsigned long h = 5381;
    int c;
    while ((c = *str++))
        h = ((h << 5) + h) + c; // h * 33 + c
    return h;
}