【转】一道笔试题的解法和联想

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量94 收藏
点赞数
文章标签： 数据结构与算法 c#
原文链接：http://www.cnblogs.com/kangtr/archive/2008/08/24/1274940.html
版权
转自： http://www.cnblogs.com/nuaalfm/archive/2008/08/23/1274868.html



原题是这样的，请用C#编写一个可以对任意类型进行冒泡排序算法，我们先看一个整型的冒泡排序来了解一下冒泡排序：

 

ContractedBlock.gif ExpandedBlockStart.gif 整型冒泡排序
static void Main(string[] args)
        {
            int[] array = { 9,8,2,6,5,4,3,7,1};
            BubleSort(array);
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
        }
        static void BubleSort(int[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = 0; j < array.Length-i-1; j++)
                {
                    if (array[j] > array[j + 1])
                    {
                        int temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }

 

这个题其实考的重点并不在冒泡排序（当然不懂冒泡排序肯定不行），而是考一种抽象能力，对于冒泡排序来说，任意类型排序他们共同的东西就是冒泡排序的思想，而不同的部分在比较上，所以我们就要想一种方法将变化的部分和不变的部分隔离开，我们首先想到的方法是使用接口，下边是一种解法：

 

ContractedBlock.gif ExpandedBlockStart.gif 接口实现1
public interface IArray
    {
        bool Compare(IArray IA);
    }
    public class Employee:IArray
    {
        public Employee(int age)
        {
            this.Age = age;
        }
        public int Age { get; set; }
        public bool Compare(IArray IA)
        {
            return this.Age>((Employee)IA).Age;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Employee[] array = { new Employee(23),new Employee(20),new Employee(19),new Employee(30)};
            BubleSort(array);
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i].Age);
            }
        }
        static void BubleSort(IArray[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = 0; j < array.Length-i-1; j++)
                {
                    if (array[j].Compare(array[j + 1]))
                    {
                        IArray temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }
    }

 

这个解法可以应对更多的类型排序，只要这些需要排序的类型都实现IArray接口就可以了，但是问题是如果这样，这个排序算法又不支持整型了，我们总不能为了这个排序算法重新封装一下整型吧。我们得继续寻找办法，于是我们想到了系统的一个接口IComparable，这个接口定义通用的比较方法，由值类型或类实现以创建类型特定的比较方法。系统自定义类型几乎都实现了这个接口，所以只要自定义类也实现这个接口就可以利用到这里了，代码如下：

 

ContractedBlock.gif ExpandedBlockStart.gif 接口实现2
class Program
    {
        static void Main(string[] args)
        {
            //Employee[] array = { new Employee(23),new Employee(20),new Employee(19),new Employee(30)};
            IComparable[] array = { 9, 8, 2, 6, 5, 4, 3, 7, 1 };
            BubleSort(array);
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
        }
        static void BubleSort(IComparable[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = 0; j < array.Length-i-1; j++)
                {
                    if (array[j].CompareTo(array[j + 1])>0)
                    {
                        IComparable temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }
    }

 

现在基本符合题意了，但看起来好像还不是好的解决方案，因为每个类型都要实现IComparable仍然是个限制，那如何打破这个限制呢，仔细想想，我们想出另外一个解决方案，就是想办法把比较方式封装起来，然后调用排序函数时传进来不就成了么。

 

ContractedBlock.gif ExpandedBlockStart.gif 接口实现3
class IntCompare:IComparer<int>
    {
        public int Compare(int x, int y)
        {
            return x.CompareTo(y);
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            //Employee[] array = { new Employee(23),new Employee(20),new Employee(19),new Employee(30)};
            int[] array = { 9, 8, 2, 6, 5, 4, 3, 7, 1 };
            BubleSort<int>(array,new IntCompare());
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
        }

        static void BubleSort<T>(T[] array,IComparer<T> compare)
        {
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = 0; j < array.Length-i-1; j++)
                {
                    if (compare.Compare(array[j], array[j + 1]) > 0)
                    {
                        T temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }
    }

 

大家可能觉得这个和上一个方案很象阿，不都要实现一个接口么，其实后一个方案中的最大优点在于你自定义类不用继承任何接口了，我们想一下，为了让某个类型支持这个冒泡排序而去实现一个接口是很牵强的。那这个是不是最好的解决方案呢，我们本着不撞南墙不回头的原则继续前进，这个接口好像用委托也可以实现吧，那写个版本先：

 

ContractedBlock.gif ExpandedBlockStart.gif 委托实现
class Program
    {
        static void Main(string[] args)
        {
            //Employee[] array = { new Employee(23),new Employee(20),new Employee(19),new Employee(30)};
            int[] array = { 9, 8, 2, 6, 5, 4, 3, 7, 1 };
            BubleSort<int>(array, CompareMethod);
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
        }
        static bool CompareMethod(int t1, int t2)
        {
            return t1 > t2;
        }
        delegate bool Compare<T>(T t1, T t2);
        static void BubleSort<T>(T[] array, Compare<T> compare)
        {
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = 0; j < array.Length-i-1; j++)
                {
                    if (compare(array[j], array[j + 1]))
                    {
                        T temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }
    }

 

似乎也没有什么改进，还要写多写一个方法，但是这个委托版本已经基本接近我们的答案了，下面我们使用Lambda表达式来实现我认为的最优的答案（这个答案中需要大家了解Lambda表达式，范型以及Func委托）：

 

ContractedBlock.gif ExpandedBlockStart.gif Lambda表达式实现
class Program
    {
        static void Main(string[] args)
        {
            //Employee[] array = { new Employee(23),new Employee(20),new Employee(19),new Employee(30)};
            int[] array = { 9, 8, 2, 6, 5, 4, 3, 7, 1 };
            BubleSort<int>(array, (a,b)=>a>b);
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
        }
        static void BubleSort<T>(T[] array, Func<T,T,bool> compare)
        {
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = 0; j < array.Length-i-1; j++)
                {
                    if (compare(array[j], array[j + 1]))
                    {
                        T temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }
    }

转载于:https://www.cnblogs.com/kangtr/archive/2008/08/24/1274940.html

anmi5580
关注
sort函数的用法(C++排序库函数的调用)
weixin_30680385的博客
01-11 1142
对数组进行排序，在c++中有库函数帮我们实现，这们就不需要我们自己来编程进行排序了。 （一）为什么要用c++标准库里的排序函数 Sort（）函数是c++一种排序方法之一，学会了这种方法也打消我学习c++以来使用的冒泡排序和选择排序所带来的执行效率不高的问题！因为它使用的排序方法是类似于快排的方法，时间复杂度为n*log2(n)，执行效率较高！ （二）c++标准库里的排序函数的使用方法 I）...
微软谷歌百度等精选100笔试题
zhanjianshinian的专栏
06-20 2148
http://blog.csdn.net/v_JULY_v/article/details/6057286   1.把二元查找树转变成排序的双向链表（树）  题目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。    10   / /   6  14  / / / / 4  8 12 16  转换成双向链表
一道笔试题的解法和联想
weixin_33831196的博客
08-23 88
(注：这里只是想通过排序算法来描述一下抽象的过程，所以大家不要太关注于数组的排序) 作者：方明 原题是这样的，请用C#编写一个可以对任意类型进行冒泡排序算法，我们先看一个整型的冒泡排序来了解一下冒泡排序：   整型冒泡排序 static void Main(string[] args)         {             int[] array = { 9,8,2,6,5,4...
将一个字符串转换为数字，返回值用来校验转换是否成功 bool strtoi(const char *, int &)
爱上小公举
08-26 343
将一个字符串转换为数字，返回值用来校验转换是否成功 bool strtoi(const char *, int &) #define _CRT_SECURE_NO_WARNINGS #include<iostream> using namespace std; //将一个字符串转换为数字，返回值用来校验转换是否成功 bool strtoi(const char*...
Kuangbin专题十匹配问题
叶子心情你不懂
10-07 4131
套班子灾区、、、板子在手天下我有、、、 A - Fire Net  HDU - 1045 Suppose that we have a square city with straight streets. A map of a city is a square board with n rows and n columns, each representing a street or a p...
C++重载：const char *类型参数被匹配为bool类型参数的函数，导致行为异常
KingOfMyHeart的博客
03-19 1332
现象： 实现了一个接口类，包含了类似以下的接口： class { public: void Set(const std::string&value); void Set(const int&value); void Set(const double&value); void Set(const bool&value); }; 当我在程序中调用该方法时，发现，最终匹配竟是bool类型的重载版本： Set("value"); 分析： 分析一下过程： “value”
2023秋招笔试题记录-自用
weixin_45485072的博客
08-21 5779
因此对于长度为n的序列，最后的结果只有2种可能。小美定义一个 01 串的权值为：每次操作选择一位取反，使得相邻字符都不相等的最小操作次数。例如，"10001"的权值是 1，因为只需要修改一次：对第三个字符取反即可。一个仅包含’0’和’1’的字符串，长度不超过 2000。长度为 2 的子串中，有 2 个"00"的权值是 1。长度为 3 的 3 个子串权值都是 1。长度为 4 的 2 个子串权值都是 1。长度为 5 的 1 个子串权值是 1。总权值之和为 2+3+2+1=8。所有非空子串的权值和。
运用模逆运算（同余方程）来解决Matlab课上的一道思考题
bandilan2400的博客
03-10 1625
一道Matlab编程题 &暴力解法 Matlab课上老师出了这样一道题： 一个篮子有K个鸡蛋： 2个2个拿剩1个； 3个3个全部拿完； 4个4个拿剩1； 5个5个拿剩4个； 6个6个拿剩3个； 7个7个拿全部拿完； 8个8个拿剩1个； 9个9个拿全部拿完； 求篮子里鸡蛋的个数K 虽然这是一道matlab拿来玩的题目，可是我觉得完全...
总结了200道经典的机器学习面试题（附参考答案）
small-guo
07-01 7634
刷题，是面试前的必备环节。本文总结了往年BAT机器学习面试题，干货满满，值得收藏。想要入职大厂可谓是千军万马过独木桥。为了通过层层考验，刷题肯定是必不可少的。本文根据网络在线发布的BAT机器学习面试1000题系列，整理了一份面试刷题宝典。1.请简要介绍下SVM。SVM，全称是support vector machine，中文名叫支持向量机。SVM是一个面向数据的分类算法，它的目标是为确定一个分类超平面，从而将不同的数据分隔开。扩展：支持向量机学习方法包括构建由简至繁的模型：线性可分支持向量机、线性支持向量机
微软的100道算法面试题（终结版）
Java进阶之路
08-29 4363
前言 数据结构与算法的重要性已不言而喻，最近，我整理出十大经典排序算法、五大常用算法总结，今天特意整理出微软面试的100题，若有不足之处，欢迎指正！由于篇幅过长，前30道题目写在上一篇，大家可以进我的个人主页浏览，之后我会抽时间争取把数据结构与算法做成一个系列，敬请期待！ 31、和为n 连续正数序列 题目：输入一个正数n，输出所有和为n 连续正数序列。 例如输入15，由于1+2+3+4...
数据结构面试100题
热门推荐
hehuanlin123的博客
04-08 2万+
引言      无私分享造就开源的辉煌。      今是二零一一年十月十三日，明日14日即是本人刚好开博一周年。在一周年之际，特此分享出微软面试全部100题答案的完整版，以作为对本博客所有读者的回馈。      一年之前的10月14日，一个名叫July （头像为手冢国光）的人在一个叫csdn的论坛上开帖分享微软等公司数据结构+算法面试100题，自此，与上千网友一起做，一起思考
数据结构+算法面试100题~~~摘自CSDN，作者July
janvinal的专栏
10-18 1689
1.把二元查找树转变成排序的双向链表（树） 题目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 10 / / 6 14 / / / / 4 8 12 16 转换成双向链表 4=6=8=10=12=14=16。 首先我们定义的二元查找树 节点的数据结构如下： struct BSTreeNode { int
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 132
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
HJ51输出单向链表中倒数第k个结点
晴山の博客
10-29 303
HJ51输出单向链表中倒数第k个结点。
查找算法简记
well_fly的博客
10-30 607
简单记录查找算法相关知识点
C++算法第五天
2302_80418176的博客
10-31 1052
1. 首这个解法叫滑动窗口，本质是同向双指针2. 使用这个解法的原因是利用了单调性3.滑动窗口的正确性：利用的单调性，规避了没必要的枚举行为4.枚举二字算是在博主的文章中第一次出现，那么我也解释枚举是什么意思，枚举就是将每一种情况都一一列举出来。
实习冲刺Day11
2301_78814687的博客
11-02 276
c++中字符串有两种存储方式，一种是存储在char[]数组中，一种是存储在c++封装的string类中。在C中也可以使用字符指针来访问一个字符串,通过字符指针指向存放字符串数组的首元素地址来进行访问.在C中，并没有字符串这个数据类型，而是使用。char[]来保存字符串。二叉树的先序遍历根左右。二叉树的后序遍历左右根。
Java实现常见算法笔试题解法精选
这个项目可能包括一系列的Java类和方法，每个都对应一个或多个常见的笔试题。该项目可能是按照不同问题类型或难度等级组织的，比如数组相关问题、链表操作、字符串处理、二叉树遍历、图的搜索和遍历算法等。 知识点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值