274997322 发表于 2013-6-21 22:47
FileStream fs = new FileStream(@"text.txt", FileMode.Open, FileAccess.Read);//把txt文件放到Debug ...

这个肯定不行吧！你没发现最后一个ip的前面和前几个的不一样么

高腾 发表于 2013-6-22 09:29

貌似不行，最后一个ip和前面的形式不一样~~~~~

看看学习一下

关关雎鸠 发表于 2013-6-22 11:30
我写了一个，这个题目还是有点意思的。。

效果图：

不成啊，这个把文件的原意都给改了，你看看截图，是61.53和61.54比较

{:soso_e140:}楼上的想法都不好。。都只能解决当前的问题。。给你任意的IP 让你排序 你们的方法都不行。
正确的想法：Ip地址格式为：a.b.c.d
每个数字范围在0~255之间 那么我们可以把它们看成一个四位的256进制数
然后转换成十进制 =a*256^3+b*256^2+c*256^1+d*256^0
然后根据对应的十进制大小排序就OK了。。

曾大鹏 发表于 2013-6-23 16:35
楼上的想法都不好。。都只能解决当前的问题。。给你任意的IP 让你排序 你们的方法都不行。
正 ...

a*256^3+b*256^2+c*256^1+d*256^0
这个看不太懂，能再解释一下么？^是开方的意思么？
还有6楼的方法能解决任意IP排序的问题

wanghuailin1030 发表于 2013-6-24 09:17
a*256^3+b*256^2+c*256^1+d*256^0
这个看不太懂，能再解释一下么？^是开方的意思么？
还有6楼的方法能解 ...

多少次放的意思。。
举个例子 比如说二进制100装10进制
=1*2^2+0*2^1+0*2^0=4

哥们，面试怎么样啊，我后天面试，能给我介绍一下么，我qq
940969973

曾大鹏 发表于 2013-6-24 10:41
多少次放的意思。。
举个例子 比如说二进制100装10进制
=1*2^2+0*2^1+0*2^0=4

Ok，我明白了，若果用十进制就更好理解了，开了几次方就分别是个十百千位。
至于怎么实现，我在实践一下

曾大鹏 发表于 2013-6-23 16:35
楼上的想法都不好。。都只能解决当前的问题。。给你任意的IP 让你排序 你们的方法都不行。
正 ...

你看看我实现的源码，不知道什么原因，转换进制时算出来的数和实际的数差个一两百
namespace temp
{
    class Program
    {
        //把一下IP地址存入一个TXT文件，编写程序把这些IP按数值大小，从小到大排序并打印出来IP地址排序文件操作
//61.52.231.245
//60.54.231.9
//61.54.234.246
//61.54.231.48
//60.53.231.249
        static void Main(string[] args)
        {
            FileStream fs = new FileStream(@"text.txt", FileMode.Open, FileAccess.Read);//把文件方法放在debug里
            StreamReader sr = new StreamReader(fs, Encoding.Default);

            ArrayList strIP = new ArrayList();

            while (sr.Peek() >= 0)
            {  //读到最后一行            
                strIP.Add(sr.ReadLine());
            }
            sr.Close();
           int[] temp = new int[5];
            for (int i = 0; i < strIP.Count; i++)
            {
                string[] p = strIP.ToString().Split('.');
                for(int j=0;j<p.Length;j++)
                {
                    //Console.WriteLine(60 * 256 ^ 3 + 53 * 256 ^ 2 + 231 * 256 ^ 1 + 249 * 256 ^ 0);
                    temp += (int.Parse(p[j])) * (256 ^ (p.Length - 1 - j));
                }
            }

            for (int i = 0; i < strIP.Count; i++)
            {
                Console.WriteLine(temp);
                Console.WriteLine(strIP);
            }
            Console.WriteLine();
            for (int i = 0; i < strIP.Count-1; i++)
            {
                for (int j = 0; j < strIP.Count-1; j++)
                {
                    if (temp[j] > temp[j+1])
                    {
                        int tempd = temp[j+1];
                        temp[j+1] = temp[j];
                        temp[j] = tempd;

                        string strBu = (string)strIP[j];
                        strIP[j] = strIP[j + 1];
                        strIP[j + 1] = strBu;

                    }
                }
            }

            for (int i = 0; i < strIP.Count; i++)
            {
                Console.WriteLine(temp);
                Console.WriteLine(strIP);
            }
            Console.ReadKey();

        }

    }
}

^   这个东西在程序里是按位异或的意思 。

