сиаод / Reformating_Saod

тратится на пересылки. Последовательность из 1-го элемента упорядочена. Список разбиваем на одноэлементные куски и сливаем их. (nlog2n)

MergeSort(list,first,last); If first<last then Middle:=(first+last)/2 Mergesort(list,first,middle)

Mergesort(list,middle+1,last)

Mergelists(list,first,middle,middle+1,last) MergeLists(list,start1,end1, start2,end2); Finalstart:=start1;

Finalend:=end2;

Indexc:=1;

While(start=<end1) and(start2=<end2) do If list[start1]<list[start2] then Result[indexc]:=list[start1] Start1:=start1+1;

Else result[indexc]:=list[start2] Start2:=start2+1; Indexc:=indexc+1

If (start1=<end1) then For i:=start1 to end1 do Result[indexc]:=list[i] Indexc:=indexc+1; Else

For i:=start2 to end2 do Result[indexc]:=list[i] Indexc:=indexc+1; Indexc:=1;

For i:=finalstart to finalend do List[i]:=tesult[indexc] Indexc:=indexc+1;

51.Машинное представление графов.

Будем рассматривать как ориентированные графы, так и неориентированные. Будем обозначать граф G V , E , где V - множество вершин, а E - множество ребер, причем

E V V – для ориентированного графа и E {{x, y}: x, y V x y} – для неориентированного графа.

Будем использовать также обозначения | V | = n, | E | = m (мощность множества). В теории графов классическим способом представления графа является матрица

инциденций. Это матрица А с n строками, соответствующими вершинам, и m столбцами, соответствующими ребрам. Для ориентированного графа столбец, соответствующий дуге (x, y) E, содержит +1 в строке, соответствующей вершине x, -1 в строке, соответствующей вершине y и нули во всех остальных строках.рисунок-пример!!!

Для неориентированного графа столбец, соответствующий ребру {x, y}, содержит 1 в строках, соответствующих x и y, и 0 - во всех остальных строках

С алгоритмической точки зрения матрица инциденций является одним из самых худших способов представления графа, так как:

1.требуется n x m ячеек памяти, причем большинство ячеек занято нулями;

неудобен доступ к информации, т.к. ответ на вопросы: существует ли дуга (x, y)? к каким вершинам ведут ребра из x? – требует в худшем случае перебора всех столбцов, т.е. m шагов. Немного лучше способ представления графа с помощью матрицы смежности

размера n x m, где bij = 1, если существует ребро, ведущее из x в y, и bij = 0 – противном

случае. При этом подразумевается, что ребро {x, y} неориентированного графа идет как от x к y, так и от y к x. Поэтому матрица смежности для неориентированного графа всегда симметрична. Пример-рисунок!!!

Основное преимущество матрицы смежности состоит в том, что за один шаг можно ответить на вопрос – существует ли ребро из x в y? Недостатком является тот факт, что независимо от числа ребер объем занимаемой памяти составляет n2 . Более экономным в отношении памяти (особенно для неплотных графов, когда m гораздо меньше n2 ) является способ представления графа с помощью списка пар, соответствующих его ребрам. Пара (x, y) соответствует дуге (x, y), если граф ориентированный, и ребру {x, y}, если граф неориентированный. Пример-рисунок!!! Очевидно, что в этом случае объем памяти составляет 2m. Неудобством является большое число шагов (порядка m в худшем случае) для нахождения множества вершин, к которым ведут ребра из данной вершины.

Лучшим решением во многих случаях является структура данных, которую назовем списками инцидентности. Она содержит для каждой вершины v V список вершин u таких, что v u для ориентированного графа и v u для неориентированного графа. Каждый элемент такого списка является записью r, состоящей из двух полей:

r.строка– вершина графа;

r.след– указатель на следующую запись в списке.

Для последней записи в списке – r.след = nil. Указатель на начало каждого списка хранится в таблице НАЧАЛО. Таким образом НАЧАЛО[v] – указатель на начало списка, содержащего вершины из множества {u: (v, u)} для ориентированного графа или

{u: {v, u}} для неориентированного графа, соответственно.

Число ячеек памяти, необходимых для представления графа с помощью списков инцидентности, имеет порядок (n + m).

if Mark[w] then dfs(w).

Можно убедиться в том, что этот алгоритм просмотрит каждую вершину ровно один раз и его сложность порядка О(n+m).

Основные требования к методам поиска в графе:

