1.位运算与简单的排序

1.位运算

1.1二进制与位运算

int底层是32位的数。long是64位的数

打印整数的32位

package com.hanlin.code;

public class Code01 {

    public static void print(int num){
        for (int i = 31; i >= 0; i--) {
            //num 的位运算 num 底层是32位数，将1左移i位 如果等于0 那就打印0，等于1 就打印1
            System.out.print((num & (1 << i )) ==0 ? "0":"1");
        }
        System.out.println();
    }
    public static void main(String[] args) {
            //print(32);
        print(~Integer.MIN_VALUE+1);
    }
}

1.2"<<"左移：

如：（1<<31）：将1向左移动31位，移动后右边的用0补

1.3负数怎么表示：

符号位：整数的第32位为符号位“1”就表示负数

负数的二进制计算：取反后加1

1.4右移">>"

">>"：带符号位的右移；右移后的左边的用符号位代替

">>>"不带符号位的右移；右移后的左边用"0"代替

2.什么是算法：

2.1 有具体的问题

2.2 有设计解决这个问题的具体流程

2.3 有评价处理流程的可量化指标

3.算法的分类

1.明确知道怎么算的流程

2.明确知道怎么尝试的流程

3.1实践题：求N的阶乘

package com.hanlin.code;

public class Code02 {

    

    public static int f1(int N){
        int sum = 0;
        int mut = 1;
        for (int i = 1; i <= N; i++) {
           mut =mut * i;
           sum += mut;
        }
        return sum;
    }
    public static void main(String[] args) {
        System.out.println(f1(10));
    }
}

4.排序算法 4.1选择算法

package com.hanlin.code;

import java.util.Arrays;

public class SelectSort {
    public static void selectSort(int[] arr){
        //设置边界条件
        if (arr==null || arr.length<2){
            return;
        }
        
        int N = arr.length;
        //控制循环的轮数最大不能超过arr.length轮
        for (int i = 0; i < N; i++) {
            //将i+1后面的数拿到作比较
            for (int j = i + 1; j < N; j++) {
                //假设i的位置就是最小值
                int minValueIndex = i;
                //如果i的后一位比前一位小就将后一位的下标拿到
                minValueIndex = arr[j] < arr[minValueIndex] ? j :minValueIndex;
                //交换位置
                swIndex(arr,minValueIndex,i);
            }
        }

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

    public static void printArr(int[] arr){
        System.out.println(Arrays.toString(arr));
    }
    public static void main(String[] args) {
        int[] arr = {34,44,5,23,8,3,90,99};
        printArr(arr);
        selectSort(arr);
        printArr(arr);
    }
}

4.2冒泡排序

package com.hanlin.code;

import java.util.Arrays;

public class BubbleSort {
    public static void bubbleSort(int [] arr){
        if(arr ==null ||arr.length<2)return;
        int N = arr.length;
        //从数组最大的下标开始，
      for (int end=N-1;end>=0;end--){
          //拿到第一个下标与后面一个比较
          for (int second =1;second 
4.3插入排序 
package com.hanlin.code;

import java.util.Arrays;

public class InsertSort {
    public static void insertSort(int[] arr){
        if (arr.length<2 || arr==null) {
            return;
        }
        int N = arr.length;
       for (int end = N;end=0 && arr[newIndex-1]>arr[newIndex]){
               swIndex(arr,newIndex,newIndex-1);
               newIndex--;
           }
       }
    }
    public static void insertSort1(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return;
        }
        int N = arr.length;
        for (int end = 1; end=0 && arr[pre]>arr[pre+1];pre--){
                swIndex(arr,pre,pre+1);
            }
        }
    }
    public static void swIndex(int[] arr,int i,int j){
        int switchIndex = arr[j];
        arr[j] = arr[i];
        arr[i] = switchIndex;
    }

    public static void printArr(int[] arr){
        System.out.println(Arrays.toString(arr));
    }
    public static void main(String[] args) {
        int[] arr = {34,44,5,23,8,3,90,99};
        printArr(arr);
        insertSort(arr);
        printArr(arr);
    }
}