新征程day02

第一个任务

1、Java的8中基本类型的复习与使用。

2、Java编写排序算法。（会）

结果一

8种基本类型

1、byte     8位1字节，取值范围 2^-7~2^7-1

2、shot   16位2字节，取值范围 2^-15~2^15-1

3、int      32位4字节，取值范围2^-31~2^31-1

4、long    64位8字节，取值范围2^-63~2^63-1

5、float   32位4字节，取值范围2^-31~2^31-1

6、double 64位8字节，取值范围2^-63~2^63-1

7、char     16位2字节（采用的是unicode编码），取值范围0~2^16-1

8、boolean 没有明确规定大小，取值范围true/false

结果二

排序算法之选择排序

public static void sort2(int[] a) {
        for (int i = 0; i < a.length; i++) {
            int min = i;
            //选出之后待排序中值最小的位置
            for (int j = i + 1; j < a.length; j++) {
                if (a[j] < a[min]) {
                    min = j;
                }
            }
            //最小值不等于当前值时进行交换
            if (min != i) {
                int temp = a[i];
                a[i] = a[min];
                a[min] = temp;
            }
        }
}

排序算法之冒泡排序

public static void sort(int[] a) {
        //外层循环控制比较的次数
        for (int i = 0; i < a.length - 1; i++) {
            //内层循环控制到达位置
            for (int j = 0; j < a.length - i - 1; j++) {
                //前面的元素比后面大就交换
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }

 排序算法之快速排序

import java.util.Scanner;
public class QuicSort {
    public static void sort(int[] arr,int begin,int end) {
        //先定义两个参数接收排序起始值和结束值
        int a = begin;
        int b = end;
        //先判断a是否大于b
        if (a >= b) {
            //没必要排序
            return;
        }
        //基准数,默认设置为第一个值
        int x = arr[a];

        //循环
        while (a < b) {
            //从后往前找,找到一个比基准数x小的值,赋给arr[a]
            //如果a和b的逻辑正确--a<b ,并且最后一个值arr[b]>x,就一直往下找,直到找到后面的值大于x
            while (a < b && arr[b] >= x) {
                b--;
            }
            //跳出循环,两种情况,一是a和b的逻辑不对了,a>=b,这时候排序结束.二是在后面找到了比x小的值
            if (a < b) {
                //将这时候找到的arr[b]放到最前面arr[a]
                arr[a] = arr[b];
                //排序的起始位置后移一位
                a++;
            }

            //从前往后找,找到一个比基准数x大的值,放在最后面arr[b]
            while (a < b && arr[a] <= x) {
                a++;
            }
            if (a < b) {
                arr[b] = arr[a];
                //排序的终止位置前移一位
                b--;
            }
        }
        //跳出循环 a < b的逻辑不成立了,a==b重合了,此时将x赋值回去arr[a]
        arr[a] = x;
        //调用递归函数,再细分再排序
        sort(arr,begin,a-1);
        sort(arr,a+1,end);
    }
    public static  void main(String [] args)
    {
        Scanner scanner=new Scanner(System.in);
        int [] number=new int[11];
        for(int i=0;i<10;i++)
        {
            number[i]=scanner.nextInt();
        }
        sort(number,0,10);
        for(int i=0;i<number.length;i++)
        {
            System.out.println(number[i]);
        }
    }
}

运行结果：

原模原样---没有任何更改。