wanghuailin1030 发表于 2013-6-25 10:03
你看看我实现的源码，不知道什么原因，转换进制时算出来的数和实际的数差个一两百
namespace temp
{

temp += (int.Parse(p[j])) * (256 ^ (p.Length - 1 - j));
这里错了。。
^ 在C#中表示异或,不是次方
计算次方 可以用Math.Pow()函数
改成这样

1. temp[i]=0;
   
2. for(int j=0;j<p.Length;j++)
   
3. {
   
4.   temp[i]=temp[i]*256+int.Parse(p[j]);
   
5. }

复制代码

string path = @"E:\IP地址.txt";
            string[] strs = System.IO.File.ReadAllLines(path,Encoding.Default);
            List<int> numIP = new List<int>();
            string[] strQ = strs[0].Split('.');
            string s = strQ[0] +"."+ strQ[1] +"."+ strQ[2]+".";//取字符串中的相同部分
            for (int i = 0; i < strs.Length; i++)
            {
                numIP.Add(Convert .ToInt32 ( strs[i].Split ('.')[3]));
            }
            for (int i = 0; i < numIP.Count; i++)//比较最后一位的大小
            {
                for (int j = i; j < numIP.Count; j++)
                {
                    if (numIP[i] > numIP[j])
                    {
                        int temp = numIP[i];
                        numIP[i] = numIP[j];
                        numIP[j] = temp;
                    }
                }
                Console.WriteLine(s + numIP[i].ToString());//输出结果
            }
            

1. static void Main(string[] args)
   
2.         {
   
3.             string[] str = File.ReadAllLines("IP地址.txt", Encoding.Default);
   
4.             for (int i = 0; i < str.Length - 1; i++)
   
5.             {
   
6.                 for (int j = 0; j < str.Length - 1; j++)
   
7.                 {
   
8.                     if (ToNumber(str[j]) > ToNumber(str[j + 1]))
   
9.                     {
   
10.                         string strBu = str[j];
    
11.                         str[j] = str[j + 1];
    
12.                         str[j + 1] = strBu;
    
13.                     }
    
14.                 }
    
15.             }
    
16.             for (int i = 0; i < str.Length; i++)
    
17.             {
    
18.                 Console.WriteLine(str[i]);
    
19.             }
    
20.             Console.ReadKey();
    
21.         }
    
22.         /*Ip地址格式为：a.b.c.d
    
23.         每个数字范围在0~255之间 那么我们可以把它们看成一个四位的256进制数
    
24.         然后转换成十进制 =a*256^3+b*256^2+c*256^1+d*256^0
    
25.         然后根据对应的十进制大小排序就OK了。。*/
    
26.         private static int ToNumber(string str)
    
27.         {
    
28.             string[] p = str.Split('.');
    
29.             int sum = 0;
    
30.             for (int i = 0; i < p.Length; i++)
    
31.             {
    
32.                 sum = sum * 256 + int.Parse(p[i]);
    
33.             }
    
34.             return sum;
    
35.         }

复制代码

逆_水_寒 发表于 2013-6-21 21:37
这是一个TXT文本，并且是一行一行写的，用  Line 能读出 “/r/n”，一行一行读出来放入数组再遍历吧。
第九 ...

哪个第九天的基础视频啊，能再说细一些吗，这道题不会做。。。

曾大鹏 发表于 2013-6-26 21:57

你的想法很精妙，不知道你是怎么得来的这个思路。另外，你的第一步冒泡排序的内层循环可以再优化下，可以这么写for (int j = 0; j < str.Length - 1- i ; j++)

蔡志涛 发表于 2013-7-3 16:35
你的想法很精妙，不知道你是怎么得来的这个思路。另外，你的第一步冒泡排序的内层循环可以再优化下，可以 ...

差别也不大。

曾大鹏 发表于 2013-7-3 16:49
差别也不大。

排序好了的  可以不用再比较了

曾大鹏 发表于 2013-6-26 21:57

网上看到的一种写法：用移位操作，将ip地址转换为long型整数，排序后，再将long整数转为string。
不过这里移位后累加，最后得出一个long整数的原理不太明白，还想请教一下。
代码：

1. #region IP地址转换为long型整数
   
2.         public static long ip2long(string strIP)
   
3.         {
   
4.             IPAddress ip = IPAddress.Parse(strIP);
   
5.             int x = 3;
   
6.             long o = 0;
   
7.             foreach (byte f in ip.GetAddressBytes())
   
8.             {
   
9.                 o += (long)f << 8 * x--;
   
10.             }
    
11.             return o;
    
12.         }
    
13.         #endregion
    
14. 
    
15.         #region long型整数转换为IP地址
    
16.         public static string long2ip(long l)
    
17.         {
    
18.             var b = new Byte[4];
    
19.             for (int i = 0; i < 4; i++)
    
20.             {
    
21.                 b[3 - i] = (byte)(l >> 8 * i & 255);
    
22.             }
    
23.             return new IPAddress(b).ToString();
    
24.         }
    
25.         #endregion

复制代码

曾大鹏 发表于 2013-6-26 21:57

你的string[] str = File.ReadAllLines("IP地址.txt", Encoding.Default);最后一个Encoding.Default是什么意思啊