Java算法面试题

随~缘

已于 2022-08-03 09:43:56 修改

阅读量204

点赞数

文章标签： java 算法开发语言

于 2022-07-07 19:36:47 首次发布

本文链接：https://blog.csdn.net/qq_44865726/article/details/125665706

版权

1. 最大公约数与最小公倍数

	//辗转相除法  递归实现
		public class Demo02 {
			public static void main(String[] args) {
				Demo02 demo = new Demo02();
				int num = demo.gcd(12, 6);
				System.out.println("最大公约数:"+num);		
			}
			//递归实现
			public int gcd(int a, int b){
				if(b == 0)
					return a;
				else
					return gcd(b, a%b);
			}
		}


	//辗转相除法 基本方法实现
		public class Demo01 {
			public static void main(String[] args) {
				Scanner reader = new Scanner(System.in);
				int n, m, r = 1, temp, a;
				n = reader.nextInt();
				m = reader.nextInt();
				a = n * m;
				//保证n是最大的
				if (n < m) {
					temp = n;
					n = m;
					m = temp;
				}
				//关键代码
				while (r != 0) {
					r = n % m;		 
					n = m;
					m = r;
				}
				System.out.print("最小公倍数："+a / n + "，最大公约数 ："+ n);
			}
		}

//最小公倍数 = 两整数的乘积÷最大公约数

2.冒泡排序(i=0&i<length-1,j=0;j<legnth-1-i)

比较相邻的元素。如果第一个比第二个大，就交换他们两个

		public class Bubble_sort {
		    public static void main(String[] args) {
		        //冒泡排序算法
		        int[] arr=new int[]{10,21,8,16,7,23,12};
		        //需进行length-1次冒泡
		        for(int i = 0; i < arr.length-1;i++){
		            for(int j=0;j<arr.length-1-i;j++){
		                if(arr[j]>arr[j+1]) {
		                    int temp=arr[j];
		                    arr[j]=arr[j+1];
		                    arr[j+1]=temp;
		                }
		            }
		        }
		        System.out.println("从小到大排序后的结果是:");
		        for(int i=0;i<arr.length;i++)
		            System.out.print(arr[i]+" ");
		    }
		}

3.选择排序(i=0&i<length-1, minIndex = i, j=i+1&j<length)

选择排序原理即是，遍历元素找到一个最小（或最大）的元素，把它放在第一个位置，
然后再在剩余元素中找到最小（或最大）的元素，把它放在第二个位置，依次下去，完成排序

		public class SelectionSort {
		    public static void main(String[] args) {
		        int[] arr= new int[] { 5, 3, 6, 2, 10, 18, 1 };
		        selectSort(arr);
		        System.out.println("从小到大排序的结果为: "+ Arrays.toString(num));
		    }
		
		    public static void selectSort(int[] arr) {
		        for (int i = 0; i < arr.length - 1; i++) {
		            int minIndex = i; // 用来记录最小值的索引位置，默认值为i
		            for (int j = i + 1; j < arr.length; j++) {
		                if (arr[j] < arr[minIndex]) {
		                    minIndex = j; // 遍历 i+1~length 的值，找到其中最小值的位置
		                }
		            }
		            // 交换当前索引 i 和最小值索引 minIndex 两处的值
		            if (i != minIndex) {
		                int temp = arr[i];
		                arr[i] = arr[minIndex];
		                arr[minIndex] = temp;
		            }
		            // 执行完一次循环，当前索引 i 处的值为最小值，直到循环结束即可完成排序
		        }
		    }
		}

4.杨氏三角(i=2&i<length,j=1&j<i {arr[i][j]=arr[i-1][j-1]+arr[i-1][j] })

		public class Test {
		
			public static void main(String[] args) {
				int[][] arr =new int[10][10];
				
				//边界赋值
				for(int i=0;i<arr.length;i++){
					arr[i][0] = 1;	//左边界
					arr[i][i] =1;		//右边界
				}
				//内部元素采用递推公式计算
				for(int i=2;i<arr.length;i++){
					for(int j=1;j<i;j++){
						arr[i][j] = arr[i-1][j-1]+ arr[i-1][j];
					}
				}
				//输出杨辉三角形
				for(int i=0;i<arr.length;i++){
					for (int j =0; j <=i; j++) {
						System.out.print(arr[i][j]+"\t");
					}
					System.out.println();
				}
			}
		}