1)метод должен легко реализовываться алгоритмом решения интересующей нас задачи; 2)каждое ребро графа анализируется один раз (или ограниченное число раз, что существенно не меняет ситуации).

Преимущество поиска в глубину: в момент посещения вершины u стек содержит последовательность вершин, определяющую путь из v и u.

Недостаток: полученный таким образом путь в общем случае не будет кратчайшим.

52. Поиск в глубину в графе. Рекурсивный алгоритм.

Общая идея метода состоит в следующем. Начинаем поиск с некоторой фиксированной вершины v0. Затем выбираем произвольную вершину u, смежную с v0, и повторяем наш просмотр от u . В общем случае предположим, что мы находимся в некоторой вершине v. Если существует новая (ещё не просмотренная) вершина u, u-v, то мы рассматриваем эту вершину (она перестает быть новой), начиная с неё, продолжаем поиск. Если же не существует новой вершины, смежной с v, мы говорим, что вершина v использована, возвращаемся в вершину, из которой мы попали в v, и продолжаем поиск (если v=v0, то поиск закончен). Иначе говоря, поиск в глубину из вершины v основывается на поиске в глубину из всех новых вершин, смежных с v.

53. Поиск в ширину в графе. Не рекурсивный алгоритм.

Рассмотрим несколько иной метод поиска в графе, называемый поиском в ширину (breadth first search). Этот метод основан, грубо говоря, на замене стека очередью. В этом случае чем раньше посещается вершина (помещается в очередь), тем раньше она используется (удаляется из очереди). Использование вершины происходит с помощью просмотра сразу всех еще непросмотренных соседей этой вершины.

1.PROCEDURE WS(v);

{поиск в ширину в графе с началом в вершине v;

переменные НОВЫЙ, СПИСОК – глобальные}

2.BEGIN

3.ОЧЕРЕДЬ := ; ОЧЕРЕДЬ <= v; НОВЫЙ[v] := false;

4.WHILE ОЧЕРЕДЬ : DO begin

5.P <= ОЧЕРЕДЬ; посетить p;

6.FOR uСПИСОК[p] DO

7.IF НОВЫЙ[u] THEN BEGIN

8.ОЧЕРЕДЬ <= u; НОВЫЙ[u] := false

9.END

10.END

11.END

Как и для поиска в глубину, можно легко показать, что вызов процедуры WS(v) приводит к посещению всех вершин компоненты связности графа, содержащей вершину v, причем каждая вершина просматривается ровно один раз. Вычислительная сложность алгоритма также имеет порядок m+n, т.к. каждая вершина помещается в очередь и удаляется из очереди в точности один раз, а число итераций цикла 6, очевидно, будет иметь порядок числа ребер графа.

57. Эйлеровы пути и циклы. Алгоритм нахождения эйлерова цикла в графе.

Эйлеров путь в графе – произвольный путь, проходящий через каждое ребро графа ровно один раз, т.е. такой путь v1,..., vm 1 , что каждое ребро e E появляется один раз как {vi , vi 1} для некоторого i. Если граф имеет цикл, содержащий все ребра графа по одному разу, то такой цикл называется эйлеровым циклом. Необходимое и достаточное условие существования эйлерова пути: эйлеров путь в графе существует тогда и только тогда, когда граф связан и содержит не более чем две вершины нечетной степени. Если в графе нет вершин нечетной степени, то каждый эйлеров путь является эйлеровым циклом. Пусть G = <V, E> – связный граф, представленный списками СПИСОК[r], v V. Алгоритм нахождения эйлерова цикла в графе построим следующим образом. Используем два стека: СТЕК1 и СТЕК2.

Выбираем произвольную вершину графа v0 и строим последовательно путь из этой

вершины. Вершины этого пути помещаем в СТЕК1, а ребра удаляем из графа. Эти действия продолжаем до тех пор, пока оказывается, что путь удлинить, включив в него новую вершину, уже нельзя. Т.е. СПИСОК[v] = . Отметим, что тогда должно быть v v0 ,

иначе это бы означало, что вершина v – нечетной степени. Таким образом из нашего графа был удален цикл, а вершины этого цикла находятся в стеке СТЕК1. При этом в графе, модифицированном таким образом, степень произвольной вершины остается четной. Вершина v v0 переносится теперь из стека СТЕК1 в стек СТЕК2, а процесс повторяется,

