Delphi - сортировка действительных чисел в высоком, низком, высоком, низком порядке

Question

Скажет, у меня есть данные 1,2,3,4,5,6

Я хочу, чтобы отсортировать эти данные так, что он выводит - 1 5 2 4 3

таким образом, цифры совпадают с тем, что низкие числа пары с большим числом

ли я использовать слияние для сортировки в порядке возрастания, а затем разделить список и сопоставить их в соответствии с этим условия?

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

Это код для моей сетки сортировки

procedure TForm1.SortGrid(Grid: TStringGrid; const SortCol: Integer; 
//sorting the string grid 
    const datatype: Integer; const ascending: boolean); 
var 
    i: Integer; 
    tempgrid: TStringGrid; 
    list: array of Integer; 
begin 
    tempgrid := TStringGrid.create(self); 
    with tempgrid do 
    begin 
    rowcount := Grid.rowcount; 
    ColCount := Grid.ColCount; 
    fixedrows := Grid.fixedrows; 
    end; 
    with Grid do 
    begin 
    setlength(list, rowcount - fixedrows); 
    for i := fixedrows to rowcount - 1 do 
    begin 
     list[i - fixedrows] := i; 
     tempgrid.rows[i].assign(Grid.rows[i]); 
end; 
    Mergesort(Grid, list, SortCol + 1, datatype, ascending); 


     for i := 0 to rowcount - fixedrows - 1 do 
     begin 
    rows[i + fixedrows].assign(tempgrid.rows[list[i]]) 
     end; 
     row := fixedrows; 
    end; 
    tempgrid.free; 
    setlength(list, 0); 
    end; 

Answer 1

Сортировка данных в порядке возрастания. Затем выбрать значения с помощью следующих показателей: 0, п-1, 1, п-2, ....

В псевдокоде алгоритм выглядит следующим образом:

Sort; 
lo := 0; 
hi := n-1; 
while lo<=hi do 
begin 
    yield lo; 
    inc(lo); 
    if lo>hi then break; 
    yield hi; 
    dec(hi); 
end; 

Answer 2

Во-первых, сортировать числа в порядке убывания с использованием любого алгоритма, который вы хотите (я использовал пузырьковой сортировки в примере)

Тогда, если у вас есть п элементов в массиве:

• установлен счетчик, идущий от 1 до (п ДИВ 2)
• взять последний элемент и хранить его в временной переменной (TMP)
• сдвиг всех элементов на одно место вправо, начиная с (счетчик - 1) * 2 + 1. Это перезапишет последний элемент, но хранят его в TMP вар
• набор массива [(счетчик - 1) * 2 + 1] элемент TMP
• конец прилавка

Таким образом, вы эффективно берете последний элемент из массива и вставляете его в положение 1, 3, 5 ..., пока вы не введете последнюю половину элементов массива.

Пример кода:

procedure Sort(var AArray: array of Double); 
var 
    C1, C2: Integer; 
    tmp : Double; 
    pivot : Integer; 
begin 
    for C1 := Low(AArray) to High(AArray) - 1 do 
    for C2 := C1 + 1 to High(AArray) do 
     if AArray[C1] < AArray[C2] then 
     begin 
     tmp := AArray[C1]; 
     AArray[C1] := AArray[C2]; 
     AArray[C2] := tmp; 
     end; 

    pivot := Length(AArray) div 2; 
    for C1 := 1 to pivot do 
    begin 
    tmp := AArray[High(AArray)]; 
    for C2 := High(AArray) downto (C1 - 1) * 2 + 1 do 
     AArray[C2] := AArray[C2 - 1]; 
    AArray[(C1 - 1) * 2 + 1] := tmp; 
    end; 
end; 

Answer 3

Пример программы демонстрации уже выше, данные решения:

program Project1; 

{$APPTYPE CONSOLE} 

const 
    Count = 12; 
type 
    TValues = array[0..Count - 1] of Double; 
const 
    Input: TValues = (1,2,4,9,13,14,15,23,60,100,101,102); 
var 
    I: Integer; 
    Output: TValues; 

procedure ShowValues(Caption: String; Values: TValues); 
var 
    I: Integer; 
begin 
    Write(Caption); 
    for I := 0 to Count - 2 do 
    Write(Round(Values[I]), ', '); 
    WriteLn(Round(Values[Count - 1])); 
end; 

begin 
    if Odd(Count) then 
    WriteLn('Cannot compute an odd number of input values') 
    else 
    begin 
    WriteLn('Program assumes sorted input!'); 
    ShowValues('Input: ', Input); 
    for I := 0 to (Count div 2) - 1 do 
    begin 
     Output[2 * I] := Input[I]; 
     Output[2 * I + 1] := Input[Count - 1 - I]; 
    end; 
    ShowValues('Output: ', Output); 
    end; 
    ReadLn; 
end. 

Answer 4

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

[Обратите внимание, что у меня нет компилятора, так что вам нужно будет запустить его и увидеть, что он работает - возможно, потребуется минимальное возиться.]

procedure SerratedSort(var AArray: array of Double); 
var 
    Length1: Integer; 
    Index1: Integer; 
    Temp1: Double; 
begin 
    Length1 := Length(AArray); 
    Index1 := 0; 
    while Index1 < Length1 do begin 
    Temp1 := AArray[Length1 - 1]; 
    System.Move(AArray[Index1], AArray[Index1 + 1], (Length1 - Index1 + 1) * SizeOf(Double)); 
    AArray[Index1] := Temp1; 
    Index1 := Index1 + 2; 
    end; 
end; 

Вот как это (должны) работа (ы) шаг за шагом

Входной AArray: 123456

• Индекс1: 0

Temp1: = 6

System.Move: 112345

AArray: 612345

• Индекс1: 2

Temp1: = 5

System.Move: 612234

AArray: 615234

• Индекс1: 4

Temp1: = 4

System.Move: 615233

AArray: 615243

Выход AArray: 615243

---

Для структуры записи, например, TPerson, это было бы так:

procedure SerratedSort(var A: array of TPerson); 
var 
    s: Integer; 
    i: Integer; 
    t: TPerson; 
begin 
    s := Length(A); 
    i := 0; 
    while i < s do begin 
    t := A[s - 1]; 
    System.Move(A[i], A[i + 1], (s - i + 1) * SizeOf(TPerson)); 
    A[i] := t; 
    i := i + 2; 
    end; 
end;