java面向对象练习

最新推荐文章于 2025-12-15 09:30:09 发布

原创最新推荐文章于 2025-12-15 09:30:09 发布 · 409 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法 #算法 #java

面向对象实战

冒泡排序

    public static void main(String[] args) {
        int[]arr=new int[]{3,5,7,2,9,0,6,1,8,4};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void sort(int[]arr){
        for (int i = 0; i < arr.length-1; i++) {
            boolean flag=false;
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    int tmp=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=tmp;
                }
            }
            if(!flag)break;
        }
    }

二分搜索算法

有一个从小到大排序的数组，给一个目标值target，找到这个值在数组中的对应下标，没有就返回-1。

普通的搜索：

    public static void main(String[] args) {
        int[]arr={1,3,4,6,7,8,10,11,13,15};
        System.out.println(search(arr,13));
    }

    private static int search(int[]arr,int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > target) break; //有序数组的优化
            if (arr[i] == target) return i;
        }
        return -1;
    }

二分搜索：

    public static void main(String[] args) {
        int[]arr={1,3,4,6,7,8,10,11,13,15};
        System.out.println(search(arr,13));
    }

    private static int search(int[]arr,int target) {
        int left=0,right= arr.length-1;
        while (left<=right){
            int mid=(left+right)/2;
            int i=arr[mid];
            if(i<target)
                left=mid+1;
            else if(i>target)
                right=mid-1;
            else
                return mid;
        }
        return -1;
    }

青蛙跳台阶问题

一共有n个台阶，一只青蛙每次只能跳1或2阶，一共有多少种跳到顶端的方案：

    public static void main(String[] args) {
        System.out.println(jump(6));
    }

    private static int jump(int n){
        int[] arr=new int[n+1];
        arr[0]=1;
        arr[1]=1;
        for (int i = 2; i <=n ; i++)
            arr[i]=arr[i-1]+arr[i-2];
        return arr[n];
    }

用递归程序设计：

    public static void main(String[] args) {
        System.out.println(jump(6));
    }

    private static int jump(int n){
        if(n==0||n==1) return 1;
        return jump(n-1)+jump(n-2);
    }

回文串判断

“回文串”是一个正反读都一样的字符串，实现一个程序判断用户输入的字符串（仅出现英文字符）是否为回文串：

    public static void main(String[] args) {
        System.out.println(test());
    }

    public static boolean test(){
        Scanner scanner=new Scanner(System.in);
        String str=scanner.nextLine();
        char[] chars=str.toCharArray();
        int i=0, j= chars.length-1;
        while (i<j){
            if(chars[i]!=chars[j])
                return false;
            i++;
            j--;
        }
        return true;
    }

汉诺塔求解

在一根柱子上从小到大摞了一些圆盘（上小下大），按大小顺序重新摆放到另一根柱子上，并且规定，在小圆盘上不能放大圆盘，在三跟柱子之间一次只能移动一个圆盘。

    public static void main(String[] args) {
        hanoi('A','B','C',3);
    }

    //将n片圆盘从A移动到C
    static void hanoi(char a,char b,char c,int n){
        if(n == 1){
            System.out.println(a+"-->"+c);
        } else {
            hanoi(a,c,b,n-1);
            System.out.println(a+"-->"+c);
            hanoi(b,a,c,n-1);
        }
    }