Java基础50题（4） 31~40题

2018.3.25
Java基础50题系列源码已上传到我的github仓库，有需要的可以自取，欢迎大家提出建议
https://github.com/Lawliet0717/Java-foudamental-50-problems

第31题

题目：数组的逆序
思路：用Collections.reverse()实现

package Java基础50题;

import java.util.ArrayList;
import java.util.Collections;

/*
 *  Lawliet.2018.3.24
 */
/*
 * 数组的逆序
 */
public class example_31 {

    public static void main(String[] args){
        int[] martx ={1,2,5,8,10};
        ArrayList list = new ArrayList();
        for(int i = 0; i < martx.length; i++){
            list.add(martx[i]);
        }

        System.out.print("当前数组为：");
        for(int i = 0; i < list.size(); i++){
            System.out.print(list.get(i) + " ");
        }

        Collections.reverse(list);
        System.out.print("逆序后数组为：");
        for(int i = 0; i < list.size(); i++){
            System.out.print(list.get(i) + " ");
        }
    }
}

第32题

题目：取一个整数a从右端开始的4～7位
思路：把数字作为String类型读入，再转化为char数组

package Java基础50题;

import java.util.Scanner;

/*
 *  Lawliet.2018.3.24
 */
/*
 * 取一个整数a从右端开始的4～7位
 */
public class example_32 {

    public static void main(String[] args){

        Scanner in = new Scanner(System.in);
        long num = in.nextLong();
        String str = Long.toString(num);
        char[] ch = str.toCharArray();
        int len = ch.length;
        if(len >= 7){
            for(int i = 7; i >= 4; i--){
                System.out.print(ch[len-i]);
            }
        }else{
            System.out.println("你输入的数不足7位");
        }

    }


}

第33题

题目：打印出杨辉三角形
思路：每一行的最左边和最右边的元素都是元素。对其他元素来说，tri[i][j] = tri[i-1][j] + tri[i-1][j-1]

package Java基础50题;

/*
 *  Lawliet.2018.3.24
 */
/*
 * 打印出杨辉三角形
 */
public class example_33 {

    public static void main(String[] args){
        int[][] tri = new int[8][];
        for(int i = 0; i < tri.length; i++){
            tri[i] = new int[i + 1];
            for(int j = 0; j < tri[i].length; j++ ){
                if(i == 0 || j == 0 || j == tri[i].length-1){
                    tri[i][j] = 1;
                }else{
                    tri[i][j] = tri[i-1][j] + tri[i-1][j-1];
                }
                System.out.print(tri[i][j] + " ");
            }
            System.out.println();
        }
    }

}

第34题

题目：输入3个数a,b,c，按大小顺序输出。
思路：Arraylist，sort，不再做重复劳动了

第35题

题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
思路：遍历一次数组，找到最大和最小元素，然后交换。

package Java基础50题;

import java.util.Scanner;

/*
 *  Lawliet.2018.3.24
 */
/*
 * 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
 */
public class example_35 {

    public static void swap(int[] arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入数组长度：");
        int len = in.nextInt();
        int[] arr = new int[len];
        System.out.println("请输入数组：");
        for(int i = 0; i < len; i++){
            arr[i] = in.nextInt();
        }
        int maxIndex = 0;
        int minIndex = 0;
        int max = arr[0];
        int min = arr[0];
        for(int i = 1; i < arr.length; i++){
            if(arr[i] > max){
                max = arr[i];
                maxIndex = i;
            }
            if(arr[i] < min){
                min = arr[i];
                minIndex = i;
            }
        }
        swap(arr, 0, maxIndex);
        swap(arr, arr.length-1, minIndex);
        printArray(arr);
    }

}

第36题

题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
思路：Arraylist, add方法可以指定添加的下标

package Java基础50题;

import java.util.ArrayList;
import java.util.Scanner;

/*
 *  Lawliet.2018.3.24
 */
/*
 * 有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数 
 */

