1.选择排序法

所谓的选择排序，就是把当前数据与它后面所有的数据做个比较，假如满足比较条件，则进行交换操作，直到最后二个数比较完毕，

这样重新输出的数据就已经由大到小或者由小到大排好序了。

for(int i=0;i

for(int j=i+1;j

if(arr[i]>arr[j]){

swap(arr,i,j);

}

}

}

2.冒泡排序法

所谓的冒泡排序，就是相邻的二个数相互比较，把满足比较条件的二个数给交换下位置，第一轮二二相比较，把第一个最大(或最小值)

给冒泡到最后面去，然后第二轮继续从最前面开始二二比较，直到已经被确定位置的数据为止，从而确定第二个数，以此类推，从而达到排序。

for(int i=0;i

for(int j=0;j

if(arr[j]>arr[j+1]){

swap(arr,j,j+1);

}}

3.二维数组求和

基本思想：把每个一维数组遍历出来，然后再求和，所有一维数组的和就是二维数组的和

int arr[][] = {{1,3,4,5},{2,5,6},{64,12}};

int sum=0;

for(int i=0;i

for(int j=0;j

sum+=arr[i][j];

}

}

4.获取一个子串在字符串中出现的次数

基本思想：使用字符串中的indexOf方法，返回子串在字符串中的位置，假如返回的数字不是-1，则计数器加一，然后继续从返回的index索引号

加上子串的长度位置继续使用indexOf(key,index)查找，直到返回的为-1为止，index=index+key.length(假如允许重叠的话，则index++)

public static Integer getKeyCountFromStr(String str,String key){

int index=0;

int count=0;

while((index=str.indexOf(key,index))!=-1){

index=index+key.length();

count++;

}

}

5.获取两个字符串中最大相同子串

基本思想：使用字符串中contains方法，从最大字符串包含最小字符串开始进行判断，假如不包含则从子串中截取出少一字符的子串，然后再

判断是否被最大字符串包含，直到被包含位置，返回该字串。注意截取是左闭有开

public static List getMaxSameStr(String stringOne,String stringTwo){

String longstring,shortstring,substring;

List substringgroup = new ArrayList<>();

if(null==stringOne||null==stringTwo||stringOne.isEmpty()||stringTwo.isEmpty()){

substringgroup.add("字符串存在为空或为null，没有相同字串");

return substringgroup;

}

if(stringOne.length()>stringTwo.length()){

longstring = stringOne;

shortstring = stringTwo;

}else{

longstring = stringTwo;

shortstring = stringOne;

}

for(int i=0;i

for(int j=0,y=shortstring.length()-i;y!=shortstring.length()+1;j++,y++){

substring=shortstring.substring(j,y);

if(longstring.contains(substring)){

substringgroup.add(substring);

}

}

if(substringgroup.size()!=0){

return substringgroup;

}

}

if(substringgroup.size()==0){

substringgroup.add("没有相同字串");

return substringgroup;

}

return null;

}

6. "34 9 -7 12 67 25"要求对这个字符串中的数值进行从小到大的排序

基本思路：通过字符串spilt方法按照一定规则进行切割转换成字符串数组，再把字符串数组转换为int数组，然后再进行冒泡排序

public static int[] sortStringNumber(String str,String split){

String[] strgroup = str.spilt(spilt);

int[] number = toIntGroup(strgroup);

return sortNumber(number);

}

public static int[] toIntGroup(String[] stringGroup){

int[] intgroup = new int[stringGroup.length()];

for(int i=0;i

intgroup[i]=Integer.parseInt(stringGroup[i]);

}

return intgroup;

}

public static int[] sortNumber(int[] intgroup){

for(int i=0;i

for(int j=0;j

if(intgroup[j]>intgroup[j+1]){

int temp=intgroup[j];

intgroup[j]=intgroup[j+1];

intgroup[j+1]=temp;

}

}

}

return intgroup;

}

7.九九乘法表打印

基本思路：1.找出规律-第一行，只有一个计算，第二行，有二个，每行第二个数等于行数，第一个数从1开始到行数

2.根据规律设计结构-二层嵌套循环打印，以及打印完每行后进行换行操作

public static void printMultTable(int number){

if(number<=0){

System.prinln.out("请输入大于0的整数");

System.exit();

}

for(int i=1;i<=number;i++){

for(int j=1;j<=i;j++){

system.print.out(j+"*"+i+"="+j*i);

system.print.out();

}

system.println.out();

}

}

8.打印以下图案

*

* * *

* * * * *

* * * * * * *

* * * * *

* * *

*

基本思路：找出每行星数变化规律-由于前面的好找规律，后面的比较难找，所以从后面开始找规律，行数+星星数=最大数为14

public static void printStar(int row){

if(row<=0){

System.prinln.out("请输入大于0的整数");

System.exit();

}

for (int i=1; i<=2*row-1; i+=2){

for(int j=1; j<=i && i+j<= 2*row; j++){

System.out.print("* ");

}

System.out.println(); // 换行

}

}

9. PI＝4/1－4/3+4/5-4/7.......

打印出第一个大于 3.1415小于 3.1416的值

1.分子=-4*(-1),分母=分母+2

public static double getorderPi(){

double pi=0,molecule=-4;

for(int i=1;;i+=2){

molecule=molecule*(-1);

pi = pi+molecule/i;

if(pi>3.1415&&pi<3.1416){

return pi;

}

}

}

10.在屏幕上打印出n行的金字塔图案，如，若n=5,则图案如下：

*

***

*****

*******

*********

空格=n-i

星星数=2n-1

public static void printTriangleStar(int n){

for(int i=1;i<=n;i++){

for(int j=0;j

System.out.print(" ");

}

for(int k=1;k<=2*i-1;k++){

System.out.print("*");

}

System.out.println();

}

}

11.约梭芬杀人法

把犯人围成一圈，从任意位置开始数，杀掉第7个人，然后继续从被杀掉的人后面那位从头开始数，直到剩下最后一个，

求打印出最后剩下的犯人是谁

基本思想：把犯人放到一个list中去，然后这里分为二种情况，当犯人数大于等于7的时候，kill掉的后面的元素赋予给一个新数组，

然后把前面的元素给add到新数组中去，然后循环去迭代，直到小于七人，

当犯人数小于七人的时候，利用数组大小%7获得kill索引，不断去获取，然后kill掉，直到数组大小=1；

public static List getLastPrisoner(List list,int killnumber){

List newlist = new ArrayList();

while(list.size()>=killnumber){

for(int i=0;i

if(i>killnumber-1){

newlist.add(list.get(i));

}

}

for(int j=0;j

newlist.add(list.get(j));

}

list.clear();

for(int k=0;k

list.add(newlist.get(k));

}

newlist.clear();

}

while(list.size()>1){

for(int h=0;h

if(h>(killnumber%list.size()-1)){

newlist.add(list.get(h));

}

}

int size=newlist.size();

for(int x=0;x

newlist.add(list.get(x));

}

list.clear();

for(int y=0;y

list.add(newlist.get(y));

}

newlist.clear();

}

return list;

}