Java小程序練習

1.選擇排序法
所謂的選擇排序，就是把當前數據與它後面全部的數據作個比較，假如知足比較條件，則進行交換操做，直到最後二個數比較完畢，
這樣從新輸出的數據就已經由大到小或者由小到大排好序了。
for(int i=0;i<arr.leng-1;i++){
for(int j=i+1;j<arr.leng;j++){
if(arr[i]>arr[j]){
swap(arr,i,j);
}
}
}

 

2.冒泡排序法
所謂的冒泡排序，就是相鄰的二個數相互比較，把知足比較條件的二個數給交換下位置，第一輪二二相比較，把第一個最大（或最小值）
給冒泡到最後面去，而後第二輪繼續從最前面開始二二比較，直到已經被肯定位置的數據爲止，從而肯定第二個數，以此類推，從而達到排序。
for(int i=0;i<arr.leng-1;i++){
for(int j=0;j<arr.leng-1-i;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<arr.length;i++{
for(int j=0;j<arr[i].length();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<String> getMaxSameStr(String stringOne,String stringTwo){
String longstring,shortstring,substring;
List<String> 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<shortstring.length();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<stringGroup.length;i++){
intgroup[i]=Integer.parseInt(stringGroup[i]);
}
return intgroup;
}

public static int[] sortNumber(int[] intgroup){
for(int i=0;i<intgroup.length-1;i++){
for(int j=0;j<intgroup-1-i;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<n-i;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<list.size();i++){
if(i>killnumber-1){
newlist.add(list.get(i));
}
}
for(int j=0;j<killnumber-1;j++){
newlist.add(list.get(j));
}
list.clear();
for(int k=0;k<newlist.size();k++){
list.add(newlist.get(k));
}
newlist.clear();
}

while(list.size()>1){
for(int h=0;h<list.size();h++){
if(h>(killnumber%list.size()-1)){
newlist.add(list.get(h));
}
}
int size=newlist.size();
for(int x=0;x<list.size()-size-1;x++){
newlist.add(list.get(x));
}
list.clear();

for(int y=0;y<newlist.size();y++){
list.add(newlist.get(y));
}
newlist.clear();
}
return list;
}