Java学习笔记day07_琐碎知识_水仙花数_ASCII码_冒泡排序_简单选择排序_折半查找

琐碎知识: 水仙花数, ASCII码, 冒泡排序, 简单选择排序, 折半查找

1.水仙花数

　　每位数的平方的和等于本身.

　　如100到999之间的水仙花数满足: 个位的平方+十位的平方+百位的平方 = 本身.

　　

public class Test02{
    public static void main(String[] args){
        int g = 0;//存储个位
        int s = 0;//存储十位
        int b = 0;//存储百位
        
        for(int i=100; i<999; i++)
        {
            g = i%10;//获取各位. 如365%10=5
            
            //s = (i%100 - g) / 10;
            s = i/10%10;//获取十位. 如365/10=36,36%10=6
            
            //b = (i - s*10 - g) / 100;
            b = i/100;//获取百位. 如365/100=3
            
            if(g*g*g+s*s*s+b*b*b == i)
                System.out.println(i);
        }
    }
}

2.ASCII码

　　数字0-9对应　　-　　48-57

　　字母A-Z对应　   -　　65-90　　

　　字母a-z对应　　-　　97-122

　　同一个字母的大小写相差32.

3.冒泡排序

　　从后往前(或从前往后)两两比较相邻元素, 若不满足排序规则就交换位置, 直到序列比较完, 至此一趟比较完毕.

//冒泡排序
public class BubbleSort{
    public static void main(String[] args){
        int[] arr = {9,6,5,4,8,7,1,2,3};
        bubbleSort(arr);
    }
    
    
    
    /*
        冒泡排序
    */
    public static void bubbleSort(int[] arr){
        for(int i=0; i<arr.length-1; i++)
        //外层循环控制每轮比较的次数
            for(int j=arr.length-1; j>i; j--)
            {//内层循环从后往前相邻两个数进行比较,较小的放在前面的位置
                if(arr[j]<arr[j-1]){
                    int temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                }
            }
            
        for(int i=0; i<arr.length; i++)
            System.out.print(arr[i]+" ");
    }
}

4.简单选择排序

　　第 i 趟循环在后面的n-i 个待排序的元素中选出最小(或最大)的关键字, 将其与序列的第 i 个元素交换位置.

/*
    简单选择排序
*/

public class SelectSort{
    public static void main(String[] args){
        int[] arr = {7,4,5,8,9,6,1,2,3};
        SelectSort(arr);
        
    }
    
    /*
        定义方法,实现数组的选择排序
        实现步骤:
            1.嵌套循环实现排序
              外循环控制一共比较了多少次
              内循环可控制每次比较了多少个元素
            2.判断元素的大小值
              小值,存储到小的索引
    */
    public static void SelectSort(int[] arr){
        for(int i=0; i<arr.length-1; i++)
        {
            for(int j=i+1; j<arr.length; j++)
            {
                //数组的元素进行判断
                if(arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        
        for(int i=0; i<arr.length; i++)
            System.out.print(arr[i]+" ");
    }
}

5.折半查找

　　又称二分查找.

　　将定值key与序列中间位置元素比较, 若查找成功,返回该元素的位置. 若不等, 则所需查找的元素只能在中间元素以外的前半部分或后半部分中. 根据大小关系确定在哪部分中继续进行折半查找. 直到查找成功, 或查找失败.

/*
    折半查找(二分查找)
*/
import java.util.*;
public class BinarySearch{
    public static void main(String[] args){
        int[] arr = {5,6,7,8,17,18,25,27,33,35,37,57};//6,17,27,35,57
        Scanner sc = new Scanner(System.in);
        int s = sc.nextInt();
        System.out.println(binarySearch(arr, s));
    }
    
    
    //折半查找方法
    //参数:有序表,要查找的值
    //返回值:若找到,要查找的值在有序表的位置(索引)
    //若未查找到,返回-1;
    public static int binarySearch(int[] arr, int key){
        int low = 0, high = arr.length-1, mid;
        while(low<=high)    //小于等于!!!
        {
            mid = (low+high)/2;
            if(arr[mid]==key)
                return mid;
            else if(arr[mid]<key)
                low = mid+1;
            else
                high = mid-1;
        }
        return -1;
    }
}