打乱数组

方法一

从已知数组中随机一个数,然后加入到另一个数组中,在加入之前,先检查是否已经加入过。

这种方法有很大运气成分,且数据越大,效率越低,超过一定数目,则程序几乎无法执行,会一直卡在那里,代码:

    package com.test;  

    import java.util.Random;  

    public class TestArray {
     public static int runCount =0;//用于记录方法运算次数  

     public int []  m1(int [] arr){
      Random ran = new Random();
      int length = arr.length;
      int [] newArr = new int[length];
      int count =0;
      while (true) {
       runCount ++;
       int r = ran.nextInt(length)+1;
       if(!exist(r, newArr)){
        newArr [count] = r;
        count++;
       }
       if(count==length){
        break;
       }
      }
      System.out.println("m1 运算次数  = "+runCount);
      return newArr;
     }  

     public static boolean exist(int a,int [] arr){
      for (int i = 0; i < arr.length; i++) {
       if(arr[i] ==a){
        return true;
       }
      }
      return false;
     }  

方法二

这种方法是我遇到这个问题就想到的,思路就是:先随机出已知数组的下标值,然后取出这个数放到另一个数组中,再从已知数组中删除这个数。这种方法的运算次数是根据数组长度而定的,缺点是 大部分运算都耗在删除的判断上,主要是因为 数组不像list那样,能删除一个指定位置的值。代码:

public int []  m2(int [] arr){
 Random ran = new Random();
 int [] newArr = new int[arr.length];
 int k = 0;
 while (arr.length>0) {
  runCount++;
  int index = ran.nextInt(arr.length);//随即数组下标
  newArr[k++] = arr[index];
  arr = removeElement(arr[index], arr);
 }
 System.out.println("m2运算次数  = "+runCount);
 return newArr;
}  

public int [] removeElement(int ele,int [] arr){
 int [] arr2 =new int[arr.length-1];
 int k = 0;
 for (int i = 0; i < arr.length; i++) {
  runCount++;
  if(arr[i]!=ele){
   arr2[k++] = arr[i];
  }
 }
 return arr2;
}  

方法三

每次从已知数组随机一个数,然后将数组的最后一个值 赋值给前面随机到的数的位置上,然后将长度-1,再从原数组下标-1的数组中随机。 运算次数就是数组长度,代码:

public int []  m3(int [] arr) {
 int [] arr2 =new int[arr.length];
 int count = arr.length;
 int cbRandCount = 0;// 索引
 int cbPosition = 0;// 位置
 int k =0;
 do {
  runCount++;
  Random rand = new Random();
  int r = count - cbRandCount;
  cbPosition = rand.nextInt(r);
  arr2[k++] = arr[cbPosition];
  cbRandCount++;
  arr[cbPosition] = arr[r - 1];// 将最后一位数值赋值给已经被使用的cbPosition
 } while (cbRandCount < count);
 System.out.println("m3运算次数  = "+runCount);
 return arr2;
}

4 将随机得到的这个数和数组最后一个数交换。然后再从array.length-1中随机一个数和array.length-1交换。

测试代码

public static void main(String[] args) {
    int[] arr = new int[10];
    for (int i = 0; i < arr.length; i++) {
        arr[i] = i + 1;
    }
    TestArray t = new TestArray();
    arr = t.m1(arr);
    print(arr);
    arr = t.m2(arr);
    print(arr);
    arr = t.m3(arr);
    print(arr);
}  

public static void print(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + " ");
    }
    System.out.println();
    runCount = 0;
}

结果:

    1. m1 运算次数  = 51
    2. 3 10 2 1 5 9 6 8 4 7
    3. m2运算次数  = 65
    4. 1 3 8 2 10 5 9 6 7 4
    5. m3运算次数  = 10
    6. 10 7 8 3 1 5 6 9 2 4
时间: 2024-12-07 23:14:09

打乱数组的相关文章

简单说说随机打乱数组的方法

