阳光男孩

Never give up!

Entries Tagged ‘面试’

华为2012校园招聘上机编程题

1顶一下编程题(共3题,第一题20分,第二题30分,第三题50分,共100分) 注意: 1、请上机编写程序,按题目要求提交文件。[详见考试说明,点击进入考试说明] 2、本试题采用自动执行测试用例进行评分,测试用例不对考生公开 3、评卷通过在给定用例输入下,严格按照试题要求比较考生实现函数的输出与预设输出。两者相同则得分,不同则不得分。 4、评卷人保证测试用例输入参数的合法性,考生不用考虑...[阅读全文]

1
顶一下

编程题(共3题,第一题20分,第二题30分,第三题50分,共100分)
注意:
1、请上机编写程序,按题目要求提交文件。[详见考试说明,点击进入考试说明]
2、本试题采用自动执行测试用例进行评分,测试用例不对考生公开
3、评卷通过在给定用例输入下,严格按照试题要求比较考生实现函数的输出与预设输出。两者相同则得分,不同则不得分。
4、评卷人保证测试用例输入参数的合法性,考生不用考虑输入参数非法或异常的情况
5、评卷人保证测试用例输入在被测函数正常合法情况下使用不会导致程序错误
6、如果考生函数异常导致程序崩溃或死循环,则自动评卷可能会被人为终止,剩余用例不被执行,无法得分

7、基于上述阅卷规则,请考生严格按照题目要求功能实现程序,尽量保证实现函数的稳健性,同时建议完成一道题并调试保证正确性后,再考虑并实现下一题目
1. 手机号码合法性判断(20分)
问题描述:
我国大陆运营商的手机号码标准格式为:国家码+手机号码,例如:8613912345678。特点如下:
 1、  长度13位;
2、  以86的国家码打头;
3、  手机号码的每一位都是数字。
 请实现手机号码合法性判断的函数(注:考生无需关注手机号码的真实性,也就是说诸如86123123456789这样的手机号码,我们也认为是合法的),要求:
1)  如果手机号码合法,返回0;
2)  如果手机号码长度不合法,返回1
3)  如果手机号码中包含非数字的字符,返回2;
4)  如果手机号码不是以86打头的,返回3;
【注】除成功的情况外,以上其他合法性判断的优先级依次降低。也就是说,如果判断出长度不合法,直接返回1即可,不需要再做其他合法性判断。
要求实现函数:
int s int verifyMsisdn(char* inMsisdn)
【输入】 char* inMsisdn,表示输入的手机号码字符串。
【输出】  无
【返回】  判断的结果,类型为int。
示例
输入:  inMsisdn = “869123456789“
输出:  无
返回:  1
输入:  inMsisdn = “88139123456789“
输出:  无
返回:  3
输入:  inMsisdn = “86139123456789“
输出:  无
返回:  0

int verifyMsisdn(char* inMsisdn)  
{  
    if(strlen(inMsisdn) != 13)  
        return 1;  
  
    char *p = inMsisdn;  
    while(*p != ’\0′)  
    {  
        if((*p < ’0′) || (*p > ’9′))  
            return 2;  
        p++;  
    }  
  
    p = inMsisdn;  
    if(*p != ’8′ || *(++p) != ’6′)  
        return 3;  
  
    return 0;  
  
}  

int verifyMsisdn(char* inMsisdn) { if(strlen(inMsisdn) != 13) return 1; char *p = inMsisdn; while(*p != ‘\0′) { if((*p < ’0′) || (*p > ’9′)) return 2; p++; } p = inMsisdn; if(*p != ’8′ || *(++p) != ’6′) return 3; return 0; }

 

2. 将一个字符串的元音字母复制到另一个字符串,并排序(30分)
问题描述:
有一字符串,里面可能包含英文字母(大写、小写)、数字、特殊字符,现在需要实现一函数,将此字符串中的元音字母挑选出来,存入另一个字符串中,并对字符串中的字母进行从小到大的排序(小写的元音字母在前,大写的元音字母在后,依次有序)。
 说明:
1、  元音字母是a,e,i,o,u,A,E,I,O,U。
2、  筛选出来的元音字母,不需要剔重;
 最终输出的字符串,小写元音字母排在前面,大写元音字母排在后面,依次有序。
 要求实现函数:
void sortVowel (char* input, char* output);
【输入】  char* input,表示输入的字符串
【输出】  char* output,排好序之后的元音字符串。
【返回】  无
 示例
输入:char *input = “Abort!May Be Some Errors In Out System. “
输出:char *output =“aeeeooAEIO “

void sortVowel (char* input, char* output)  
{  
    size_t len = strlen(input) + 1;  
    char *pDa = new char[len];  
    char *pXiao = new char[len];  
    char *pIN = input;  
  
    int i = 0, j = 0;  
    while(*pIN  != ’\0′)  
    {  
        if(*pIN  == ’A' ||*pIN  == ’E' ||*pIN  == ’I' ||*pIN  == ’O' ||*pIN  == ’U')  
        {  
            pDa[i++] = *pIN ;  
        }  
  
        if(*pIN  == ’a' || *pIN  == ’e' ||*pIN  == ’i' ||*pIN  == ’o' ||*pIN  == ’u')  
        {  
            pXiao[j++] = *pIN;  
        }  
  
        pIN ++;  
    }      
    pDa[i] = ’\0′;  
    pXiao[j] = ’\0′;  
  
    size_t len_da = strlen(pDa);  
    size_t len_xiao = strlen(pXiao);  
  
    for(int i = 0; i < len_da - 1; i++)  
    {  
        for(int j = 0; j < len_da - 1 - i; j++)  
        {  
            if(pDa[j] > pDa[j + 1])  
            {  
                char temp;  
                temp = pDa[j + 1];  
                pDa[j + 1] = pDa[j];  
                pDa[j] = temp;  
            }  
        }  
    }  
  
    for(int i = 0; i < len_xiao - 1; i++)  
    {  
        for(int j = 0; j < len_xiao - 1 - i; j++)  
        {  
            if(pXiao[j] > pXiao[j + 1])  
            {  
                char temp;  
                temp = pXiao[j + 1];  
                pXiao[j + 1] = pXiao[j];  
                pXiao[j] = temp;  
            }  
        }  
    }  
  
    int k = 0;  
    for(int i = 0; i < len_xiao; i++)  
    {  
        output[k++] = pXiao[i];  
    }  
  
    for(int i = 0; i < len_da; i++)  
    {  
        output[k++] = pDa[i];  
    }  
  
    output[k] = ’\0′;  
  
    delete []pDa;  
    delete []pXiao;  
  
}  

void sortVowel (char* input, char* output) { size_t len = strlen(input) + 1; char *pDa = new char[len]; char *pXiao = new char[len]; char *pIN = input; int i = 0, j = 0; while(*pIN != ‘\0′) { if(*pIN == ‘A’ ||*pIN == ‘E’ ||*pIN == ‘I’ ||*pIN == ‘O’ ||*pIN == ‘U’) { pDa[i++] = *pIN ; } if(*pIN == ‘a’ || *pIN == ‘e’ ||*pIN == ‘i’ ||*pIN == ‘o’ ||*pIN == ‘u’) { pXiao[j++] = *pIN; } pIN ++; } pDa[i] = ‘\0′; pXiao[j] = ‘\0′; size_t len_da = strlen(pDa); size_t len_xiao = strlen(pXiao); for(int i = 0; i < len_da – 1; i++) { for(int j = 0; j < len_da – 1 – i; j++) { if(pDa[j] > pDa[j + 1]) { char temp; temp = pDa[j + 1]; pDa[j + 1] = pDa[j]; pDa[j] = temp; } } } for(int i = 0; i < len_xiao – 1; i++) { for(int j = 0; j < len_xiao – 1 – i; j++) { if(pXiao[j] > pXiao[j + 1]) { char temp; temp = pXiao[j + 1]; pXiao[j + 1] = pXiao[j]; pXiao[j] = temp; } } } int k = 0; for(int i = 0; i < len_xiao; i++) { output[k++] = pXiao[i]; } for(int i = 0; i < len_da; i++) { output[k++] = pDa[i]; } output[k] = ‘\0′; delete []pDa; delete []pXiao; }
3. 身份证号码合法性判断
问题描述:
 我国公民的身份证号码特点如下: 
1、     长度为18位;
2、     第1~17位只能为数字;
3、     第18位可以是数字或者小写英文字母x。
4、     身份证号码的第7~14位表示持有人生日的年、月、日信息。
例如:511002198808080111或51100219880808011x。
 请实现身份证号码合法性判断的函数。除满足以上要求外,需要对持有人生日的年、月、日信息进行校验。年份大于等于1900年,小于等于2100年。需要考虑闰年、大小月的情况。所谓闰年,能被4整除且不能被100整除 或 能被400整除的年份,闰年的2月份为29天,非闰年的2月份为28天。其他情况的合法性校验,考生不用考虑。
函数返回值:
1)  如果身份证号合法,返回0;
2)  如果身份证号长度不合法,返回1;
3)  如果身份证号第1~17位含有非数字的字符,返回2;
4)  如果身份证号第18位既不是数字也不是英文小写字母x,返回3;
5)  如果身份证号的年信息非法,返回4;
6)  如果身份证号的月信息非法,返回5;
7)  如果身份证号的日信息非法,返回6(请注意闰年的情况);
【注】除成功的情况外,以上其他合法性判断的优先级依次降低。也就是说,如果判断出长度不合法,直接返回1即可,不需要再做其他合法性判断。
 要求实现函数:
int verifyIDCard(char* input)
【输入】  char* input,表示输入的身份证号码字符串
【输出】  无
【返回】  判断的结果,类型为int
 示例
1) 输入:”511002111222”,函数返回值:1;
2) 输入:”511002abc123456789”,函数返回值:2;
3) 输入:”51100219880808123a”,函数返回值:3;
4) 输入:”511002188808081234”,函数返回值:4;
5) 输入:”511002198813081234”,函数返回值:5;
6) 输入:”511002198808321234”,函数返回值:6;
7) 输入:”511002198902291234”,函数返回值:7;
8) 输入:”511002198808081234”,函数返回值:0;

int verifyIDCard(char* input)  
{  
    if (strlen(input) != 18)  
        return 1;  
  
    for(int i = 0; i < 17;i++)  
    {  
        if(input[i] < ’0′ || input[i] > ’9′)  
            return 2;  
    }  
  
    if(input[17] == ’x' || (input[17] > ’0′ && input[17] < ’9′));  
    else  
        return 3;  
  
    char year[5];  
    year[0] = input[6];  
    year[1] = input[7];  
    year[2] = input[8];  
    year[3] = input[9];  
    year[4] = ’\0′;  
    int year_num = atoi(year);  
    if(year_num <= 1900 || year_num >= 2100)  
        return 4;  
  
    char month[3];  
    month[0] = input[10];  
    month[1] = input[11];  
    month[2] = ’\0′;  
    int month_num = atoi(month);  
    if(month_num > 12 || month_num < 1)  
        return 5;  
  
    char day[3];  
    day[0] = input[12];  
    day[1] = input[13];  
    day[2] = ’\0′;  
    int day_num = atoi(day);  
    if(((year_num % 4 == 0) && (year_num % 100 != 0)) || (year_num % 400 == 0))     // 闰年   
    {  
        if(month_num == 2)  
        {  
            if(day_num < 1 || day_num > 29)  
                return 6;  
        }  
        else if(month_num == 1 || month_num == 3 ||month_num == 5 ||month_num == 7 ||month_num == 8 ||month_num == 10 ||month_num == 12)  
        {  
            if(day_num < 1 || day_num > 31)  
                return 6;  
        }  
        else  
        {  
            if(day_num < 1 || day_num > 30)  
                return 6;  
        }  
    }  
    else        // 不是闰年   
    {  
        if(month_num == 2)  
        {  
            if(day_num < 1 || day_num > 28)  
                return 6;  
        }  
        else if(month_num == 1 || month_num == 3 ||month_num == 5 ||month_num == 7 ||month_num == 8 ||month_num == 10 ||month_num == 12)  
        {  
            if(day_num < 1 || day_num > 31)  
                return 6;  
        }  
        else  
        {  
            if(day_num < 1 || day_num > 30)  
                return 6;  
        }  
    }  
  
    return 0;  
}  

Comments (1)

Java6道经典面试题

1顶一下1、String 与 StringBuffer 的区别, 哪个效率高? 通常情况下, String 是不可变的, 而StringBuffer是可以动态增长的.但String拼接字符串时,编译器会做优化, 因此, 性能不会低. String 与 StringBuffer 都是使用char[] value存储值, 但初始容量不同.因此在编译器不做优化的情况且 StringBuffer 显式指定一个合适的初始值, 避免动态增长, 效率肯定高于 String. String 与 StringBuffer的动态...[阅读全文]

1
顶一下

1、String 与 StringBuffer 的区别, 哪个效率高?

通常情况下, String 是不可变的, 而StringBuffer是可以动态增长的.但String拼接字符串时,编译器会做优化, 因此, 性能不会低.
String 与 StringBuffer 都是使用char[] value存储值, 但初始容量不同.因此在编译器不做优化的情况且 StringBuffer 显式指定一个合适的初始值, 避免动态增长, 效率肯定高于 String.
String 与 StringBuffer的动态增长时, 都是调用的System.arrayCopy(). 因此效率是一致的.

结论: StringBuffer 必须给定一个显式的足够大的容量值, 来避免动态增长, 从而提高效率.

2.、各种排序算法在JAVA中的实现:
快速与归并排序:
Arrays.sort(Object[] , Comparator)

冒泡排序: j=length-1, 交换j, j-1
选择排序: j=length-1, 交换i, j

3 、JAVA 集合类:
Collection
├List : 有序, 可以重复
│├LinkedList : 非同步, 允许null元素, 适合修改
│├ArrayList :非同步, 允许null元素, 适合查询
│├CopyOnWriteArrayList : 写锁
│└Vector : 同步, 不允许null元素
│ └Stack : 后进先出
├Queue : 先进先出(PriorityBlockingQueue 比较特殊)
└Set : 无序, 不重复

Map
├Hashtable 同步, 不允许null元素
├HashMap 非同步, 允许null元素
└WeakHashMap 非同步, 弱引用

Array
存储集合对象内部

结论:
单线程下优先使用更加高效的非同步集合类.
集合类设置初始容量与加载因子.
根据功能选择合适的集合类.

4 、分页
在分页算法中,影响查询速度的关键因素在于返回数据集的大小.

5 、为什么重写equals,必须重写hashcode?
JAVA语言中有一条原则:
同一对象的hashcode必须保持相同.
提高HashMap的性能, 如果 HashMap中 不同对象的 hashcode 相同, 会造成hashcode冲突, 降低效率.
Set 对象会根据 hashcode 来检测重复元素, 如果同一对象的hashcode不同,会造成元素重复.

6 、为什么hashcode冲突, 会降低效率?
HashMap 通过 Entry[] table 数组保存条目, 默认为16, 相同hashcode 的条目会添加到条目链表, 这种链表是单向的.
Entry[] table
Entry<K, V> next; // 指向下一个相同 hashcode 的条目
key 的 hashcode 决定条目在table的索引.
条目的 hashcode 通过 key.hashcode ^ value.hashcode.
如果条目的hashcode 冲突过多, 导致 条目的单向链表过长, 随机访问时效率低. 因此降低条目单向链表的长度可以提高效率.

Comments (2)

腾讯面试题:50个阶梯,你一次可以上一阶或两阶,走上去,共有多少种走法

1顶一下有个同学去了腾讯,他说面试时有这么一道思维题:50个阶梯,你一次可以上一阶或两阶,走上去,共有多少种走法? 我的思路:  我的思维比较直线简单: 1,求出走上次可能有的方式,这里的方式是指:共走多少个1步,多少个2步。比如说,你走了2个1步,其余走2步,要走24个2步,用对象存起来就是:{one:2,two:24} 2,每个方式的走法是可以通过排列组合公式算出来的。如下是排列组合公式: ...[阅读全文]

1
顶一下

有个同学去了腾讯,他说面试时有这么一道思维题:50个阶梯,你一次可以上一阶或两阶,走上去,共有多少种走法?

我的思路: 
我的思维比较直线简单:
1,求出走上次可能有的方式,这里的方式是指:共走多少个1步,多少个2步。比如说,你走了2个1步,其余走2步,要走24个2步,用对象存起来就是:{one:2,two:24}
2,每个方式的走法是可以通过排列组合公式算出来的。如下是排列组合公式:

 3,用到的公式是c(n,r)=n!/r!(n-r)!;这个比较好实现,无非就是阶乘除阶乘。
代码如下:
        (function() {
            var waysArr = []; //上台阶方式的,每一种方式为一个对象字面量,如[{one:2,two:24},{one:4,two:23}]
            var counts = []; //存每种方式排列组合数
            //生成waysArr
            for (var i = 25; i >= 0; i–) {
                var x = 50 - 2 * i;
                waysArr.push({ one: x, two: i });
            }
            //阶乘
            function factorial(num) {
                if (num <= 1) {
                    return 1;
                }
                else {
                    return num * arguments.callee(num - 1);
                }
            }

            //每种方式的排列数
            //参数是走1步的次数,走2步的次数
            function thisWayTimes(one, two) {
                //排列组合公式: n!/r!(n-r)!
                //穷举–求得被除数
                var ExhaustiveTimes = factorial(one + two);
                //重复的次数—求得除数
                var repeatedTimes = factorial(one) * factorial(two);
                //算出次数—相除
                var thisWayTime = ExhaustiveTimes / repeatedTimes;
                //存进数组
                counts.push(thisWayTime);
            }

            //计算每种方式的,除去全1全2,存入数组
            for (var j = 0, waysLen = waysArr.length; j < waysLen; j++) {
                if (waysArr[j].one != 0 && waysArr[j].one != 50) {
                    thisWayTimes(waysArr[j].one, waysArr[j].two);
                }
            }

            //求和函数
            function arrayNumSum(len) {
                if (len <= 0) {
                    return 0;
                } else {
                    return counts[len] + arguments.callee(len - 1);
                }
            }

            //求和,包括全1全2
            countsSum = arrayNumSum(counts.length - 1) + 2; //计算出来共是20,365,010,749次
            alert(countsSum);
        })();
 后来正解出来,我的答案是不对,又不全错,因为排列组合公式做了除法运算,js算出来的结果不精确。
(这就是没有找到真正数学规律的方案,费力不讨好)
 
 peter.liu的思路:
 以一个台阶为迈步的单位, 每次迈步都只有三种可能: 
1.一次走完了一个台阶, 这种情况用 ‘O’表示.  (One的首字母)
2.一次走两个台阶, 但是只走到前一半, 脚还在空中悬着, 没放下. 这种情况用’T1’表示. (Two的首字母)
3.一次走两个台阶, 这次走的是后一半, 也就是脚从空中放下的过程. 这种情况用’T2’表示.
假设这个人开始走
1.走第一个台阶他有两个选择: ‘O’, 和 ‘T1’
2.走第二个台阶他的选择取决于第一个台阶怎么走的:
   a.前一个台阶如果是’O’和’T2’, 这个台阶就有两个选择: ’O’和’T1’
   b.前一个台阶如果是’T1’, 那么这个台阶就只能是’T2’.  (悬着的脚总要放下来才行啊)
3.走第三个台阶的方式, 取决于第二个台阶是怎么走的
4.走第n个台阶的方式, 取决于第n-1个台阶只怎么走的.
可以把他的每一步想象成一棵多叉树的节点, 下一步有多种走法, 那么节点就分叉. 这棵树一直到50层, 第50层有多少个叶节点, 就一共有多少种走法. 每一种走法, 都代表了从根节点到某一叶节点的那条路径.
当然, 有一个问题, 最后一层的节点类型是不能为’T1’的, 否则悬着的脚就放不下来了.
代码如下: 
(function(){

function steps(n){
    if (n === 1)
        return ['O', 'T1']; //第一步两种可能
    lastSteps = steps(n-1);
    var currentSteps = [];
    for(var i = 0; i< lastSteps.length; i++){
        var lastStep = lastSteps[i];
        if(lastStep === ’O' || lastStep === ’T2′)
            currentSteps.push(‘O’, ’T1′);
        else if(lastStep === ’T1′)                                              
            currentSteps.push(‘T2′);        
    }
    return currentSteps;
}

var result = steps(20);
result = result.filter(function(item, index){return item !== ’T1′}); //最后一步不能是’T1′, 过滤掉
console.log(result.length);

})();
 
最终发现, 到30层的时候, 结果已经是100多万了, 并且以指数级增长. 运算第50层的时候会卡死, 因为可能性太多运算量太大了. 
(这种思路很好,很巧妙,可惜就是运算量太大)
 

 费波拉希数列:

 peter的方法虽然不能求得50层的次数,但是可以求得前30多层。依次如下:

一共1个台阶的话有1种走法.

一共2个台阶的话有2种走法.
一共3个台阶的话有3种走法.
一共4个台阶的话有5种走法.
一共5个台阶的话有8种走法.
一共6个台阶的话有13种走法.
一共7个台阶的话有21种走法.
一共8个台阶的话有34种走法.
一共9个台阶的话有55种走法.
一共10个台阶的话有89种走法.
一共11个台阶的话有144种走法.
一共12个台阶的话有233种走法.
一共13个台阶的话有377种走法.
一共14个台阶的话有610种走法.
一共15个台阶的话有987种走法.
一共16个台阶的话有1597种走法.
一共17个台阶的话有2584种走法.
一共18个台阶的话有4181种走法.
一共19个台阶的话有6765种走法.
一共20个台阶的话有10946种走法.
一共21个台阶的话有17711种走法.
一共22个台阶的话有28657种走法.
一共23个台阶的话有46368种走法.
一共24个台阶的话有75025种走法.
一共25个台阶的话有121393种走法.
一共26个台阶的话有196418种走法.
一共27个台阶的话有317811种走法.
一共28个台阶的话有514229种走法.
一共29个台阶的话有832040种走法.
一共30个台阶的话有1346269种走法.
一共31个台阶的话有2178309种走法.
一共32个台阶的话有3524578种走法.
一共33个台阶的话有5702887种走法.
一共34个台阶的话有9227465种走法.
一共35个台阶的话有14930352种走法.

……
这不正是个费波拉希数列!!!!

 知道这个数学规律就好办了。代码如下:

        function fib(n) {
            return function(n, a, b) {
                return n > 0 ? arguments.callee(n - 1, b, a + b) : a;
            } (n, 0, 1);
        }
        fib(0); //0
        fib(1); //1
        fib(2); //1
        fib(3); //2
        fib(4); //3
        //……
        fib(50); //12586269025
        fib(51); //20365011074,这里是上到第50个阶梯

Leave a Comment

一道常考的javaSE面试题

0顶一下就这道题我也想些想法,当时他们和我说完,我在想用什么方法可以实现。毕竟现在javaSE都忘的差不多了,现在主要学的还是javaEE方面。年前学习JSP和SERVLET一片的知识,到了年后主要学习三大框架、ajax、jquery和XML等。不过当时出现脑中的算法只有:java.util包中定义的Arrays类和冒泡法。 下面就拿上面方说的那两种方法具体说说。 在JDK的java.util包中定义的Arrays类提供了多种数据操作...[阅读全文]

0
顶一下

就这道题我也想些想法,当时他们和我说完,我在想用什么方法可以实现。毕竟现在javaSE都忘的差不多了,现在主要学的还是javaEE方面。年前学习JSP和SERVLET一片的知识,到了年后主要学习三大框架、ajax、jquery和XML等。不过当时出现脑中的算法只有:java.util包中定义的Arrays类和冒泡法。

下面就拿上面方说的那两种方法具体说说。

在JDK的java.util包中定义的Arrays类提供了多种数据操作方法,实现了对数组元素的排序、填充、转换、增强检索和深度比较等功能,所以的这些方法都是static的,下面介绍对数组元素进行排序的方法。数组元素的排序通常是指一维数值型数组元素按升序排序,偶尔也会涉及一维String数组排序,一般来说,多维和其他引用类型的元素数组排序使用意义不大。

Arrays类中的sort()的格式:

public static void sort([] a);

案例1:

JDK的java.util包中定义的Arrays类提供了排序方法

一维数组排序:

Java代码

 

 

package cn.z_xiaofei168.sort;

import java.util.Arrays;

public class TestArraySort {

    /**  
     * @author z_xiaofei168  
     */
    public static void main(String[] args) {
        int[] arr = { -1, -3, 5, 7, 9, 2, 4, 6, 8, 10 };
        System.out.print(“整数排序前:”);
        displayIntArr(arr);
        Arrays.sort(arr);
        System.out.print(“整数排序后:”);
        displayIntArr(arr);

        String[] name = {“Tom”,”Kitty”,”James”,”z_xiaofei168″,”DXL_xiaoli”,”Zhang_Di”};
        System.out.print(“字符串排序前:”);
        displayStringArr(name);
        Arrays.sort(name);
        System.out.print(“字符串排序后:”);
        displayStringArr(name);
    }

    /** 整数排序方法 */
    public static void displayIntArr(int[] arr) {
        for (int i : arr) {
            System.out.print(i + ”\t”);
        }
        System.out.println();
    }

    /** 字符串排序方法  */
    public static void displayStringArr(String[] arr) {
        for (String s : arr) {
            System.out.print(s + ”\t”);
        }
        System.out.println();
    }

}

 

运行结果如下图所示:

 

 

案例2:冒泡法

Java代码

 

 

package cn.z_xiaofei168.sort;

public class TestMaopao {

    /**  
     * @author z_xiaofei168  
     */
    public static void main(String[] args) {
        int[] arr = { -1, -3, 5, 7, 9, 2, 4, 6, 8, 10 };
        System.out.print(“整数排序前:”);
        for(int ar : arr){
            System.out.print(ar+”\t”);
        }
        System.out.println();
        displayIntArr(arr);
        System.out.print(“整数排序后:”);
        for(int a : arr){
            System.out.print(a+”\t”);
        }
    }

    /** 冒泡排序方法  */
    public static void displayIntArr(int[] arr) {
        for (int i=arr.length-1;i>0;i–) {
            for (int j = 0; j < i; j++) {
                if(arr[j]>arr[j+1]){
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

 

运行结果如下图所示:

 

Comments (104)