начиная с вершины, верхней в СТЕК1 (если ее список не пустой). Теперь снова в СТЕК1 помещается некоторый цикл, проходящий через эту вершину, и т.д. Процесс продолжается до тех пор, пока СТЕК1 не станет пустым. Очевидно, что вершины, помещенные в СТЕК2, образуют некоторый путь, причем вершина v переносится в

СТЕК2 только тогда, когда СПИСОК[v] = , т.е. когда все ребра, инцидентные этой вершине, представлены в СТЕКе1 (парами соседних вершин). Отсюда следует, что по окончании алгоритма СТЕК2 содержит эйлеров цикл. общая Сложность алгоритма O(m). Алгоритм считается оптимальным.

58.Множествофундаменталных циклов графа. Алгоритм нахождения множества фундаментальных циклов.

Если к стягивающему дереву <V, T> графа G = <V, E> мы добавим произвольную хорду e E\T, то возникший при этом подграф C = <V, T {e}> содержит в точности один цикл (под циклом мы здесь будем понимать элементарный цикл). Обозначим этот цикл через Ce. Множество C = {Ce : e E \ T} называют фундаментальным множеством циклов графа G (относительно стягивающего дерева <V, T>). Алгоритм основан на поиске в глубину и имеет структуру, аналогичную рекурсивному алгоритму нахождения стягивающего дерева.

Каждая новая вершина, встречающаяся в процессе поиска, помещается в стек, представленный таблицей СТЕК, и удаляется из стека после использования. Очевидно, что стек всегда содержит последовательность вершин от рассматриваемой в данный момент вершины v к корню.

Поэтому, если анализируемое нами ребро {v, u} замыкает цикл (т.е. WGN[v] > WGN[u] > 0 b u не находится непосредственно под верхним элементом стека), то вершина u находится в стеке и цикл, замыкаемый ребром {v, u}, представлен группой элементов стека, начиная с v и кончая вершиной u.

1.PROCEDURE цикл(v);

{переменные d, num, СТЕК, СПИСОК, WGN - глобальные}

2.BEGIN d := d+1; СТЕК[d] := v; num := num+1; WGN[ ] := num;

3.FOR uСПИСОК[v] DO

4.IF WGN[u] = 0 THEN цикл(г)

5.ELSE IF (u СТЕК[d-1]) and (WGN[v] > WGN[u])

THEN {ребро {v, u} замыкает новый

цикл}

6. выписать цикл с вершинами

7. СТЕК[d], СТЕК[d-1], ..., СТЕК[c], где СТЕК[c] = u

8. d := d-1 {использованная вершина v удаляется из стека}

9.END (цикл};

Основная программа:

1.BEGIN

2. FOR v V DO WGN[r] := 0; num := 0; {инициализация}

3.d := 0; СТЕК[0] := 0; {d - число элементов в стеке}

4.FOR r V DO

5.IF WGN[r] = 0 THEN цикл(v)

6.END.

Отметим, что общее число шагов, не считая вычисления циклов, как и во всех алгоритмах, основанных на поиске в глубину, имеет порядок O(n+m). К этому следует добавить суммарную длину всех циклов. Эта длина не превосходит (m-n+1), что дает общую сложность алгоритма O(nm+n) (или O(nm), если отбросить вырожденный случай m=0).

Процедуры поиска в глубину и в ширину можно использовать для нахождения стягивающих деревьев. В обоих случаях достижение из вершины v новой вершины u вызывает включение в дерево ребра {v, u}. Вспомним, что деревом называется произвольный неориентированный связный граф без циклов. Для произвольного неориентированного графа G = <V, E> каждое дерево <V, T>, где T E, будем называть стягивающим деревом или каркасом графа G. Ребра такого графа (дерева) назовем ветвями, а остальные ребра графа G будем называть хордами. Отметим, что каждое дерево с n вершинами имеет n-1 ветвь. (В каждую вершину, кроме корня, входит только одно ребро). Процедуры поиска в глубину и в ширину можно использовать для нахождения стягивающих деревьев. В обоих случаях достижение из вершины v новой вершины u вызывает включение в дерево ребра {v, u}.

BEGIN

FOR u V DO НОВЫЙ[u] := true;

{инициализация}

T := ; {множество найденных к этому времени ветвей}

ОЧЕРЕДЬ := ; ОЧЕРЕДЬ <= r;

НОВЫЙ[r] := false; {r - корень стягивающего дерева}

