经典编程题解析-优快云博客

本文链接：https://blog.youkuaiyun.com/lei20172017/article/details/121084232

1.完数

/**
 * 如果一个数等于其所有因子之和,我们就称这个数为"完数",
 * 例如 6的因子为1,2,3  6=1+2+3   
 * 6就是一个完数.请编程打印出1000以内所有的完数
 */
class wanshu {
    public static void main(String[] args) {
        int i,j;
        for(i=1;i<=1000;i++){   //判断一千以内的完数
            int sum=0;
            for(j=1;j<i;j++){
               if(i%j==0)       // 判断i的因子
                  sum=sum+j;
            }
            if(sum==i)          // 判断该数因子的和是否为完数
                System.out.print(i+"\t");//6 28 496
        }
    }
}

2.水仙花数

/**
 * 打印出所有的"水仙花数"，
 * 所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
 * 例如：153 是一个"水仙花数"，因为153=1³＋5³＋3³。
 */

class NarciNum {
    public static void main(String [] args){
        for(int z = 100; z>=100&&z<1000; z++){
            int i=0;
            i=z/100;
            int j=z/10%10;
            int x=z/1%10;;
            if(j*j*j+i*i*i+x*x*x==z)
                System.out.println(z+"是水仙花数");
        }

    }
}

3.素数

//列出1-1000的质数/素数

class PrimeNumber {
    public static void main(String[] args) {
        for(int i  = 2 ; i <= 1000 ; i++){
            boolean flag = true;
            for(int j = 2 ; j < i ; j++){
                if(i % j == 0){
                    flag = false;
                    break;
                }
            }
            if(flag){
                System.out.println(i);
            }
        }
    }
}

4.阿姆斯特朗数


/**
 * 如果一个n位正整数等于其各位数字的n次方之和,则称该数为阿姆斯特朗数。
 * 例如1^3 + 5^3 + 3^3 = 153
 * 当n=3时，又称水仙花数，特指一种三位数，其各个数之立方和等于该数。
 * 水仙花数共有4个，分别为：153、370、371、407
 */
class Test{
    public static void main(String[] args){
        for(int i = 1 ;i<= 999 ;i++) show(i);
    }
    public static void show(int i){ 
        int sum = 0;
        int temp = i;
        String str = i+"";
        while(temp != 0){
            int num = temp % 10;
            sum += Math.pow(num,str.length());
            temp /= 10;
        }
        if(sum == i) System.out.println(i);
    }
}

5.斐波那契数列

//斐波那契数列

class Fib {
    public static void main(String args[]) {
        for (int i = 1; i <= 20; i++)
            System.out.println(f(i));
    }
    public static int f(int x) {
        if (x == 1||x == 2)
            return 1;
        else
            return f(x - 1) + f(x - 2);
    }
}

6.最大公约数和最小公倍数

import java.util.Scanner;

class GCDLCM {
	// 最大公约数
	public static int get_gcd(int n1, int n2) {
		int gcd = 0;
		if (n1 < n2) {// 交换n1、n2的值
			n1 = n1 + n2;
			n2 = n1 - n2;
			n1 = n1 - n2;
		}
		if (n1 % n2 == 0) {
			gcd = n2;
		}
		while (n1 % n2 > 0) {
			n1 = n1 % n2;
			if (n1 < n2) {
				n1 = n1 + n2;
				n2 = n1 - n2;
				n1 = n1 - n2;
			}
			if (n1 % n2 == 0) {
				gcd = n2;
			}
		}
		return gcd;
	}

	// 最小公倍数
	public static int get_lcm(int n1, int n2) {
		return n1 * n2 / get_gcd(n1, n2);
	}
	
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.print("请输入第一个整数：");
		int n1 = input.nextInt();
		System.out.print("请输入第二个整数：");
		int n2 = input.nextInt();
		System.out.println("最大公约数：" + "(" + n1 + "," + n2 + ")" + "=" + get_gcd(n1, n2));
		System.out.println("最小公倍数：" + "[" + n1 + "," + n2 + "]" + "=" + get_lcm(n1, n2));
	}
}

7.字符统计

/*
    将字符串以a(字母)=>2(个数)存入Map集合框架中
   思路:1.将字符串转换成字符数组.
          2.定义一个Map集合,然后对字符数组进行遍历,如果Map集合中没有该元素就将该元素存入Map集合中,并定义一个计数器,将次数存入Map中,来达到目的 

*/
import java.util.*;
class CharMapDemo{
    public static void main(String[] args){
        String str2 = "";
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入字符串：");
        if (scan.hasNextLine()) {
            str2 = scan.nextLine();
        }
        scan.close();
        TreeMap<Character,Integer> tm = Pross(str2);
        System.out.println(tm);
    }
    
