软件开放性面试题.docx

软件开放性面试题.docx

《软件开放性面试题.docx》由会员分享，可在线阅读，更多相关《软件开放性面试题.docx（10页珍藏版）》请在冰豆网上搜索。

软件开放性面试题

开放型面试题

答题人：

____________                         答题时间：

____________

一、           简答题：

1.       谈谈你对spring，hibernate的理解？

2.       你在项目中用到了哪些设计模式？

分别都用在什么场景？

3.       xml有哪些解析技术?

区别是什么?

4.       多线程有几种表示方法，都是什么？

同步有几种实现方法，都是什么？

5.       深克隆和浅克隆的区别？

6.       你在项目中最常用的集合有哪些，区别是什么？

7.       试说说socket通信的原理（客户端和服务器端）？

8.       邮件传输协议有哪些？

pop3

9.       存储过程和函数的区别？

存储过程一般没有返回值

函数一定有返回值

10.   事务是什么？

它的原理是哪4个？

原子性、一致性、分离性、持久性

11.   SELECT*FROMTABLE

和

SELECT*FROMTABLE

WHERENAMELIKE'%%'

ANDADDRLIKE'%%'

AND（1_ADDRLIKE'%%'OR2_ADDRLIKE'%%'OR3_ADDRLIKE'%%'OR4_ADDRLIKE'%%'）

的检索结果为何不同？

12.链表的特点有哪些？

插入删除快，检索慢

13.在一个长度为n的顺序表中删除第i个元素，要移动几个元素？

如果要在第i个元素前插入一个元素，要后移几个元素？

n-i,n-i+1

14.你常用的排序算法有哪些，举例说明对5个数字进行排序。

你认为对中文排序该如何实现？

冒泡，插入，选择，希尔，快速

15.你做过权限系统吗？

如果是你设计权限系统，你会怎么设计？

过滤器

二、           编程题：

1.  求出前1000个素数。

2.  从D盘读取一个xml文件，并将其解析为java中的一个对象，例子自理。

3.  输入一个二叉树，如何从叶子节点向上逐层打印？

比如二叉树如下

      1

   2    3

4   5  6  7

程序打印：

4567231

一，冒泡排序：

packagecom.sort;

importjava.util.Random;

publicclassNo1Maopao{

   publicstaticvoidmain（String[]args）{

       Randomrd=newRandom（）;

//生成随即数组

       int[]src=newint[10];

       for（inti=0;i<10;i++）{

           src[i]=rd.nextInt（100）;

       }

//排序前打印数组所有元素

       for（inti:

src）

           System.out.println（i）;

       System.out.println（"---------------可爱的分割线-------------------"）;

       src=sort（src）;

//排序后打印数组所有元素

       for（inti:

src）

           System.out.println（i）;

   }

   publicstaticint[]sort（int[]src）{

       for（inti=0;i

           for（intj=i;j

               if（src[j]

                   inttemp=src[j];

                   src[j]=src[i];

                   src[i]=temp;

               }

           }

       }

       returnsrc;

   }

}

二、选择排序：

packagecom.sort;

importjava.util.Random;

publicclassNo2XuanZhe{

   publicstaticvoidmain（String[]args）{

       Randomrd=newRandom（）;

       int[]src=newint[10];

       for（inti=0;i<10;i++）{

           src[i]=rd.nextInt（100）;

       }

       for（inti:

src）

           System.out.println（i）;

       System.out.println（"---------------可爱的分割线-------------------"）;

       src=sort（src）;

       for（inti:

src）

           System.out.println（i）;

   }

   publicstaticint[]sort（int[]src）{

       intmin;

       for（inti=0;i

           min=src[i];

           for（intj=i+1;j

               if（src[j]

                   min=src[j];

                   inttemp=src[i];

                   src[i]=src[j];

                   src[j]=temp;

               }

           }

       }

       returnsrc;

   }

}

三、插入排序：

packagecom.sort;

importjava.util.Random;

publicclassNo3ChaRu{

   publicstaticvoidmain（String[]args）{

       Randomrd=newRandom（）;

       int[]src=newint[10];

       for（inti=0;i<10;i++）{

           src[i]=rd.nextInt（100）;

       }

       for（inti:

src）

           System.out.println（i）;

       System.out.println（"---------------可爱的分割线-------------------"）;

       src=sort（src）;

       for（inti:

src）

           System.out.println（i）;

   }

   publicstaticint[]sort（int[]src）{

       intin,out;

       for（in=1;in

           inttemp=src[in];

           out=in;

           while（out>0&&src[out-1]>=temp）{

               src[out]=src[out-1];

               --out;

           }

           src[out]=temp;

       }

       returnsrc;

   }

}

四、希尔排序：

packagecom.sort;

importjava.util.Random;