WHILE ОЧЕРЕДЬ DO BEGIN v <= ОЧЕРЕДЬ;

FOR u СПИСОК[u] DO

IF НОВЫЙ[u] THEN BEGIN

ОЧЕРЕДЬ <= u; НОВЫЙ[u] := false; T :=

T {v, u} END

END END

Данный алгоритм корректно строит стягивающее дерево для произвольного связного графа за O(n+m) шагов, т.е. за число шагов не более, чем С(n+m).

Преимущества процедуры поиска в ширину, приводят к следующему выводу. Пусть <V, T> - стягивающее дерево произвольного связного графа G = <V, E>, построенное с

помощью алгоритма поиска в ширину. Тогда путь в <V, T> из произвольной вершины v к корню r является кратчайшим путем из v к r в графе G.

59.Алгоритм Варшалла.

Транзитивн замык. ориентир графа с n вершинами можно опр-ть как булеву матрицу, в которой Эл-т на пересечении i,j =1 если существует транзитивный путь и 0 если не сущет. Транзитивное замыкание можно построить с помощью поиска в ширину или глубину.

61. Стягивающие деревья. Нахождение стягивающего дерева методом поиска в глубину.

Стягивающие деревья-см вопр 60. Рассмотрим алгоритм нахождения стягивающего дерева связного графа методом поиска в глубину. Пусть исходный граф G = <V, E> задан списками инцидентности СПИСОК[v], v V. Алгоритм реализуем процедурой WGD(v):

1.PROCEDURE WGD(v);

{Перем. НОВЫЙ, СПИСОК, Т (множество ветвей) - глобальные}

2.BEGIN НОВЫЙ[v] := false; 3.FOR u СПИСОК[v] DO

4.IF НОВЫЙ[u] THEN BEGIN

5.T := T {v, u}; {добавить новую ветвь}

6.WGD(u)

7.END

8.END {WGD};

Основная программа

1.BEGIN

2.FOR u V DO НОВЫЙ[u] := true; {инициализация}

3.T := ;

4.WGD( r ) {r - произвольная вершина}

5.END

1)в момент добавления к множеству Т новой ветви {v, u} (строка 5 WGD) в дереве <V, T> существует путь из r в v. Таким образом алгоритм строит связанный граф;

2)каждая новая ветвь {v, u}, добавляемая к множеству Т, соединяет уже рассмотренную вершину v с новой вершиной u. Отсюда следует, что построенный граф <V, T> не имеет циклов. (Действительно, последняя ветвь, замыкающая цикл, должна была бы соединить две уже рассмотренных вершины);

3)из свойства поиска в глубину следует, что программа WGD просматривает все вершины связного графа.

Очевидно, что вычислительная сложность алгоритма будет порядка С(n+m).

62.Минимальные покрывающие деревья. Алгоритм Прима.

При разработке электронных схем зачастую необходимо электрически соединить контакты нескольких компонентов. Для соединения множества из n контактов мы можем использовать некоторую компоновку из n - 1 проводов, каждый из которых соединяет два контакта. Нужно получить компоновку, которая использует минимальное количество провода. Мы можем смоделировать эту задачу при помощи связного неориентированного графа G = (V, Е), где V - множество контактов, Е - множество возможных соединений между парами контактов, и для каждого ребра (u, v) входящие в Е задан вес w(u,v), определяющий стоимость (количество необходимого провода) соединения u и v. Мы хотим найти ациклическое подмножество Т входящее в Е, которое соединяет все вершины и чей общий вес минимален. Поскольку множество Т ациклическое и

связывает все вершины, оно должно образовывать дерево, которое мы назовем остовным деревом графа G ("покрывающее дерево"). Задачу поиска дерева Т мы назовем задачей поиска минимального остовного дерева. На ребрах указан их вес, а ребра минимального остовного дерева отдельно выделены цветом. Общий вес показанного дерева равен 37.

Прима:

Алгоритм Прима представляет собой частный случай обобщенного алгоритма поиска минимального остовного дерева из раздела 23.1. Алгоритм Прима очень похож на алгоритм Дейкстры для поиска

кратчайшего пути в графе, который будет рассмотрен нами в разделе 24.3. АлгоАлгоритм Прима обладает тем свойством, что ребра в множестве А всегда образуют единое дерево. Как показано на рис. 23.5, дерево начинается с произвольной

63. Минимальные покрывающие деревья. Алгоритм Крускала.