public class example_36 {

    public static void changeList(int m, int n){
        ArrayList<Integer> list = new ArrayList<Integer>();
        int tmp;
        for(int i = 0; i < n; i++ ){
            list.add(i);
        }
        System.out.println("原数组为：");
        for(int i = 0; i < list.size(); i++){
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        for(int i = 0; i < m; i++){
            tmp = list.get(n-1);
            list.remove(n-1);
            list.add(0, tmp);
        }
        System.out.println("移动后的数组为：");
        for(int i = 0; i < list.size(); i++){
            System.out.print(list.get(i) + " ");
        }
    }

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入数组个数和移动几位：");
        int n = in.nextInt();
        int m = in.nextInt();
        changeList(m, n);
    }
}

第37题

题目：约瑟夫问题

https://baike.baidu.com/item/%E7%BA%A6%E7%91%9F%E5%A4%AB%E9%97%AE%E9%A2%98/3857719?fr=aladdin

思路：环形链表实现，报到特定数的结点删除，直到剩下最后一个结点

package Java基础50题;

/*
 *  Lawliet.2018.3.25
 */
/*
 * 约瑟夫问题
 */
//环形链表实现
public class example_37 {

    public static class Node{
        public int value;
        public Node next;

        public Node(int date){
            this.value = date;
        }
    }

    //m为报的数字，原题中 m = 3 ， 返回最后没有被杀死的结点
    public static Node josephusKill (Node head, int m){
        if(head == null || head.next == head || m < 1){
            return head;
        }
        Node last = head;
        //last走到头结点的前面一个
        while(last.next != head){
            last = last.next;
        }
        int count = 0;
        while(head != last){
            if(++count == m){
                last.next = head.next;
                count = 0;
            }else{
                last = last.next;
            }
            head = last.next;
        }
        return head;
    }

    public static void main(String[] args){
        //原题有41个人，报到3的自杀，这里用10个结点，报到3自杀作测试
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        Node node6 = new Node(6);
        Node node7 = new Node(7);
        Node node8 = new Node(8);
        Node node9 = new Node(9);
        Node node10 = new Node(10);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        node6.next = node7;
        node7.next = node8;
        node8.next = node9;
        node9.next = node10;
        node10.next = node1;
        Node alive = new Node(0);
        alive = josephusKill(node1, 3);
        System.out.println("存活下来的人是" + alive.value +"号");
    }

}

第38题

题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。
思路：直接用.length()方法

package Java基础50题;

import java.util.Scanner;

/*
 *  Lawliet.2018.3.24
 */
/*
 * 写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。 
 */
public class example_38 {

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        System.out.println(str.length());
    }
}

第39题

题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数求 1/1+1/3+…+1/n
思路：处理好分支，注意下 1/i 要强制转换为double型，不然int型的话一直都是0

package Java基础50题;

import java.util.Scanner;

/*
 *  Lawliet.2018.3.24
 */
/*
 * 编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,
 * 当输入n为奇数时，调用函数求 1/1+1/3+...+1/n
 */
public class example_39 {

    public static void fun(int n){
        double sum = 0;
        if(n % 2 == 0){
            for(int i = 2; i <= n; i += 2){
                sum += (double) 1/i ;
            }
        }else{
            for(int i = 1; i <= n; i += 2){
                sum += (double) 1/i ;
            }
        }
        System.out.println(sum);
    }

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        fun(n);
    }
}

第40题

题目：字符串排序。
思路：转为字符数组，sort排序

package Java基础50题;

import java.util.Arrays;
import java.util.Scanner;

/*
 *  Lawliet.2018.3.24
 */
/*
 * 字符串排序。
 */
public class example_40 {

    public static void printArray(char[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args){
        String str;
        Scanner in = new Scanner(System.in);
        str = in.nextLine();
        char[] ch = str.toCharArray();
        Arrays.sort(ch);
        printArray(ch);
    }
}