产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复。
请问怎么实现！

1. int[] array = new int[100];
   
2.             Random ran = new Random();
   
3.             int count = 0;
   
4.             for (; count < 100;)
   
5.             {
   
6.                 int num = ran.Next(1, 101);
   
7.                 if(!array.Contains(num))
   
8.                 {
   
9.                     array[count] = num;
   
10.                     count++;
    
11.                 }
    
12.             }

复制代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
         
            int[] a = new int[100];
            Random rm = new Random();
            int b = 0;
            while (b<100)
            {
                int r=rm.Next(1,101);
                if (!a.Contains(r))  //判断随机数是否包含在数组中，不包含则赋值给a[b]，并且下标自增
                {
                    a[b] = r;
                    b++;                    
                }
            }
            for (int i = 0; i < a.Length; i++)    //做个冒泡排序后输出打印到控制台，可以更直观
            {
                for (int j = 0; j < a.Length-i-1; j++)
                {
                    if (a[j] > a[j + 1])
                    {
                        int temp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = temp;
                    }

                }
            }
                for (int j = 0; j < a.Length; j++)   //遍历打印
                {
                    Console.WriteLine(a[j]);
                }
            Console.WriteLine("============================");
            Console.WriteLine(a.Length);
            Console.ReadKey();

        }
    }
}

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Linq;
   
4. using System.Text;
   
5. using System.Threading.Tasks;
   
6. 
   
7. namespace ConsoleApplication2
   
8. {
   
9.      class Program
   
10.      {
    
11.          static void Main(string[] args)
    
12.          {
    
13.          
    
14.              int[] a = new int[100];
    
15.              Random rm = new Random();
    
16.              int b = 0;
    
17.              while (b<100)
    
18.              {
    
19.                  int r=rm.Next(1,101);
    
20.                  if (!a.Contains(r))  //判断随机数是否包含在数组中，不包含则赋值给a[b]，并且下标自增
    
21.                 {
    
22.                      a[b] = r;
    
23.                      b++;                    
    
24.                  }
    
25.              }
    
26.              for (int i = 0; i < a.Length; i++)    //做个冒泡排序后输出打印到控制台，可以更直观
    
27.             {
    
28.                  for (int j = 0; j < a.Length-i-1; j++)
    
29.                  {
    
30.                      if (a[j] > a[j + 1])
    
31.                      {
    
32.                          int temp = a[j];
    
33.                          a[j] = a[j + 1];
    
34.                          a[j + 1] = temp;
    
35.                      }
    
36. 
    
37.                  }
    
38.              }
    
39.                  for (int j = 0; j < a.Length; j++)   //遍历打印
    
40.                 {
    
41.                      Console.WriteLine(a[j]);
    
42.                  }
    
43.              Console.WriteLine("============================");
    
44.              Console.WriteLine(a.Length);
    
45.              Console.ReadKey();
    
46. 
    
47.          }
    
48.      }
    
49. }

复制代码

怎么不用代码段 这样看着不是更加清晰了么？

向晓伟 发表于 2014-7-30 17:34
int[] array = new int[100];
            Random ran = new Random();
            for (int  ...

int num = ran.Next(1,100);
这个随机数的范围是 1~99 吧  ，  不会产生100
好像填充数组也有问题  而且重复了也就过了， 最后得出的可能没有100个数。
不知道我理解得对卟....  有大神在的话 希望能回复下  呵呵

sunnyboyi 发表于 2014-7-30 19:16
int num = ran.Next(1,100);
这个随机数的范围是 1~99 吧  ，  不会产生100
好像填充数组也有问题  而且 ...

你一说才发现真的没有100~而且填充数组的时候还有0.
填充数组的问题是 复制过来的时候这个论坛的格式直接把我array的下标删除了~

u010209195 发表于 2014-7-30 18:03
怎么不用代码段 这样看着不是更加清晰了么？

数组也有Contains方法吗？

二楼的解题无法达到随机数不能重复的目的，三楼是正解。

向晓伟 发表于 2014-7-30 17:34

能不能用，点一下就知道啦~我开始也不知道。点出来的。

liangdmaster 发表于 2014-7-30 20:50
二楼的解题无法达到随机数不能重复的目的，三楼是正解。

事实证明运行之后都是不重复的。

路过 学学习习

不断的重复用contains的话,会有很多多余的循环,可以考虑随机索引,然后把随机到的索引对应的数字移除,这样只要100次循环就可以了

以下是项目中我们用的代码,在一个给定集合中,获取一系列不重复的元素,根据你的需求,第一个参数就是一个1~100之间数字组成的集合,用一个for循环就可以创建出来了,第二个参数是100,第三个参数决定你是否不想更改原来集合元素的顺序,如果选了false,原来集合和返回值是一样的
  /// <summary>
    /// 在一个集合中获取一系列不重复随机数(同一个索引元素不会获取两次,不考虑集合本身元素重复)
    /// </summary>
    /// <param name="sourceList">源集合</param>
    /// <param name="neededCount">需求的数量</param>
    /// <param name="sourceListSafe">是否保留源集合,如果为true,则传入集合不会被更改</param>
    /// <returns></returns>
    public static List<int> GetNoRepeatList(List<int> sourceList, int neededCount, bool sourceListSafe)
    {
        List<int> result = new List<int>();
        if (neededCount > sourceList.Count)
        {
            Debug.LogError("需求的数量超出原始集合长度,请确认参数");             return null;
        }
        List<int> copyList = sourceListSafe ? CopyList(sourceList) : sourceList;
        int index;
        for (int i = 0; i < neededCount; i++)
        {
            index = Random.Range(0,  copyList.Count);
            result.Add(copyList[index]);
            copyList.RemoveAt(index);   //移除随机到的元素
        }
        return result;
    }

  /// <summary>
    /// 获取一个集合的浅拷贝副本
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="sourceList"></param>
    /// <returns></returns>
    public static List<T> CopyList<T>(List<T> sourceList)
    {
        List<T> result = new List<T>();
        for (int i = 0; i < sourceList.Count; i++)
        {
            result.Add(sourceList);
        }
        return result;
    }

总结的不错，值得学习

为爱编程 发表于 2014-7-30 20:25
数组也有Contains方法吗？

有啊。。

u010209195 发表于 2014-8-1 11:36
有啊。。

是c#吧               

学习了，刚好在复习Contains 这个，嘿嘿，