unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Label1: TLabel;
    Label2: TLabel;
    Button1: TButton;
    Button2: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
  const N=40;
var
  Form1: TForm1;
  mas: array[1..N] of integer;
implementation

{$R *.dfm}
procedure sort(l, r: integer);
var
  i,j,temp: integer;
  left: boolean;
begin
left:=true;
if (r-l)>=1 then
begin
 i:=l;
 j:=r;

 while i<>j do
   begin
    if left=true then begin
      if mas[i]<=mas[j] then
        begin
         j:=j-1;
        end
      else
        begin
         temp:=mas[i];
         mas[i]:=mas[j];
         mas[j]:=temp;
         inc(i);
         left:=false;
        end;
      end
      else
      begin
      if mas[i]<=mas[j] then
        begin
         inc(i);
        end
      else
        begin
         temp:=mas[i];
         mas[i]:=mas[j];
         mas[j]:=temp;
         j:=j-1;
         left:=true;
        end;
        end;
   end;
sort(l, i-1);
sort(j+1, r);
end;
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  i: integer;
begin
randomize;
Label1.Caption:='';
for i:=1 to N do
  begin
   mas[i]:=random(100);
   Label1.Caption:=Label1.Caption+'  '+IntToStr(mas[i]);
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  i: integer;
begin
Label2.Caption:='';

sort(1,N);
for i:=1 to N do
  Label2.Caption:=Label2.Caption+'  '+IntToStr(mas[i]);
end;

end.

Алгоритм:

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;
	  }
       };

    }

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

• Отцом к является узел [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;

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

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

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

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

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

Qsort(L,R) – процедура среднего элемента

заведем два счетчика i,j

i:=L;      j:=R;

i будет увеличиваться, а j уменьшаться, при чем в одну интерпретацию изменять только один счетчик. Объявляем активным любой из них, каждый раз сравниваем B[i] и B[j]. Если требуется обмен, то мы его производим и меняем активный элементы и активный счетчик. Процедура завершается когда i=j, то есть и будет средний элемент.

3  2  1  6  5  9  4  7  0  8

i                                    j

3  2  1  6  5  8  4  7  0  9

i                 j

3  2  1  6  5  0  4  7  8  9

i           j

Сложность Хоара пропорциональна n*log(n) по основанию 2

Недостаток. Быстрее всего работает если элементы упорядочены наоборот и медленее всего если элементы упорядочены или близки к этому.

i – счетчик

M – расматриваемая часть массива ,  M:=N-1

Несколько раз подряд просматриваем массив В от 0 до M-1 . Для каждого i сравниваем B[i] и B[i+1]. Если они стоят не в нужном порядке, то меняем их местами и к:=i (k – место последнего обмена).  к+1 занял свое место, M:=k; перед каждым просмотром к:=0. Просмотры повторяются до тех пор пока M>0/

Достоинство метода: не требуется дополнительных массивов.

Недостаток: время алгоритма пропорционально квадрату количества элементов.

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

]]> http://www.studcode.ru/archiv/sortirovka-metod-pogruzheniya-2/feed/ 0