Сортировка объектов 4/5

Курсы Объекты
16

Моя уметь цикл и условие. Больше не уметь. Таки придется покупать интенсивы :rofl:

var getSortedArray = function (arr, nameKey) {
  arrValues = [];
  for (var i=0; i<arr.length; i++) {
    arrValues[i] = arr[i][nameKey];
  };
  arrValues.sort(function(a, b) { return a - b; });
  for (var i=0; i<arr.length; i++) {
    for (var j=0; j<arr.length; j++) {
      if (arrValues[i] === arr[j][nameKey]) {
        arrValues[i] = arr[j];
      };
      if (arrValues[i] === arrValues[i-1]) {
        arrValues[i] = arr[j];
      };
    };
  };
  return arrValues;
};
17

В принципе @Hierumo уже реализовал то же самое (я думал все через стрелочные переделать, но лень)

Давно не спойлер!

function getSortedArray(array, key) {
return array.sort((a, b) => a[key] - b[key]);
}

18

просто переписываем массив

Сводка 
var getSortedArray = function (arr, name){
   for (var i = 0; i < arr.length - 1; i++){
    for (var j = i+1; j < arr.length; j++){
      if (arr[i][name] > arr[j][name]){
        arr.push(arr[i]);
        arr.splice(i,1);
      }      
    }
  }
  return arr;
}
2 лайка
19 
var getSortedArray = function (arrayList, nameKey) {
  
  for (var i = 0; i < arrayList.length - 1; i++) {
    var minValue = arrayList[i];
    
    for (var j = i + 1; j < arrayList.length; j++) {
      if (arrayList[j][nameKey] < arrayList[i][nameKey]) {
        minValue = arrayList[j];
        var replace = arrayList[i];
        arrayList[i] = minValue;
        arrayList[j] = replace;
      }
    }
  }
  
  return arrayList;
}
1 лайк
20

Я стараюсь выполнять задания только на основе полученных знаний и вот что выходит
var getSortedArray = function(arr, key){
for (var i = 0; i < arr.length - 1; i++){
for (var j = 0; j < arr.length - 1 - i; j++){
if(arr[j + 1][key] < arr[j][key]){
var flag = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = flag;
}
}
}

return arr;
};

1 лайк
21

Что-то я упустил в каких случаях применяется mass.length - 1, а в каких mass.length?

22

Здравствуйте!
Мой вариант:

Сортирова объектов (п - после)
Сортирова объектов (п - после)1366×861 66.7 KB

23 
let getSortedArray = (arr, keyOfObj)=>arr.sort((a,b)=>a[keyOfObj] - b[keyOfObj])
24

вариант без стрелочных функций

const getSortedArray = function(array, key) {
  return array.sort(function(a, b) {
    return a[key] - b[key];
  });
}
25

А Вы не знаете случайно почему здесь не работает обращение к ключам через точку? вместо a[key] - b[key] ---- a.key - b .key

26

ну там где с точкой, должно быть четкое название ключа key. Т.е. сортироваться будут только объекты с ключом, который так и называется “key”, а не передаваемый ключ из аргументов функции

27

Спасибо большое) Теперь пазл сложился полностью у меня)))

28

Тому що у об’єкта немає таких ключів, а ключами є змінні, тому береться в [ ]

29

const getSortedArray = (arr, key)=> arr.sort((a,b)=>a[key]-b[key])

30

Мое решение использую только пройденный материал:

let getSortedArray = function (array, keyName) {

for (let i=0; i<array.length-1; i++) {
  let swap = array[i];
      for (let j=i+1; j<array.length; j++) {
        if (array[j][keyName] < array[i][keyName]) {
            array[i] = array[j];
            array[j] = swap;
            swap = array[i];            
        }         
      }   
}

return array
}

31

Моё решение:

let getSortedArray = function (array, name) {
  for (let i = 0; i <= array.length - 2; i++) {
    let minValue = array[i];
    for (let j = i + 1; j <= array.length - 1; j++) {
      if (minValue[name] > array[j][name]) {
        minValue = array[j];
        let swap = array[i];
        array[i] = minValue;
        array[j] = swap;
      }
    }
  }
  return array;
}
1 лайк
32

Не совсем понятно как ты поменял объекты местами в массиве

33

Потому что последний элемент массива не нужно сортировать, т.к. все элементы перед ним уже отсортированы. Там в любом случае будет наибольший элемент.

34

Я решил попрактиковать алгоритмы и написал quicksort. Код проходит первый тест, а на втором выдает Timeout error. Не очень понимаю как это может быть, если тут примеры кода за O(n^2) работают и проходят.

Код ниже:

let quickSort = function(array, key, low=0, high=NaN) {
  if (isNaN(high)) {
    high = array.length - 1
  };
  
  let left = low;
  let right = high;
  let pivot = array[Math.floor((low+high)/2)][key];
  
  if (left >= 0 && right >= 0 && left < right) {
    while (left < right) {
        if (array[left][key] < pivot) {
          left++;
        }
        else if (array[right][key] > pivot) {
          right--;
        }
        else {
          [array[left], array[right]] = [array[right], array[left]]
        };
    };
    quickSort(array, key, low, right);
    quickSort(array, key, left + 1, high);
  };
};

let getSortedArray = function(array, key) {
  quickSort(array, key);
  return array;
};
35

var getSortedArray = function (mass, key) {
for (var i = 0; i < mass.length - 1; i++) {
for (var j = i + 1; j < mass.length; j++) {
if (mass[i][key] > mass[j][key]) {
var swap = mass[i];
mass[i] = mass[j];
mass[j] = swap;
}
}
}
return mass;
}