Алгоритм:

1. понадобится два массива:  исходный(неупорядоченный) и выходной(пустой)
2. берем первый элемент исходного массива и помещаем в конец выходного
3. в цикле сравниваем добавленый элемент со всеми, пока он не станет на свое место
4. повторяем пункт 3 пока в исходном массиве не закончатся элементы

  #include 
  #include


  void add(int *mas[20], int n)
    {
     int i,j,*temp;

     for (i=0;i0)
         {
          temp=mas[j-1];
          mas[j-1]=mas[j];
          mas[j]=temp;
          --j;
         }
       for (i=0;i>menu;
	switch (menu)
	  {
	   case 1: { cin>>mas[n];  ++n; add(&mas, n);  } ; break;

	   default: exit=1;
	  }
       };

    }

Исходные данные для этого метода должны быть упорядочены по ключу или же создан специальный файл ключей, который отсортирован по этому ключу.

Исходные данные: L=1  и R=n (границы поиска)

Алгоритм:

1. i=(L+R) / 2
2. сравниваем K[i] с K[искомое] , если равно, то 5, если K[i]< ,то пункт 3 , иначе пункт 4
3. Значит L=i+1 и перейти в пункт 1
4. R=i-1 и перейти к пункту 1
5. найдено, поиск успешен

Всю процедуру повторяем до тех пор пока L не станит равным R

Скорость данного метода равна log₂n

Скорость такого поиска равна n/2

Достоинство:

• Возможен поиск по любому условию
• не требуется предворительная подготовка

Возможности ускорения: Если имеется файл ключей, так как длина ключа значительно меньше длины всей записи, то поиск будет проходить быстрее. Но файл ключей должен быть предворительно создан, что не всегда удобно.

Пусть на каком либо  носителе хранятся записи R1, R2,…, Rn. У каждой записи выделен ключ K1,K2,.., Kn.

Ключ – это набор полей записи по которым произвожится поиск или сортировка.

Задача поиска состоит в нахождении такого Ki равному Кискомому и соответственно последующий доступ к Ri.

У нас на сайте вы можете найти следущие алгоритмы организации поиска:

• поиск последовательным просмотром
• бинарный поиск

Если в двух исходных файлах получить количество упорядоченых последовательностей равных двум соседним числам Фибоначи (например, 5 отрезков в одном и 8 в другом), то используя три файла мы сможем завершить сортировку не прибегая к дополнительному разделению файлов на два.

Принцип:

Подбираем длину цепочки таким образом, что бы хватило памяти на сортировку цепочки. И так что бы количество отрезков было равно какому то числу Фибоначи. Тогда распределяем их в количество совпадающих с двумя предыдущими числами Фибоначи.

Алгоритм:

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

Числа Фибоначи гарантируют, что это произойдет без эксцессов.

Естественное двупутевое слияние
Недостатком предыдущего метода можно считать необходимость учитывать длину цепочки, что в некоторых случаях не желательно.
Для того что бы не считать длину цепочки можно ввести условие окончания цепочки, таким условием может быть когда следующий элемент меньше предыдущего для возрастающей сортировки. Может так получиться, что первый элемент больше последнего элемента предыдущего фрагмента. В этом случае считаем, что это одна возрастающая цепочка, так как это только ускорит сортировку.

• Отцом к является узел [k/2]
• Потомками узла к являются 2к и 2к+1

Пирамидой будем называть дерево удовлетворяющие написаным выше правилам и к ним еще плюс:

k[j/2]>=k[j]

1<=[j/2]<j<=N

Procedure shift(L,R: integer);
var
i,j:integer;
x: integer;
Begin
i:=L;
j:=2*L;
x:=A[L];
if (j<R) and (A[j]<A[j+1]) then
j:=j+1;
while (j<=R) and (x<A[j]) do
begin
A[i]:=A[j];
i:=j;
j:=2*j;
if (j<R) and (A[j]<A[j+1]) then
inc(j);
end;
A[i]:=x;
end;

Пример исспользования:

L:=(N div 2)+1;
R:=N;
while L>1 do
begin
L:=L-1;
shift(L,R);
end;
while (R>1) do
begin
x:=A[1];
A[1]:=A[R];
A[R]:=x;
R:=R-1;
shift(L,R);
end;

Достаточно спуститься от корня к листьям тем путем, каким значение попало в корень. Для этого достаточно найти среди двух потомков равные ему и перейти, повторять операцию до тех пор, пока не дойдем до листьев. Лист удаляем, после этого поднимаемся снова к корню в поимке нового максимального значения.

Достоинство: высокая скорость, приближенная к скорости сортировки Хоара.

Недостаток: требуется много памяти.

Недостатки: долго, требуется два массива.