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

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

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

最终代码

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. }

复制代码

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

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

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

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

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

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

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

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

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

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

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

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

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

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

说下我的思路，可以判断任意奇数个数的数字是否连续。
这里简化一下，对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.         }

复制代码