    public static TreeMap<Character,Integer> Pross(String str){
            char[] charArray = str.toCharArray();
            TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
            for (int x = 0; x < charArray.length ;x++ ){
                if(!tm.containsKey(charArray[x])){
                    tm.put(charArray[x],1);
                }else{
                    int count = tm.get(charArray[x])+1;
                    tm.put(charArray[x],count);
                }
            }
            return tm;
    }
}

8.回文判断

import java.util.*;
class HuiWen{
    public static void main(String[] args){
        String str = "abac";
        if(judge(str)){
            System.out.println("true");
        }else{
            System.out.println("false");
        }  
            
    }
    public static boolean judge (String str) {
        int len = str.length();
        for(int i = 0 ; i < len/2 ;i++) 
            if(str.charAt(i)!=str.charAt(len-1-i)) 
                return false;
        return true;
    }
    
}

import java.util.*;
/**
 *回文数
 */

public class Solution {
    /**
     * 
     * @param x int整型 
     * @return bool布尔型
     */
    public boolean isPalindrome (int x) {
        // write code here
        // 边界判断
        if (x < 0) return false;
        int div = 1;
        //
        while (x / div >= 10) div *= 10;
        // 循环停止
        while (x > 0) {
            int left = x / div;
            int right = x % 10;
            // 如果不同则表示不是回文
            if (left != right) return false;
            x = (x % div) / 10;
            div /= 100;
        }
        return true;
    }
}

9.归并排序

//归并排序

class MergeSort {
    //两路归并算法，两个排好序的子序列合并为一个子序列
    public void merge(int []a,int left,int mid,int right){
        int []tmp=new int[a.length];//辅助数组
        int p1=left,p2=mid+1,k=left;//p1、p2是检测指针，k是存放指针

        while(p1<=mid && p2<=right){
            if(a[p1]<=a[p2])
                tmp[k++]=a[p1++];
            else
                tmp[k++]=a[p2++];
        }

        while(p1<=mid) tmp[k++]=a[p1++];//如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
        while(p2<=right) tmp[k++]=a[p2++];//同上

        //复制回原素组
        for (int i = left; i <=right; i++) 
            a[i]=tmp[i];
    }

    public void mergeSort(int [] a,int start,int end){
        if(start<end){//当子序列中只有一个元素时结束递归
            int mid=(start+end)/2;//划分子序列
            mergeSort(a, start, mid);//对左侧子序列进行递归排序
            mergeSort(a, mid+1, end);//对右侧子序列进行递归排序
            merge(a, start, mid, end);//合并
        }
    }

    public static void main(String[] args){
        int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
        MergeSort merge = new MergeSort();
        merge.mergeSort(a, 0, a.length-1);
        System.out.println("排好序的数组：");
        for (int e : a)
            System.out.print(e+" ");
    }
}

10.冒泡排序

