我的想法：
先将这5个数字放入一个数组num。
设定个bool类型的flag，初值为true。
将冒泡排序算法稍微改动下。添加“==”判断，若有任意两个元素相等，则把flag改为false，且break掉冒泡排序的循环。
冒泡排序结束后，先判断flag，如果为false，则5个数不连续。
如果flag为true，在判断num[4]-num[0]==4。如果成立，则5个数字连续，如果大于4，则5个数字不连续。
过段时间想代码贴过来

大家还有什么别的想法么？

说下我的思路，可以判断任意奇数个数的数字是否连续。
这里简化一下，对5个数字来说，求出平均数average，
那么肯定有一个数和average相等。
依次判断，如果5个数都和average不相等，那么5个数不连续。
5个数依次减去average的结果肯定是-2，-1，0，1,2五个数，当然可以乱序。
5个差值放在list中，依次移除实际5个数与average的差值，如果list中的成员全部移除，那么5个数才是连续的，否则不连续。代码如下

1. int[] numbers = { 5, 2, 3, 4, 1 }; //简化起见，没让用户手动输入。
   
2.             double avr = 1.0*numbers.Sum() / 5; //5个数的平均数，那么这个平均数肯定得跟5个数中的一个数相等。
   
3.             bool xx = true ;
   
4.             foreach (int n in numbers)
   
5.                 if (avr == n)
   
6.                     xx = false;     //找到相等数，设置xx为false，，找不到则xx一直未true
   
7.             if (xx)   //xx为true的时候，说明肯定不连续。
   
8.             {
   
9.                 Console.WriteLine("不连续");
   
10.                 Console.ReadKey();
    
11.                 return;
    
12.             }
    
13.             //接下来  ，5个与平均数的差值为-2，-1,0，-1，-2
    
14.             List<int> request = new List<int>() { -2, -1, 0, 1, 2 };
    
15. 
    
16.             foreach (int n in numbers)  
    
17.             {
    
18.                 request.Remove(n - (int)avr);  //每次移除一个差值，如果是连续的，那么request的5个成员应该被全部移除
    
19.             }
    
20.             Console.WriteLine(request.Count);
    
21.             if (request.Count != 0)       //如果此时还有成员，说明之前的5个数不连续。
    
22.             {
    
23.                 Console.WriteLine("不连续");
    
24.                 Console.ReadKey();
    
25.                 return;
    
26.             }
    
27.             Console.WriteLine("连续");
    
28.             Console.ReadKey();
    
29.         }

复制代码

LZ你的题目不太清楚；倘若是想，1,2,3,4,5这样的连续的话可以这样判断，这样的话可以考虑一下等差数列的判断方法。
我是这样想的
1：先用冒泡排序
2：再用最大的数减去最小的数再加1，判断是否等于数组长度，如果相等则是连续的，反之不是。
这个题目LZ确实给的不太清楚；

还记得等差数列的求和公式么，先把这五个数相加，再与数列相加的结果比较：
for (int i = 0; i < array.Length; i++)
            {
                sum += array[i];
            }
            if (sum == (array.Length * (array[0] + array[array.Length - 1]) / 2))
            {
                Console.WriteLine("这五个数是连续的");
            }
如果两者相等，证明这五个数是连续的。

黄晓波 发表于 2013-10-2 19:41
嗯，只是排序比较费时间些

目前只会冒泡排序，以后会学习下其他排序的

黄晓波 发表于 2013-10-2 19:41
嗯，只是排序比较费时间些

目前只会冒泡排序，以后会学习下其他排序的

熊丽 发表于 2013-10-8 17:15
你的想法肯定是错误的，如 1,4,3,2,5

你自己去试试嘛，把代码贴上，然后你输入这5个数字，肯定结果是连续啊。

你的想法肯定是错误的，如 1,4,3,2,5

大虾挂了 发表于 2013-10-2 19:37
我上面贴的那段代码基本就是这个思路，只不过我那里是排序和检测重复是同时进行的，如果检测到重复就没必 ...

嗯，只是排序比较费时间些

黄晓波 发表于 2013-10-2 19:23
1、将5个数存数组num中
2、num数组的最大值与最小值之差为4？做下一步判断：数组num中的5个数字不是连续的
...

我上面贴的那段代码基本就是这个思路，只不过我那里是排序和检测重复是同时进行的，如果检测到重复就没必要在进行排序了。没有检测到重复的情况下再用排序后的数组最后一个数减第一个数观察是否为4

1、将5个数存数组num中
2、num数组的最大值与最小值之差为4？做下一步判断：数组num中的5个数字不是连续的
3、数组num中是有重复数字？不是连续的：是连续的

最终代码

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Linq;
   
4. using System.Text;
   
5. using System.Threading.Tasks;
   
6. 
   
7. namespace 判断输入数字是否连续
   