publicclassNo4Xier{

   publicstaticvoidmain（String[]args）{

       Randomrd=newRandom（）;

       int[]src=newint[10];

       for（inti=0;i<10;i++）{

           src[i]=rd.nextInt（100）;

       }

       for（inti:

src）

           System.out.println（i）;

       System.out.println（"---------------可爱的分割线-------------------"）;

       src=sort（src）;

       for（inti:

src）

           System.out.println（i）;

   }

   publicstaticint[]sort（int[]src）{

       intlen=src.length;

       inttemp,i,j;

       inth=1;

       while（h<=len/3）

           h=h*3+1;

       while（h>0）{

           for（i=h;i

               temp=src[i];

               j=i;

               while（j>h-1&&src[j-h]>=temp）{

                   src[j]=src[j-h];

                   j-=h;

               }

               src[j]=temp;

           }

           h=（h-1）/3;

       }

       returnsrc;

   }

}

五、快速排序：

publicclassNo5Kuaisu{

   publicstaticvoidquickSort（int[]array）{

       quickSort（array,0,array.length-1）;

   }

   privatestaticvoidquickSort（int[]array,intlow,inthigh）{

       if（low

           intp=partition（array,low,high）;

           quickSort（array,low,p-1）;

           quickSort（array,p+1,high）;

       }

   }

   privatestaticintpartition（int[]array,intlow,inthigh）{

       ints=array[high];

       inti=low-1;

       for（intj=low;j

           if（array[j]

               i++;

               swap（array,i,j）;

           }

       }

       swap（array,++i,high）;

       returni;

   }

   privatestaticvoidswap（int[]array,inti,intj）{

       inttemp;

       temp=array[i];

       array[i]=array[j];

       array[j]=temp;

   }

publicstaticvoidmain（String[]args）{

       Randomrd=newRandom（）;

       int[]src=newint[10];

       for（inti=0;i<10;i++）{

           src[i]=rd.nextInt（100）;

       }

       for（inti:

src）

           System.out.println（i）;

       System.out.println（"---------------可爱的分割线-------------------"）;

       quickSort（src）;

       for（inti:

src）

           System.out.println（i）;

       System.out.println（"---------------可爱的分割线-------------------"）;

   }

}

二叉树

publicclassTestTree{

publicstaticvoidmain（String[]args）{

Noderoot=newNode（）;

root.setNodeText（"1"）;

NodeleftNode=newNode（）;

leftNode.setNodeText（"2"）;

leftNode.setParentNode（root）;

NoderightNode=newNode（）;

rightNode.setNodeText（"3"）;

rightNode.setParentNode（root）;

root.setLeftNode（leftNode）;

root.setRightNode（rightNode）;

NodeleftNode2=newNode（）;

leftNode2.setNodeText（"4"）;

leftNode2.setParentNode（leftNode）;

NoderightNode2=newNode（）;

rightNode2.setNodeText（"5"）;

rightNode2.setParentNode（leftNode）;

leftNode.setLeftNode（leftNode2）;

leftNode.setRightNode（rightNode2）;

NodeleftNode3=newNode（）;

leftNode3.setNodeText（"6"）;

leftNode3.setParentNode（rightNode）;

NoderightNode3=newNode（）;

rightNode3.setNodeText（"7"）;

leftNode3.setParentNode（rightNode）;

rightNode.setLeftNode（leftNode3）;

rightNode.setRightNode（rightNode3）;

//printLeaf（root.getLeftNode（）,root.getRightNode（））;

printLeaf（root）;

System.out.println（"****************"）;

zPrintLeaf（root）;

System.out.println（"****************"）;

hPrintLeaf（root）;

}

//前序

publicstaticvoidprintLeaf（Noderoot）{

System.out.print（root.getNodeText（））;

if（root.getLeftNode（）!

=null）{

printLeaf（root.getLeftNode（））;

}

if（root.getRightNode（）!

=null）{

printLeaf（root.getRightNode（））;

}

}

//中序

publicstaticvoidzPrintLeaf（Noderoot）{

if（root.getLeftNode（）!

=null）{

zPrintLeaf（root.getLeftNode（））;

}

System.out.print（root.getNodeText（））;

if（root.getRightNode（）!

=null）{

zPrintLeaf（root.getRightNode（））;

}

}

//后序

publicstaticvoidhPrintLeaf（Noderoot）{

if（root.getLeftNode（）!

=null）{

hPrintLeaf（root.getLeftNode（））;

}

if（root.getRightNode（）!

=null）{

hPrintLeaf（root.getRightNode（））;

}

System.out.print（root.getNodeText（））;

}

}

classNode{

protectedStringnodeText;

protectedNodeparentNode;

protectedNodeleftNode;

protectedNoderightNode;

publicNodegetParentNode（）{

returnparentNode;

}

publicvoidsetParentNode（NodeparentNode）{

this.parentNode=parentNode;

}

publicStringgetNodeText（）{

returnnodeText;

}

publicvoidsetNodeText（StringnodeText）{

this.nodeText=nodeText;

}

publicNodegetLeftNode（）{

returnleftNode;

}

publicvoidsetLeftNode（NodeleftNode）{

this.leftNode=leftNode;

}

publicNodegetRightNode（）{

returnrightNode;

}

publicvoidsetRightNode（NoderightNode）{

this.rightNode=rightNode;

}

}