Python: чередующиеся элементы отсортированного массива

Question

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

В Java я был в состоянии сделать это так:

public static void wackySort(int[] nums) { 
    //first, this simply sorts the array by ascending order. 
    int sign = 0; 
    int temp = 0; 
    int temp2 = 0; 
    for (int i = 0; i < nums.length; i++) { 
     for (int j = 0; j < nums.length -1; j++){ 
      if (nums[j] > nums[j+1]) { 
       temp = nums[j]; 
       nums[j] = nums[j+1]; 
       nums[j+1] = temp; 
      } 
     } 
    } 

    //prepare for new array to actually do the wacky sort. 
    System.out.println(); 
    int firstPointer = 0; 
    int secondPointer = nums.length -1; 
    int[] newarray = new int[nums.length]; 
    int size = nums.length; 

    //increment by two taking second slot replacing the last (n-1) term 
    for (int i = 0; i < nums.length -1; i+=2) { 
     newarray[i] = nums[firstPointer++]; 
     newarray[i+1] = nums[secondPointer--]; 
    } 

    //store those values back in the nums array  
    for (int i = 0; i < nums.length; i++) { 
     nums[i] = newarray[i]; 
    } 
} 

Моя цель состоит в том, чтобы сделать то же самое, но в питоне, за исключением назад. Любые идеи о том, как преобразовать этот последний цикл в цикл, который делает wackysort в python и заставить его вернуться назад?

Answer 1

nums = [1, 2, 3, 4] 
newarray = sum(zip(reversed(nums), nums),())[:len(nums)] 

>>> print(newarray) 
(4, 1, 3, 2) 

---

Что она делает, шаг за шагом. первых, reversed():

>>> list(reversed(nums)) 
[4, 3, 2, 1] 

Тогда zip():

>>> list(zip([4, 3, 2, 1], [1, 2, 3, 4])) 
[(4, 1), (3, 2), (2, 3), (1, 4)] 

Вы можете видеть, что мы имеем почти список, мы хотим, у нас есть проблема: эти кортежи. мы хотим сгладить их.

>>> (4, 1) + (3, 2) + (2, 3) + (1, 4) 
(4, 1, 3, 2, 2, 3, 1, 4) 

Ох. Это мило. Но как это сделать в списке? Простой: используйте sum(), что делает именно это - добавление многих вещей вместе. Только мы должны дать ему что-то, чтобы начать с - пустой кортеж ():

>>> sum([(4, 1), (3, 2), (2, 3), (1, 4)],()) 
(4, 1, 3, 2, 2, 3, 1, 4) 

Но мы не хотим вторую половину, так что давайте удалим его. Мы знаем, что его список ровно в два раза длиннее, да?

>>> (4, 1, 3, 2, 2, 3, 1, 4)[:len(nums)] 
(4, 1, 3, 2) 

Всё.

---

Другой вариант:

from itertools import chain, islice 
a = list(islice(chain.from_iterable(zip(nums, reversed(nums))), len(nums))) 

Answer 2

Это последний цикл:

for (int i = 0; i < nums.length; i++){ 
    nums[i] = newarray[i]; 

... это один вкладыш в Python. Точный эквивалент:

nums[:] = newarray[:len(nums)] 

Однако, скорее всего, все, что вам действительно нужно:

nums = newarray 

---

Если вы действительно хотите, чтобы записать его в «Java стиль» по какой-то причине, бы это:

i = 0 
while i < len(nums): 
    nums[i] = newarray[i] 
    i += 1 

Но что делает то же самое, что и первый вариант, за исключением более медленный более медленно и менее читаемо.

---

Между тем, для предыдущего цикла:

for (int i = 0; i < nums.length -1; i+=2){ 
    newarray[i] = nums[firstPointer++]; 
       newarray[i+1] = nums[secondPointer--]; 

Опять же, вы можете перевести это более или менее непосредственно в Python:

i = 0 
while i < len(nums)-1: 
    newarray[i] = nums[firstPointer] 
    firstPointer += 1 
    newarray[i+1] = nums[secondPointer] 
    secondPointer -= 1 
    i += 2 

Но как с последней версией последний цикл, это ужасно нечитаемо, и вы будете намного счастливее, если попытаетесь описать алгоритм, а затем напишите это в Python.

Answer 3

Я хотел бы предложить его сортировку обычно первым, а затем делает свой перетасовать:

inlist=[3,5,7,6,9,8,2,1] 
inlist.sort() 
outlist=[] 
while len(inlist)>0: 
    if (len(outlist)%2==0): 
     outlist.append(inlist.pop()) 
    else: 
     outlist.append(inlist.pop(0)) 

Answer 4

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

def wacky_sort(seq): 
    # code you already have 

def alternate_ends(seq): 
    new_seq = [] 
    while seq: 
     new_seq.append(seq.pop(0)) 
     if seq: 
      new_seq.append(seq.pop()) 
    return new_seq 

def wacky_sort_with_alternating_ends(seq): 
    wacky_sort(seq) 
    return alternate_ends(seq)