8. {
   
9.     class Program
   
10.     {
    
11.         static void Main(string[] args)
    
12.         {
    
13.             int[] num = new int[5];
    
14.             string[] adr = new string[] {"第一","第二","第三","第四","最后一" };
    
15.             int j;
    
16.             bool flag1=false,flag2=false;//分别用于判定是否有换位和是否有相同数字
    
17. 
    
18.             Console.WriteLine("请输入5个数字，用回车间隔");
    
19.             
    
20.             //读取用户输入的5个数字
    
21.             for (int i = 0; i < 5; i++)
    
22.             {
    
23.                 Console.WriteLine("请输入{0}个数字，回车确认", adr[i]);
    
24.                 num[i] = Convert.ToInt32(Console.ReadLine());
    
25.             }
    
26. 
    
27.             //代码的核心部分，冒泡排序算法中添加相等判定
    
28.             for (int i = 0; i < num.Length - 1; i++)
    
29.             {
    
30.                 flag1 = false; //每次循环将换位标识重置
    
31.                 for (j = 0; j < num.Length - i - 1; j++)
    
32.                 {
    
33.                     if (num[j] > num[j + 1])
    
34.                     {
    
35.                         num[j] = num[j] ^ num[j + 1];
    
36.                         num[j + 1] = num[j] ^ num[j + 1];
    
37.                         num[j] = num[j] ^ num[j + 1];
    
38.                         flag1 = true; //若有换位，则将换位标识设置为true
    
39.                     }
    
40.                     if (num[j] == num[j + 1]) //相等判定部分
    
41.                     {
    
42.                         flag2 = true;
    
43.                         break; //若有相等元素应直接跳出整个冒泡排序，避免使用goto而采取两次break跳出两次循环
    
44.                     }
    
45.                 }
    
46.                 if (flag2 == true)
    
47.                     break; //判定有相等元素，跳出冒泡排序
    
48.                 if (flag1 == false)
    
49.                     break;
    
50.             }
    
51. 
    
52.             if(flag2==true) //有相等元素必然不连续
    
53.                 Console.WriteLine("不连续");
    
54.             else if(num[4]-num[0]==4) //没有相等元素的话，最大元素和最小元素差4则必然连续
    
55.                 Console.WriteLine("连续");
    
56.             else  //否则不连续
    
57.                 Console.WriteLine("不连续");
    
58.             
    
59.             //foreach(int i in num)
    
60.             //    Console.WriteLine(i);
    
61. 
    
62.             Console.ReadKey();
    
63.         }
    
64.     }
    
65. }

复制代码

帕格尼尼的眼泪 发表于 2013-10-1 00:44
大哥你那个是冒泡么，就算是效率超低的，因为你每次排好的你还进行比较，那样重复了。
下面的是冒泡排序
...

你楼上说的我没太看懂，你在说谁用的不是冒泡排序啊，我也没说他们谁是冒泡排序啊。我说我的想法是用冒泡排序稍微改动下实现。你这个确实是冒泡排序，不过可以添加个是否有换位的判定再优化一点。
我下面贴下最后的代码。

先用console.readline读取字符串，放入字符数组中，遍历这个数组，判断这个字符是否属于ascii中数字的范围（ascii中数字值是连续的）。

guo329838627 发表于 2013-9-30 22:06
连续的，不要意思，没看懂你题，你可以这么的，先用冒泡从小到大排序，然后比就行了，你看下我写的代码： ...

大哥你那个是冒泡么，就算是效率超低的，因为你每次排好的你还进行比较，那样重复了。
下面的是冒泡排序
for (int i = 0; i < num.Length - 1; i++)
{
           for (int j =  num.Length-1-i; j >i; j--)
                    {
                             if (num[j] < num[j-1])
                              {
                                      int  temp=num[j];
                                      num[j]= num[j-1];                                                                          
                                      num[j-1]=temp;
                               }
                     }
}

段朝骞 发表于 2013-9-30 17:53
先从小到大排序，再计算相邻两数的差值是否为1
可以使用
for(int i = 0; i

说的是思路，不是具体实现

static void Main(string[] args)
        {
            //Mp3 M = new Mp3();
            //M.Playe += new Delegate(M_Playe);
            //M.start();
            //Console.Read();


            int[] num = new int[] { 6, 3, 4, 2, 5 };
            Array.Sort(num);
            Console.WriteLine(Is(num));
            Console.Read();
            
         }
         private static bool Is(int[] num)
         {
              for (int i = 0; i < num.Length - 1; i++)
              {
                   if (num[i] + 1 != num[i+1])
                    {
                        return false;
                    }
              }
              return true;
          }

int[] num = new int[]{a,b,d,e,f};
for(int i=0;i<4;i++)
{
for(int j=i+1;j<=4;j++)
{
if(num[i]==num[j]||(num[i]-num[j])>4)
{
return false;
}
}
}
return true;

大虾挂了 发表于 2013-9-30 20:42
你这个没懂我题的意思啊，我的意思是只要数字是连续的就行，位置无所谓。这里要是给1 3 2 4 0，我要求结 ...

连续的，不要意思，没看懂你题，你可以这么的，先用冒泡从小到大排序，然后比就行了，你看下我写的代码：

1. static void Main(string[] args)
   
2.         {
   
3.             int[] num = new int[]{1,3,2,4,0};
   
4.             bool IsTrue = true;
   
5.             ////冒泡排序
   
6.             for (int i = 0; i < num.Length - 1; i++)
   
7.             {
   
8.                 for (int j = i + 1; j < num.Length; j++)
   
9.                 {
   
10.                     if (num[i] > num[j])
    
11.                     {
    
12.                         int ls;
    
13.                         ls = num[i];
    
14.                         num[i] = num[j];
    
15.                         num[j] = ls;
    
16.                     }
    
17.                 }
    
18.             }
    
19.             //判断
    
20.             for (int i = 0; i <num.Length-1; i++)
    
21.             {
    
22.                 if ((num[i] + 1) != num[i + 1])
    
23.                 {
    
24.                     IsTrue = false;
    
25.                 }
    
26.             }
    
27.             if (!IsTrue)
    
28.             {
    
29.                 Console.WriteLine("不连续");
    
30.             }
    
31.             else
    
32.             {
    
33.                 Console.WriteLine("连续");
    
34.             }
    
35.         }

复制代码

将5个数放入数组   判断是否有重复！有 out ！  没有 排序  求相邻两数之差值   看他们的差值是否都相等吧！