Пусть есть G(V,E) для каждого ребра графа задан неотрицательный коэффициент (v,w) минимальное остаточное дерево взвешенного связанного графа представляет собой от. Дерево с мин весом где вес дерева определяется как сумма весов всех его ребер.Алгоритм Крускала использует понятие компоненты связанности

For v V do Mark[xi]:=I Le Sort(E)

T ; while |t|<|V|-1 do {x,y} Le

if Mark[x] Mark[y] then begin T:=T {x,y} z:=Mark[y]

for v V do if Mark[v]=z then Mark[v]:=Mark[x] end

Le Le-{x,y} Return T

64. Нахождение кратчайших путей в графе. Алгоритм Форда-Беллмана.

Будем рассматривать ориентированные графы G = <V, E>, дугам которых приписаны веса. Это означает, что каждой дуге (u, v) E поставлено в соответствие некоторое вещественное число a(u, v), называемое весом данной дуги. Нас будет интересовать нахождение кратчайшего пути между двумя фиксированными вершинами s, t V. Длину такого пути обозначим d(s, t) и назовем расстоянием от s до t (расстояние, определенное таким образом, может быть и отрицательным). Если не существует ни одного пути из s в t, то полагаем d(s, t) = . Отметим, что если каждый контур нашего графа имеет положительную длину, то кратчайший путь будет всегда элементарным путем. Зная расстояние, мы можем, при условии положительной длины всех контуров, легко определить кратчайшие пути. Для произвольных s, t V (s t) существует вершина v такая, что d(s, t) = d(s, v) + d(v, t). Таким свойством обладают предпоследние вершины кратчайшего пути из s в t. Далее мы можем найти вершину u, для которой d(s, v) = d(s, u) + d(u, v) и т.д. Из условия положительности длины всех контуров следует, что последовательность t, v, u, ... не содержит повторений и заканчивается вершиной s. Перечислив вершины в обратном порядке, найдем кратчайший путь из s в t. Рассмотрим общий алгоритм, определяющий расстояния от некоторой фиксированной вершины s (назовем ее источником) до всех остальных вершин графа при усл-ии, что граф не имеет контуров отриц длины. Обычно этот алгоритм называют алгоритмом Форда–Беллмана. При работе алгоритма предполагается, что граф не имеет контуров отрицательной длины. A-матрица весов дуг, S-нач вершина, d-расстояние до всех вершин графа.

Bellman_Ford(G,A,S,d) BEGIN

FOR v V DO D[v] := a[s, v]; D[s] := 0; FOR k := 1 TO v-1 DO

FOR v V -{s} DO

FOR w V DO D[v] := min(D[v],

D[w]+a[w, v])

END;

65. Нахождение кратчайших путей в графе. Алгоритм Дейкстры.

Нахождение кратчайших путей в графе-см вопр 67. Алгоритм

находит путь минимального веса в графе G, заданном весовой матрицей (матрица смежности) -W. При этом предполагается, что все элементы Wij не отрицательны. и граф не имеет контуров. Дейкстры(G,A,S)

For all v V do d[v] A[s,w]; d[s] 0 T V-{s}

While T do

W:=наименьшее вершина t T D[t]:=min(d[p],p T) T T-{w}