在这里插入图片描述

5.完数问题(i=2&i<=n,j=1&j<i,if(i%j==0)sum=sum+j)

题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。

例如6=1＋2＋3.编程找出1000以内的所有完数。
程序分析：关键是找出数的所有因子，注意因子包含1！不包含本身,但是1不是完数。

		public class PerfectNumber{
		    public static void main(String args[]){
		        int i,j;
		        int sum=0;
		        for(i=2;i<=1000;i++) {
		            for(j=1;j<i;j++) {
		                if(i%j==0) sum=sum+j;
		            }
		            if(sum==i) System.out.println(i);
		            sum=0;
		        }
		    }
		}

6.猴(while(monkeyLeft>1){—if(b[index]{num++&if(num==7) {7为false,num为0 monkeyLeft-- } },index++&if(index=15)){index=0}—}

题目： 15个猴子围成一圈选大王,依次1-7循环报数, 报到7的猴子被淘汰,后面的猴子再从1开始数，
 	   直到最后剩一只猴子称为大王,问:哪只猴子会成为大王?

		public class MonkeyKing {
		    public static void main(String[] args) {
		        //1.定义长度为15的数组保存猴子,boolean类型是为了判断猴子是否存活
		        boolean[] b=new boolean[15];
		
		        //2.依次遍历每一只猴子
		        //true---未淘汰  false---已淘汰
		        for(int i=0;i<b.length;i++){
		            b[i]=true;//先把所有猴子设置成存活
		        }
		        //3.定义变量保存猴子报的数
		        int num=0;
		        //4.定义变量保存剩余的猴子数
		        int monkeyLeft=15;
		        //5.定义数组下标
		        int index=0;
		        //6.循环,直到只剩最后一只猴子(猴子王)
		        while(monkeyLeft>1){//判断条件
		            //7.检测猴子是否已淘汰
		            if(b[index]){
		                //8.报数
		                num++;
		                //9.判断报数是否为7
		                if(num==7){
		                    b[index]=false;//为7淘汰
		                    monkeyLeft--;//猴子数减一
		                    num=0;//报数归零
		                }
		
		            }
		
		            //10.下标移动
		            index++;
		            //11.围成一圈---最后一个置为0
		            if(index==15){
		                index=0;
		            }
		        }
		
		        //遍历数组,找到最后活着的那个猴子王
		        for(int i=0;i<b.length;i++){
		            if(b[i]){
		                System.out.println(i+1);
		            }
		        }
		    }
		}

7.二分法查找(数组索引，从0开始，以数组长度结束，需要找的值)

二分法查找（Binary Search）也称折半查找，是指当每次查询时，将数据分为前后两部分，再用中值和待搜索的值进行比较，
    如果搜索的值大于中值，则使用同样的方式（二分法）向后搜索，反之则向前搜索，直到搜索结束为止。
    
二分法使用的时候需要注意：二分法只适用于有序的数据，也就是说，数据必须是从小到大，或是从大到小排序的。

public class dichotomizingSearch {
 public static void main(String[] args) {
     // 二分法查找
     int[] binaryNums = {1, 6, 15, 18, 27, 50};
     int findValue = 27;
     int binaryResult = binarySearch(binaryNums, 0, binaryNums.length - 1, findValue);
     System.out.println("元素第一次出现的位置（从0开始）：" + binaryResult);
 }
 /**
  * 二分查找，返回该值第一次出现的位置（下标从 0 开始）
  * @param nums      查询数组
  * @param start     开始下标
  * @param end       结束下标
  * @param findValue 要查找的值
  * @return int
  */
 private static int binarySearch(int[] nums, int start, int end, int findValue) {
     if (start <= end) {
         // 中间位置
         int middle = (start + end) / 2;
         // 中间的值
         int middleValue = nums[middle];
         if (findValue == middleValue) {
             // 等于中值直接返回
             return middle;
         } else if (findValue < middleValue) {
             // 小于中值，在中值之前的数据中查找
             return binarySearch(nums, start, middle - 1, findValue);
         } else {
             // 大于中值，在中值之后的数据中查找
             return binarySearch(nums, middle + 1, end, findValue);
         }
     }
     return -1;
 }
 }