1、简单逻辑算法
(1)九九乘法表系列
实现左边图片效果：运用双重for循环
for (int i = 1; i <=9; i++) { //控制行,从1开始循环 for (int j = 1; j <=i ; j++) { //控制每行对应的数
System.out.print(i+"*"+j+"="+i*j+"\t");
}
//第一次循环i是1 j也是1 结果1*1=1 这是图1第一种
//第二次循环i是2 j是1和2 结果2*1=2 2*2=4
//第三次循环i是3 j是1、2、3 结果3*1=3 3*2=6 3*3=9
//同理
System.out.println();//每次循环完换行
}
for (int i = 9; i >=1; i--) { //控制行,从9开始循环 for (int j = 1; j <=i ; j++) { //控制每行对应的数
System.out.print(i+"*"+j+"="+i*j+"\t");
}
//第一次循环i是9 j也是1到9 9*1 9*2.... 这是第二图
//第二次循环i是8 j是1到8
//同理
System.out.println();//每次循环完换行
}
第三题思路：发现是第二图从第二行开始往右边移动2个\t(制表符差不多空格的意思),只要再j循环的上面先弄空白就会把它挤到右边
for (int i = 9; i >=1; i--) { //控制行,从9开始循环 for (int m = 1; m <= 9-i; m++) {
System.out.print("\t\t");//控制每行对应的数
//第一次i=9的时候m是false不运行
//第二次i=8的时候m是1，运行一次
//i=7，运行2次 同理 关键是9-i要想到
}
for (int j = 1; j <=i ; j++) { //控制每行对应的数
System.out.print(i+"*"+j+"="+i*j+"\t");
}
//第一次循环i是9 j也是1到9
//第二次循环i是8 j是1到8
//同理
System.out.println();//每次循环完换行
}
第四题思路：发现第一行是1，第二行是2 说明i是从1开始的，那个空白第一行有8个，所以循环从9开始，因为不等于i，所以第一次就循环8次空格，就可以把数字挤到右边去了
for (int i = 1; i <=9; i++) { //控制行,从9开始循环 for (int m = 9; m > i; m--) {
System.out.print("\t\t");//控制每行对应的数
//第一次i=1的时候m循环8次
//第二次i=2的时m循环7次
//同理
}
for (int j = 1; j <=i ; j++) { //控制每行对应的数
System.out.print(i+"*"+j+"="+i*j+"\t");
}
//第一次循环i是1 j也是1到1
//第二次循环i是2 j是1和2
//同理
System.out.println();//每次循环完换行
}
(2)星星系列
(1)
for (int i = 1; i <= 5; i++) {//i控制行，共5行 for (int j = 5; j >i; j--) {//j控制每一行的数量
System.out.print("m");//用m代替空格先测试，如果正确变空格
//i=1 j=4,3,2,1 输出4个m
//i=2 j循环3次m 同理
}
for (int k = 1; k <=5; k++) {
System.out.print("*");
//K控制每行多少个 都是5个
}
System.out.println();
}
(2)
for (int i = 1; i <= 5; i++) {//i控制行，共5行 for (int j = 5; j >i; j--) {//j控制每一行的数量
System.out.print("m");//用m代替空格先测试，如果正确变空格
//i=1 j=4,3,2,1 输出4个m
//i=2 j循环3次m 同理
}
for (int k = 1; k <=(2*i)-1; k++) {
System.out.print("*");
//i=1 k=1
//i=2 K=3同理，3就是循环了3次*
}
System.out.println();
}
(3)第三题的思路：发现和第二图加倒三角 那我们只要再画一个倒的三角就行，在2图的基础上
for (int i = 1; i <= 5; i++) {//i控制行，共5行 for (int j = 5; j > i; j--) {//j控制每一行的数量
System.out.print("m");//用m代替空格先测试，如果正确变空格
//i=1 j=4,3,2,1 输出4个m
//i=2 j循环3次m 同理
}
for (int k = 1; k <= (2 * i) - 1; k++) {
System.out.print("*");
//i=1 k=1
//i=2 K=3同理，3就是循环了3次*
}
System.out.println();
}//下面新的循环是控制倒的三角
for (int ii = 4; ii >= 1; ii--) { //ii控制行，共4行,倒3角有4行
for (int jj = 1; jj <= 5 - ii; jj++) {//jj控制每一行的数量
System.out.print("m");
//发现ii=4时候 jj循环1次 ii=3 jj循环2次
}
for (int kk = 1; kk <= (2 * ii) - 1; kk++) {
System.out.print("*");
//ii=4 kk=7 就是7颗*
//ii=3 Kk=3同理，3就是循环了3次*
}
System.out.println();
}
(4-1)思路：再上个代码改，可以考虑先画靠近m的那几个*,再画空格，然后再画最右边的*即可
for (int i = 1; i <= 5; i++) {//i控制行，共5行 for (int j = 5; j > i; j--) {//j控制每一行的数量
System.out.print("m");//用m代替空格先测试，如果正确变空格
//i=1 j=4,3,2,1 输出4个m
//i=2 j循环3次m 同理
}
for (int k = i; k ==i; k++) {//即每次循环画1次
System.out.print("*");
//前面画完空格 再接1颗*即可
}
for (int m = 2; m <2*i-1; m++) {
System.out.print(" ");//这是空格的规律从第二行开始
//i=1,不运行 i=2 2<3 第二行只循环1次空格
}
if (i > 1) {
for (int kk =i; kk ==i; kk++) {
System.out.print("*");
//因为第一行已经有了。所以第二行开始
}
}
System.out.println();
}//下面新的循环是控制倒的三角，同理
for (int ii = 4; ii >= 1; ii--) { //ii控制行，共4行,倒3角有4行
for (int jj = 1; jj <= 5 - ii; jj++) {//jj控制每一行的数量
System.out.print("m");
//发现ii=4时候 jj循环1次 ii=3 jj循环2次
}
for (int kk = ii; kk <=ii; kk++) {
System.out.print("*");
}
for (int m = 2; m <2*ii-1; m++) {
System.out.print(" ");
}
if (ii > 1) {
for (int kk =ii; kk <=ii; kk++) {
System.out.print("*");
}
}
System.out.println();
}
(4-2)更简单的方法
for (int i = 1; i <= 5; i++) {//i控制行，共5行 for (int j = 5; j > i; j--) {//j控制每一行的数量
System.out.print(" ");//用m代替空格先测试，如果正确变空格
//i=1 j=4,3,2,1 输出4个m
//i=2 j循环3次m 同理
}
for (int m = 1; m <= 2 * i - 1; m++) {
if (m == 1 || m == 2 * i - 1) {
System.out.print("*");//这是直接来判断开头和结尾
//i=1 m=1 进判断 循环1次*
//i=2 m=1,2,3 正常循环3次 进判断，1时候打印*，m==2*2-1==3 所以m=2时候是空格 3时候才是*
}else {
System.out.print(" ");
}
}
System.out.println();
}//下面新的循环是控制倒的三角，同理
for (int ii = 4; ii >= 1; ii--) { //ii控制行，共4行,倒3角有4行
for (int jj = 1; jj <= 5 - ii; jj++) {
System.out.print(" ");
}
for (int m = 1; m <= 2 * ii - 1; m++) {
if (m == 1 || m == 2 * ii - 1) {
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println();
}
(5)在第四图的基础上改一下就可以
for (int i = 1; i <= 5; i++) {//i控制行，共5行 for (int j = 5; j > i; j--) {//j控制每一行的数量
System.out.print(" ");//用m代替空格先测试，如果正确变空格
//i=1 j=4,3,2,1 输出4个m
//i=2 j循环3次m 同理
}
for (int m = 1; m <= 2 * i - 1; m++) {
if (m == 1 || m == 2 * i - 1||i==5) {
System.out.print("*");//这是直接来判断开头和结尾
//i=1 m=1 进判断 循环1次*
//i=2 m=1,2,3 正常循环3次 进判断，1时候打印*，m==2*2-1==3 所以m=2时候是空格 3时候才是*
//补一个i==5就行了,就直接打印9颗，m<=9
}else {
System.out.print(" ");
}
}
System.out.println();
}
(Q1)完数
输入一个数，判断这个数是不是完数
完数：一个数恰好等于它的除了它本身之外所有因数之和，这个数就称为“完数”。
例如：6的因数有：1、2、3；由于6=1+2+3，所以6是完数。
6是完数
28是完数
496是完数
public class Teeee { public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个整数:");
int a= scanner.nextInt();
int sum=0;
for(int i=1;i<a;i++){
if(a%i==0){
sum+=i;
System.out.println(i);
}
}
if(sum==a){
System.out.println(a+"是完数");
}else {
System.out.println(a+"不是完数");
}
}
}
public static void demo() { for(int a=100;a<1000;a++){
int sum=0;
for(int i=1;i<a;i++){
if(a%i==0){
sum+=i;
}
}
if(sum==a){
System.out.println("100到999之间的完数有："+a);
}
}
}
(Q2)斐波纳契数列（Fibonacci series）
# 两个元素的总和确定了下一个数 1 1 2 3 5 8
public class B { public static void main(String[] args) {
int b=1;
int a=0;
for(int m=1;m<6;m++){
System.out.print(a+"\t"+b+"\t");
a=a+b;
b=a+b;
}
}
}
(Q3)水仙花数
1. 水仙花数必须是3位数，它的每个位上的数字的 3次幂之和等于它本身。例如：1^3 + 5^3+ 3^3 = 153
2. 水仙花数共有4个：153，370，371，407；
3. public static void main(String[] args) { for(int a=100;a<1000;a++){
int b=a/100; //百位
int c=a%10; //个位
int d=a/10%10;//十位 a == Math.pow(b,3) + Math.pow(c,3) + Math.pow(d,3)
if (a == b * b * b + c * c * c + d * d * d) {
System.out.println(a+"这是水仙数");
}
}
}public static void shuiXian() { try {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个三位的正整数：");
int a = scanner.nextInt();
int b=a/100; //百位
int c=a%10; //个位
int d=a/10%10;//十位
if (a == b * b * b + c * c * c + d * d * d) {
System.out.println(a+"这是水仙数");
}else{
System.out.println(a+"不是水仙数");
}
} catch (Exception e) {
System.out.println("您的输入有误!");
}
}
(Q4)阶乘
public static void jieChenHe1() { long sum = 0;
int n = 6;
for(int i = 1; i<=n; i+=2){ //这里求1！+3！+5！
long temp = 1;
for(int j = 1; j<=i; j++){
temp *= j;
}
sum = sum + temp;
}
System.out.println("1！+3！+5！= " + sum);
}
public static void jieChenHe1() { int sum=0;
int i=1;
for (int j = 1; j <3; j++) {
i*=j;
sum+=i;
}
System.out.println("1到5的阶乘和:" + sum);
}
(Q5)回文数
输入一个数 如121 反过来也是一样 1221 也是
try { Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个数：");
int i = scanner.nextInt();
int temp=i;
int num =0;
while (i!=0) {
int ge= i%10;
i=i/10;
num=num*10+ge;
}
if (temp == num) {
System.out.println("这是回文数");
}else {
System.out.println("这不是回文数");
}
} catch (Exception e) {
System.out.println("输入有误!");
}
(Q6)输入10个数，输出最大值和最小值
public static void getMaxAndMin(){ try {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第1个数：");
//把第一次输入的数字赋给max和min
int num1 = sc.nextInt();
int max = num1;
int min = num1;
int count = 2;
while(count<=10){
System.out.println("请输入第"+count+"个数字：");
int numx = sc.nextInt();
if(numx>max){
max=numx;//比最大的值还大
}else if(numx<min){
min=numx;//比最小的值还小
}
count++;
}
System.out.println("最大值："+max+", 最小值："+min);
} catch (Exception e) {
System.out.println("输入错误，请重新输入！！！");
getMaxAndMin();
}
}
优化
public static void getMaxAndMin() { try {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第1个数：");
//把第一次输入的数字赋给max和min
int num1 = sc.nextInt();
int max = num1;
int min = num1;
int count = 2;
while (count <= 10) {
try {
System.out.println("请输入第" + count + "个数字：");
int numx = sc.nextInt();
if (numx > max) {
max = numx;//比最大的值还大
} else if (numx < min) {
min = numx;//比最小的值还小
}
count++;
} catch (Exception e) {
System.out.println("输入错误，请重新输入！！！");
sc = new Scanner(System.in);
}
}
System.out.println("最大值：" + max + ", 最小值：" + min);
} catch (Exception e) {
System.out.println("输入错误，请重新输入！！！");
getMaxAndMin();
}
}
2、经典的排序算法
1、冒泡排序
2、选择排序
3、插入排序
4、归并排序
5、希尔排序
6、快速排序
7、堆排序
8、基数排序
(1)冒泡排序
基本思路： 就比如数组里面[3,1,6,2,5] 就是两两比较 31>36> 第一轮3 1 2 5 6 第二轮3 1 2 5 6 第三轮1 2 3 5 6 第四轮1 2 3 5 6
首先通过一个外层的for循环确定比较的轮数，循环元素数量-1轮。
内部通过一个for循环实现每轮的两两元素比较的效果。每轮需要比较的次数都会比上一轮减少一次，通过j元素两两比较通过array[j] > array[j+1]来实现。
补充：后面每轮都按照此方法进行比较，此后的每一轮都需要比前一轮少比较一次，因为前面已经确定了最大元素的位置，为了提高性能，可以不用再和后面确定了位置的元素进行比较。
int[] a= new int[]{3,1,6,2,5};
// 外层for循环控制轮数，循环数组长度-1轮
for (int i=0;i<a.length-1;i++){
// 内层for循环控制比较的次数
for(int k=0;k<a.length-1-i;k++){
if(a[k]>a[k+1]){
var c=a[k];
a[k]=a[k+1];
a[k+1]=c;
}
}
}优化：如果一个数组已经是完全有序的情况下，冒泡排序法仍然会进行逐轮的比较，这无疑是浪费性能的行为。当冒泡的比较中，有一轮如果没有发生交换，则可以确定当前数组已经完全有序，后面的轮数完全不必在进行。故做以下的调整：
public class Test {
public static void main(String[] args) {
int[] a= new int[]{3,1,4,886,2,5};
Boolean Sort=false;
// 外层for循环控制轮数，循环n-1轮
for (int i=0;i<a.length-1;i++){
// 内层for循环控制比较的次数
if(!Sort){
Sort=true;
for(int k=0;k<a.length-1-i;k++){
if(a[k]>a[k+1]){
var c=a[k];
a[k]=a[k+1];
a[k+1]=c;
Sort=false;
}
}}else {
break;
}
}
for (int m=0;m<a.length;m++){System.out.print(a[m]+"\t");}
}}
这样写的思路：首先定义一个全局开关，正常外层是比较的正常次数，内循环开局设为关的，！是非的意思非关就是开了，运行if里面的语句，给它一个开，如果比较里面一轮没有交换，那么这个开，又到！，非开就是关了，然后运行else直接停止程序。
(2)选择排序
基本思路：通过一轮比较，选出最小的那个元素的下标，然后和第一个元素进行交换，第一个元素的位置就可以确定，后面同理 和冒泡一样，都是数组长度减1轮
public static void main(String[] args) { int[] arr = new int[]{11, 2, 33, 24, 15};
for (int i = 0; i < arr.length - 1; i++) {
int k = i;
for (int j = k + 1; j < arr.length; j++) {
if (arr[j] < arr[k]) {
k = j;
}
}
if (k != i) {
int t = arr[k];
arr[k] = arr[i];
arr[i] = t;
}
}
for (int m = 0; m < arr.length; m++) {
System.out.print(arr[m]+"\t");
}
}
- 选择排序比较的轮数和冒泡排序比较的轮数是一样的
- K表示当前最小值的下标，当前是第几轮，k就先代表第几个元素的下标，然后依次和后面的元素进行比较，如果发现比k位置元素小的元素时，改变k的下标，这样一轮过后k代表的位置就是本轮最小的元素，和i进行交换即可
- 如果一轮过后k==i，则说明i本来就是最小的元素，则无需交换提高性能。
(3)插入排序
假设一个数组已经基本有序，则这个时候插入排序就是一个不错的选择。插入排序是先保证左边元素是基本有序的，然后将后面的元素依次和左边元素进行比较，如果比较到一个比自己小的元素时就可以停止比较了，因为左边已经呈现有序状态，找到比自己小的元素时，就不用再往后比较了。
public static void main(String[] args) { int[] arr = new int[]{11, 2, 33, 24, 15};
for (int i = 0; i < arr.length ; i++) {
//arr[j]~arr[j-1]
for (int j = i; j>0; j--) {
if(arr[j]<arr[j-1]){
int t = arr[j];
arr[j] = arr[j-1];
arr[j-1] = t;
}
else{
break;
}
}
}
for (int m = 0; m < arr.length; m++) {
System.out.print(arr[m]+"\t");
}
}
- 插入排序的轮数和冒泡排序一样，但是i从1开始，因为我们假设第一个元素已经是呈现有序状态了。
- 内部循环依次从当前位置开始，和前面元素进行比较，如果找到了比自己小的元素，则停止比较，直接退出本轮比较，进行下一轮比较
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
