算法之蛮力法(java)
1.蛮力法的设计思想
蛮力法是指采用遍历（扫描）技术，即采用一定的策略将待求解问题的所有元素依次处理一次，从而找出问题的解。
依次处理所有元素是蛮力法的关键，为了避免陷入重复试探，应保证处理过的元素不再被处理。
2.完美数
如果一个自然数的真因子之和等于这个自然数本身，则这个自然数就称为完美数。
案例：给定一个自然数n,用计算机程序程序判定它是否是完美数。（java）
package com.sun.main;
import java.util.Scanner;
public class perfect {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input=new Scanner(System.in);
System.out.println("请输入要测试的完美数：");
int n=input.nextInt();
int result = perfectNumber(n);
if(result==0){
System.out.println("不是完美数");
}else{
System.out.println("是完美数");
}
}
public static int perfectNumber(int n)
{
int i,sum=0;
for(i=1;i<=n/2;i++)//设置i循环，i从1至n/2循环，枚举所有可能真因子。
if(n%i==0)// 约束条件: 逻辑表达式 n%i==0
sum=sum+i;
if(sum==n)
return 1;
else
return 0;
}
}
结果：
3.最大公约数
案例：通过“枚举尝试”（逐个尝试）就可以“试出”a,b有哪些是公约数，并将这些公约数“累乘”，就能得到最大公约数。（java）
package com.sun.main;
import java.util.Scanner;
public class MaxGongyue {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("请输入第一个数：");
int a=input.nextInt();
System.out.println("请输入第二个数：");
int b=input.nextInt();
int c,i;
c=1; //变量c是为累乘因数而设置的；
for (i=2; i<=a && i<=b; i++) //“枚举”可能的公约数
while (a % i==0 && b %i==0 )
//“试”i是否为公约数
{c=c*i;
a=a/i;
b=b/i;}
System.out.println("最大公约数为："+c);
}
}
结果：
4.选择排序
原理：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。
代码
package com.sun.main;
import java.util.Arrays;
import java.util.Scanner;
public class selectionSort {
public static void main(String[] args){
Scanner x=new Scanner(System.in);
System.out.println("输入数组个数：");
while(x.hasNext()){
int m=x.nextInt();
System.out.println("输入数组值：");
int[] arr=new int[m];
for(int i=0;i<m;i++){
arr[i]=x.nextInt();
}
for (int i = 0; i < m-1; i++) {
int min = i;
for (int j = i + 1; j < m; j++) {
if (arr[min] > arr[j]) {
min = j;
}
}
if (min != i) {
int tmp = arr[min];
arr[min] = arr[i];
arr[i] = tmp;
}
}
System.out.println("结果："+Arrays.toString(arr));
}
}
}
结果：
5.冒泡排序
原理：对n个数进行递增冒泡排序。
首先让第一个数与第二个数比较，如果是大于关系，则交换，若是小于等于关系，则不予理会；然后再让第二个数与第三个数比较，如果是大于关系，则再交换；一直比较到第n-1个数与第n个数比较，如果是大于关系，则交换。这个过程称为第一趟冒泡排序。
依此类推，那么对n个数进行冒泡排序要进行多少趟呢？显然是n-1趟。
代码
package com.sun.main;
import java.util.Arrays;
import java.util.Scanner;
public class bubbleSort {
public static void main(String[] args){
Scanner x=new Scanner(System.in);
System.out.println("输入数组个数：");
while(x.hasNext()){
int m=x.nextInt();
System.out.println("输入数组值：");
int[] arr=new int[m];
for(int i=0;i<m;i++){
arr[i]=x.nextInt();
}
for(int i =1;i<arr.length;i++) {
for(int j=0;j<arr.length-i;j++) {
if(arr[j]>arr[j+1]) {
int temp = arr[j]
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.println("结果："+Arrays.toString(arr));
}
}
}
结果：
6.插入排序
原理：
每一趟直接插入排序时，要将待排序序列中的一个元素插入到前面一个已经排好序的有序子序列中，直到所有元素都插入到有序序列中为止。
例如，若初始序列是10 3 7 11 9，则直接插入排序过程如下。
10 3 7 11 9
第一趟直接插入排序后：3 10 7 11 9
第二趟直接插入排序后：3 7 10 11 9
第三趟直接插入排序后：3 7 10 11 9
第四趟直接插入排序后：3 7 9 10 11
代码（两种）
package com.sun.main;
import java.util.Arrays;
import java.util.Scanner;
public class insertionSort {
public static void main(String[] args){
Scanner x=new Scanner(System.in);
System.out.println("输入数组个数：");
while(x.hasNext()){
int m=x.nextInt();
System.out.println("输入数组值：");
int[] arr=new int[m];
for(int i=0;i<m;i++){
arr[i]=x.nextInt();
}
int[] result = insertSort1(arr);
int[] result1 = insertSort2(arr);
System.out.println("结果1："+Arrays.toString(result));
System.out.println("结果2："+Arrays.toString(result1));
}
}
private static int[] insertSort1(int[]arr){
if(arr == null || arr.length < 2){
return arr;
}
for(int i=1;i<arr.length;i++){
for(int j=i;j>0;j--){
if(arr[j]<arr[j-1]){
int temp=arr[j];
arr[j]=arr[j-1];
arr[j-1]=temp;
}else{
break;
}
}
}
return arr;
}
/**
*插入排序,上面的todo交换很频繁,增加很多步骤
*@paramarr
*@return
*/
private static int[] insertSort2(int[]arr){
if(arr == null || arr.length < 2){
return arr;
}
for(int i=1;i<arr.length;i++){
int temp = arr[i];
int indx = 0;
for(int j=i;j>0;j--){
if(arr[j]<arr[j-1]){
arr[j] = arr[j-1];
indx = j-1;
}else{
break;
}
arr[indx]=temp;
}
}
return arr;
}
}
结果：
268
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