原文链接:http://www.gbtags.com/gb/share/5646.htm 把一个数组随机打乱这个需求来源可能就是“洗牌”,所以我们常常称之为洗牌问题.这个问题实现并不复杂,有不少方法可以完成.与其他算法不同,洗牌问题不仅追求速度,还要求“洗得足够开”.今天只想写篇短的,只分享两种比较有代码性的洗牌方法.至于这些方法能不能真正将数组随机打乱,我们下次再讲. 方法一,随机排序法: function shuffle(array) { array.sort(function() { re

c# 打乱数组

有时候得到了一个List,我想把它随机排列一下顺序.而且如果针对不同类型的List都能用,就要用到泛型. 其实思想很简单,就是从原List中每次随机取一项,添加到新的List中,并在原List中删除.这样重复,直到原List为空为止. 不过要注意,如果要保护原List不受变化,就必须先Copy一份List,再在Copy上进行操作 public static List<T> GetRandomList<T>(List<T> inputList) { //Copy to a

[Swift]LeetCode384. 打乱数组 | Shuffle an Array

Shuffle a set of numbers without duplicates. Example: // Init an array with set 1, 2, and 3. int[] nums = {1,2,3}; Solution solution = new Solution(nums); // Shuffle the array [1,2,3] and return its result. Any permutation of [1,2,3] must equally lik

随机打乱数组元素

把数组内的元素随机打乱,重新进行排列  C#版: 1 public static void Shuffle<T>(T[] array) 2 { 3 Random random = new Random(); 4 5 for (int i = 0; i < 10; i++) 6 { 7 int idx = random.Next(i, 10); 8 9 //swap elements 10 T tmp = array[i]; 11 array[i] = array[idx]; 12 arr

js【实践】用 js 封装java shuffle函数(打乱数组下标方法)

此方法返回的会是一个全新的数组 所以并不会像java里的shuffle函数一样返回一个引用一样的数组 思路如下: 1.新建一个函数传入需要打乱下标的数组 2.获取数组的长度 3.新建一个用来保存并且返回结果的数组 4.根据数组的长度新建一个随机数(随机数记得要向下取整不然会下标越界) 5.循环添加到结果数组里面 代码如下: <script type="text/javascript"> var testArr = new Array("中国","

php打乱数组二维数组、多维数组

//这个是针对二维数组的!下面针对多维数组的乱序方法<?php function shuffle_assoc($list) { if (!is_array($list)) return $list; $keys = array_keys($list); shuffle($keys); $random = array(); foreach ($keys as $key) $random[$key] = $list[$key]; return $random; } ?> //以下函数也是出自php

php保留键随机打乱数组顺序

最近遇到一个需求,把一个数组随机打乱顺序,我们可以用php的shuffle函数,但是这个函数会把数组的键清空建立新的键,那么我们若想保留键只需要利用shuffle函数再做一下处理就可以了.可以自定义一个函数. <?php function retain_key_shuffle(array &$arr){ if (!empty($arr)) { $key = array_keys($arr); shuffle($key); foreach ($key as $value) { $arr2[$v

javascript打乱数组顺序-----1

1 <!DOCTYPE html> 2 <html lang="en"> 3 <head> 4 <meta charset="UTF-8"> 5 <title>javascript数组去重算法-----3</title> 6 </head> 7 <body> 8 <script> 9 var arr = [1,2,3,4,5,6]; 10 function d

javascript随机打乱数组

var arr=[]; for(var i=0;i<10;i++){ arr[i]=i; } arr.sort(function(){ return 0.5 - Math.random() }) var str=arr.join(); alert(str); 代码解释: sort 是对数组进行排序它是这样工作的,每次从数组里面挑选两个数 进行运算.如果传入的参数是0 两个数位置不变.如果参数小于0 就交换位置如果参数大于0就不交换位置接下来用刚才的较大数字跟下一个进行比较.这样循环进行排序 恰好