class bubble_sort {
    public static void main(String[] args) {
        //冒泡排序算法
        int[] numbers=new int[]{1,5,8,2,3,9,4};
        //需进行length-1次冒泡
        for(int i=0;i<numbers.length-1;i++)
        {
            for(int j=0;j<numbers.length-1-i;j++)
            {
                if(numbers[j]>numbers[j+1])
                {
                    int temp=numbers[j];
                    numbers[j]=numbers[j+1];
                    numbers[j+1]=temp;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for(int i=0;i<numbers.length;i++)
            System.out.print(numbers[i]+" ");
    }
}

11.选择排序

//选择排序
class SelectionSort {
    public static void main(String[] args) {
        int[] arr={1,3,2,45,65,33,12};
        System.out.println("交换之前：");
        for(int num:arr){
            System.out.print(num+" ");
        }        
        //选择排序的优化
        for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;
            for(int j = k + 1; j < arr.length; j++){// 选最小的记录
                if(arr[j] < arr[k]){ 
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if(i != k){  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }    
        }
        System.out.println();
        System.out.println("交换后：");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }

}

12.插入排序

class Insert
{
	public static void main(String[] args)
	{
		int[] ins = {2,3,5,1,23,6,78,34};
		int[] ins2 = sort(ins);
		for(int in: ins2){
			System.out.println(in);
		}
	}
 
    public static int[] sort(int[] ins){
		
		for(int i=1; i<ins.length; i++){
			int temp = ins[i];//保存每次需要插入的那个数
			int j;
			for(j=i; j>0&&ins[j-1]>temp; j--){//这个较上面有一定的优化
				ins[j] = ins[j-1];//吧大于需要插入的数往后移动。最后不大于temp的数就空出来j
			}
			ins[j] = temp;//将需要插入的数放入这个位置
		}
		return ins;
	}
}

13.快速排序

import java.util.Arrays;
class QuickSort{
    public static void main (String[] args) {
        int[] arr = new int[] {7,1,9,2,5,3,12,4};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    /**
     * 快速排序
     * @param array
     */
    public static void quickSort(int[] array) {
        int len;
        if(array == null
                || (len = array.length) == 0
                || len == 1) {
            return ;
        }
        sort(array, 0, len - 1);
    }

    /**
     * 快排核心算法，递归实现
     * @param array
     * @param left
     * @param right
     */
    public static void sort(int[] array, int left, int right) {
        if(left > right) {
            return;
        }
        // base中存放基准数
        int base = array[left];
        int i = left, j = right;
        while(i != j) {
            // 顺序很重要，先从右边开始往左找，直到找到比base值小的数
            while(array[j] >= base && i < j) {
                j--;
            }
    
            // 再从左往右边找，直到找到比base值大的数
            while(array[i] <= base && i < j) {
                i++;
            }
    
            // 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
            if(i < j) {
                int tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            }
        }
    
        // 将基准数放到中间的位置（基准数归位）
        array[left] = array[i];
        array[i] = base;
    
        // 递归，继续向基准的左右两边执行和上面同样的操作
        // i的索引处为上面已确定好的基准值的位置，无需再处理
        sort(array, left, i - 1);
        sort(array, i + 1, right);
    }
}

14.二分查找



 class binarySearch {
    public static void main(String[] args) {
        int[] array ={1,2,3,4,6,7,8,9,10};
        System.out.println( binSearch_2(3,array,0,array.length-1));
        System.out.println( binSearch_2(5,array,0,array.length-1));
    }

    /*
     *循环实现二分算法
     */
    public static int binSearch_1(int key, int[] array) {
        int low = 0; //第一个下标
        int high = array.length - 1;//最后一个下标
        int middle = 0;
        //防越界
        if (key < array[low] || key > array[high] || low > high) {
            return -1;
        }
        while (low <= high) {
            middle = (low + high) / 2;
            if (middle == key) {
                return array[middle];
            } else if (middle < key) {
                low = middle + 1;
            } else {
                high = middle - 1;
            }
        }
        return -1;
    }

    /*
     *递归实现二分算法
     */
    public static int binSearch_2(int key,int[] array,int low,int high){
        //防越界
        if (key < array[low] || key > array[high] || low > high) {
            return -1;
        }
        int middle = (low+high)/2;
        if(array[middle]>key){
            //大于关键字
            return  binSearch_2(key,array,low,middle-1);
        }else if(array[middle]<key){
            //小于关键字
            return binSearch_2(key,array,middle+1,high);
        }else{
            return array[middle];
        }
    }
}

15.二叉树先序遍历


//前序遍历的递归实现与非递归实现
import java.util.Stack;
class Test {
	public static void main(String[] args){
		TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
		for(int i = 0; i < 10; i++)
			node[i] = new TreeNode(i);
		for(int i = 0; i < 10; i++){
			if(i*2+1 < 10)
				node[i].left = node[i*2+1];
			if(i*2+2 < 10)
				node[i].right = node[i*2+2];
		}
		
		preOrderRe(node[0]);
	}
	
	public static void preOrderRe(TreeNode biTree){//递归实现
		System.out.println(biTree.value);
		TreeNode leftTree = biTree.left;
		if(leftTree != null){
			preOrderRe(leftTree);
		}
		TreeNode rightTree = biTree.right;
		if(rightTree != null){
			preOrderRe(rightTree);
		}
	}

	public static void preOrder(TreeNode biTree){//非递归实现
		Stack<TreeNode> stack = new Stack<TreeNode>();
		while(biTree != null || !stack.isEmpty()){
			while(biTree != null){
				System.out.println(biTree.value);
				stack.push(biTree);
				biTree = biTree.left;
			}
			if(!stack.isEmpty()){
				biTree = stack.pop();
				biTree = biTree.right;
			}
		}
	}
}
 
class TreeNode{//节点结构
	int value;
	TreeNode left;
	TreeNode right;
	TreeNode(int value){
		this.value = value;
	}
}