For v T do d[v] min(d[v],d[w]+A[w,v] Return d

66. Пути в бесконтурном графе.

В бесконечном графе можно перенумеровать вершины так, что каждая вершина будет иметь (Vi, Vj), i<j – топологическая сортировка. 2-а вида: 1.основан на обходе в глубину;

2.метод непосредственной реализации метода уменьшения размера задачи на 1-цу.

Topol_Sort(G,N).

1.for all v (--(знак принадлежности) V do nz[v]=0

2.for all w (-- V do

3.for all v (-- V смежн с w do nz[v] nz[v]+1.

4.стекпустое мн-во. 5. num0. 6. for all v (-- V do

7. if nz[v]=0 then стекV. 8. while стек<>0 do begin 9. wстек. 10. numnum+1. 11.N[w]:=num; 12. for all v (-- V кот-ые смежны с w do begin

13.nz[v]:=nz[v]-1. 14. if nz[v]=0 then стекV 15. end. 16. end while. Теперь алгоритм путей.

При этом считаем, что вершины графа уже перенумерованы. G-граф, d-массив расстояний от вершины V. N-номера вершин после перенумерации.

DSP(G,N,d).

1.d[Ni]=0

2.for j=2 to n do d[Vj]беск-ть.

3.for j=2 to n do

For i=1 to j-1do d[Nj]=min(d[Vj],d[Vi]+a[Vi,Vj]). Для самого длинного меняем веса на «-».

67. Поиска кратчайших путей между всеми парами вершин. Алгоритм Флойда.

Задача состоит в поиске для каждого взвеш связного графа расстояния. Используется матрица расстояний. Эл-т i, j указывает длину кратч пути м-ду i-той и j-той вершиной.

68. Хеш-таблица. Открытое хеширование.

Если мн-во различных клчей велико, то хранить в памят и массив размером равным мощности возможных ключей не практично. Кроме того – большинство Эл-тов массива не заняты. позволяет очень быстро выполнять словарные операции.

Пусть имеются данные имеющие различные целочисленные положительные ключи. Для размещения данных воспользуемся таб T[0..m-1] каждая запись этой табл соответствует ключу из мн-ва И.

Открытое хеширование эл-ты мн-ва, которым соответствует одно хеш значение связ-ся в цепочку-список. Состоит из: функции хеширования и хеш табл. Использование хешфункции позволяет значительно снизить объем резервируемой памяти. Те каждому ключу ставится в соответствие значение хеш-функции. При этом эти значения могут совпадать, это ведет к образованию цепочек данных. ТЕ хеш-таб представляет собой массив списков, в j-ой позиции хранится указатель на начало списка.

Хеширование явл-ся быстрым методом поиска.

69. Хеш-функции (ключи как натуральные числа, деление с остатком, умножение).

h(k) – хеш-функция – отображает мн-во ключей в целочисл. Индекс. Число h(k) наз-ся хеш значением ключа k. Использование хеш-функции снижает использование памяти. Но есть проблема-хеш значение 2-х разных ключей могут совпадать. Тогда говорят, что случилось столкновение. При выборе хеш-функции следует учитывать сложность её вычисления и возможность распределить значения равномерно. Хорошая хеш-функция должна удовлетворять предлож. Равномерного хеширования. требования:

1.легко вычисляться

2.равномерно распределять данные по таблице ключи как:

1)натуральные числа, кодирование каждого числа целым числом, например ASCII 2)деление с остатком, h(k)=k mod m,

ключу К в соответствие ставиться остаток от деления на М(число возможных хеш значений) при этом нельзя брать М:

3)основание системы исчисления 4)28 и 216 для символьных ключей

5)умножение h(k)= m(k*a*mod1) где m- кол-во хеш-значений, a-зафиксированная константа (0..1). Достоинство метода-кол-во хеш-функций мало зависит от выбора m. Обычно выбирают как степень двойки.

70. Закрытое хеширование. (Линейная последовательность проб. Квадратичная последовательность проб. Двойное хеширование.)

Закрытое хеширование все записи хранятся в самой хеш-табл. Каждая ячейка табл является либо свободной либо содержит данные с опред ключом. Данные размещаются в хеш-табл по адресам, которые выдает хеш-функция. При добавлении элемента в хеш-табл мы просматриваем ее пока не найдем свободную ячейку. При этом хеш-функция зависит уже не только от ключа но и от номера попытки.

1)линейная последовательность проб, среднее кол-во сравн. Вып при поиске ячейки =0,5(1+1/(1-альфа)-если поиск успешный, если не успешный:0,5(1+(1/(1-альфа))^2). По мере заполнения таблицы значений данных среднее время поиска увелич-ся:если альфа=0,5(заполнена на половину), то среднее число проб не превышает 1,5, пр и безуспешном поиске 2,5; если табл заполнена на 2/3, то при успешном поиске нужно выпть 2-а сравнения, при безуспешном 5.

h(k,I)=(h (k)+i)mod m где h (k) U {0,1,…,m-1} – выполняет отображение ключей на табл. 2)квадратичная последовательность проб, h(k,I)=(h (k)+e i2)mod m

3)двойное хеширование h(k,I)=(h1(k)+i h2(k ))mod m, где h1(k) и h2(k) обычные хеш – функции. Эффективность кв-ого хеширования и двойного оценивается (1/альфа)ln(1/(1- альфа)) если успешный и 1/(1-альфа) если безуспешный. Если альфа=1/2 при усрешном 1,37 и 2 при безуспешном; если альфа=2/3 при успешном 1,64 и 3 при безуспешном