Cara rawak indeks nilai dalam tatasusunan dan buat tatasusunan rawak menggunakan kemahiran javascript_javascript

Contoh dalam artikel ini menerangkan kaedah rawak indeks nilai dalam tatasusunan dan mencipta tatasusunan rawak menggunakan JavaScript. Kongsikan dengan semua orang untuk rujukan anda. Butirannya adalah seperti berikut:

Hari ini dalam kumpulan komunikasi QW, saya melihat beberapa pelajar membincangkan isu tatasusunan rawak Algoritma yang diberikan adalah sangat baik, dan ia mengingatkan saya tentang kaedah yang tidak begitu "cantik" yang telah saya laksanakan sebelum ini. Fikir-fikirkan, kadang-kadang apabila kita sibuk menulis kod perniagaan semata-mata untuk melaksanakan fungsinya, kita tidak terlalu memikirkan sama ada terdapat kaedah pelaksanaan yang lebih baik.

Setakat masalah tatasusunan ini (kemudian susun nilai dalam tatasusunan dan kembalikan tatasusunan baharu), kaedah pelaksanaan saya sebelum ini adalah seperti berikut:

function randArr(arr) {
 var ret = [],
 obj = {},
 i = arr.length,
 l = i,
 n;
 while (--i >= 0) {
  n = Math.floor( Math.random() * l );
  if (obj[n] === void 0) {
   ret[ret.length] = obj[n] = arr[n];
  } else {
   i++;
  }
 }
 return ret;
}

Kod di atas akan berfungsi, tetapi ia bukan algoritma yang baik Ia berhasrat untuk melaksanakan gelung "panjang tatasusunan asal" Setiap gelung secara rawak akan memilih indeks dalam tatasusunan asal, dan kemudian menentukan sama ada indeks itu ada telah diambil. Jika tidak, letakkan nilai indeks ke dalam tatasusunan baru Jika sudah, tambahkan kekunci pengurangan i sebanyak 1 (tujuan untuk mengulangi kitaran sehingga indeks lain yang belum diambil diambil). Prestasi kaedah ini bergantung pada watak anda Saya percaya bahawa pelajar yang telah melihat idea ini akan memahami sebabnya.

Sekarang berikan algoritma pelajar dalam kumpulan:

function randArr(arr) {
 var ret = [],
 i = arr.length,
 n;
 arr = arr.slice(0);
 while (--i >= 0) {
  n = Math.floor( Math.random() * i);
  ret[ret.length] = arr.splice(n, 1)[0];
 }
 return ret;
}

Ini adalah algoritma yang agak bijak Selepas setiap gelung, indeks rawak diambil dan nilainya dipadamkan daripada tatasusunan Dengan cara ini, jika indeks masih diambil secara rawak kemudian, indeks itu bukan lagi nilainya diperoleh kali terakhir, dan julat nombor rawak akan berkurangan mengikut penurunan panjang tatasusunan, supaya hasil yang ideal boleh diperolehi dengan menggelung beberapa kali pada satu masa.

Saya juga melihat versi yang lebih baik, yang mengambil kira beberapa masalah prestasi yang disebabkan oleh operasi pemadaman tatasusunan dan menggunakan algoritma shuffling JK, iaitu, menukar setiap operasi pemadaman kepada operasi penggantian kedudukan (nilai yang diambil ini indeks ditukar dengan nilai yang sepadan dengan kunci penurunan semasa i), supaya kesan pada keseluruhan tatasusunan adalah minimum, jadi mari letakkan kod:

function randArr(arr) {
 var ret = [],
 i = arr.length,
 n;
 arr = arr.slice(0);
 
 while (--i >= 0) {
  n = Math.floor( Math.random() * i);
  ret[ret.length] = arr[n];
  arr[n] = arr[i];
 }
 return ret;
}

Akhir sekali, kaedah "membuat tatasusunan rawak dengan nilai antara min~maks" diberikan Prinsip algoritma adalah serupa dengan di atas:

function makeRandArr(min, max) {
 var ret = [],
 obj = {},
 n;
 for (; max >= min; max--) {
  n = Math.ceil( Math.random() * (max - min) ) + min;
  ret[ret.length] = obj[n] || n;
  obj[n] = obj[max] || max;
 }
 return ret;
}

Saya harap artikel ini akan membantu reka bentuk pengaturcaraan JavaScript semua orang.