算法学习——位运算/简单排序

最新推荐文章于 2021-09-10 21:18:35 发布

孺子韫

最新推荐文章于 2021-09-10 21:18:35 发布

阅读量121

点赞数

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/weixin_45307374/article/details/118051531

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1. 整数打印32位二进制

int num1=31313121;

对计算机来说，整型，底层是二进制数：32位

Long num2=317831378423L;

对计算机来说，Long型，底层是二进制数 ：64位

实现函数：打印num1的32位

public  static void print(int num){

    for(int i=31;i>=0;i--){
    
        System.out.print((num & (1<<i))==0 ? "0" : "1" );
        
    }
    
    System.out.println();
}

实现函数：打印num2的64位

 public  static void print(int num){
        
            for(int i=63;i>=0;i--){
            
                System.out.print((num & (1<<i))==0 ? "0" : "1" );
                
            }
            
            System.out.println();
        }

2.左移和右移的概念

函数实现逻辑：
Java中任意一个整型数字，一定是由32位信息组成的
1——> 00000000000000000000000000000001
2——> 00000000000000000000000000000010

1<<i位的含义：1在32位中使用 00000000000000000000000000000001表示

其中，左移后数据变更为 10000000000000000000000000000000 (其中空余位使用0来补)
& 运算为逻辑运算，只有当两个1相遇才会出1，只要不同，则返回0
    0和1相遇出0
    1和0相遇出0
    0和0相遇出0
    
使用 num数字与 10000000000000000000000000000000 & 完后 

因为 num 底层使用也是32位表示：则出现 每一位与每一位相 & 操作，其中除了首位 31位 会有可能出现 & 1的可能，其他位都为 & 0

num & (1<<i))的结果不为 0 ，那么结果一定是 num 在相应的位上不为0 则，输出相应的 "0" : "1" 取得一个 num 数据的32位形态

num << 1 等于 num * 2 的值

左移只有无符号左移，没有带符号右移

右移

>>  无符号右移：右移
>>> 带符号右移

正数和负数相互转化：取反+1

即：a的相反数为 ~a+1表示

int x = Integer.MIN_VALUE;

System.out.println(x);
// -2147483648

print(x);
// 10000000000000000000000000000000

print(x >> 1);
// 11000000000000000000000000000000

print(x >>> 1);
// 01000000000000000000000000000000

3.反码和补码的逻辑

计算机中32位信息表示的范围理论上可以 2的32次方-1个数

最高位为符号位，实际只使用 2的31次方-1

Java 中整形既可以表示正数和负数

取反符号：~

为什么整形负数最小是：-2147483648

System.out.println(Integer.MAX_VALUE);

为什么整形正数最大是：2147483647

System.out.println(Integer.MIN_VALUE);

0 归属在正数区域，所有负数比正数多一位

系统中，为啥要设计成这样的复杂？

所有的算数符号，+ - * / 底层都是使用 & | ^ 等逻辑计算的

后期实际完善具体内容

为了底层达到无论正数和负数都可以使用一套逻辑门进行计算，计算时忽略正负数

底层设计如此

        int a=12131413;
        int b=324231313;
        
        print(a);// 00000000101110010001110001010101

        print(b);// 00010011010100110110000010010001

        System.out.println("====================");

        print(a | b);
		// 00010011111110110111110011010101

        print(a & b);
		// 00000000000100010000000000010001

        print(a ^ b);
		// 00010011111010100111110011000100

4.算法

1.算法：

1）有具体的问题

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

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

解决一个具体问题的具体流程，并且包含评价好坏的方式

2.算法的分类：

1）分类非常多

2）对于一个新手学习特别重要的分类

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

2、明确值得怎么尝试的流程 ※※※※※

3.为什么图灵可以成为计算机的祖师爷？

第一个程序员，拜伦的女儿

从图灵开始，破解德军密码

不知道怎么算，我值得一种方式怎么试的过程

这个过程才是计算机科学的本质

题目一：

给定一个参数N

返回：1! + 2! + 3! + 4! + …… +N！的结果

package com.ketty.day01;

/**
 * @author 孺子愠
 * @create 2021-10-18 2:04
 *
 * 题目：给定一个参数N
 * 返回：1! + 2! + 3! + 4! + …… +N！的结果
 */
public class Code03_SumOfFactorial {
    // 方式一
    public static long f1(int N) {
        long ans = 0;
        for (int i = 1; i <= N; i++) {
            ans += factorial(i);
        }
        return ans;
    }

    public static long factorial(int N) {
        long ans = 1;
        for (int i = 1; i <= N; i++) {
            ans *= i;
        }
        return ans;
    }
    // 方式二
    public static long f2(int N) {
        long ans = 0;
        long cur = 1;
        for (int i = 1; i <= N; i++) {
            cur = cur * i;
            ans += cur;
        }
        return ans;
    }
    
    // 测试方法
    public static void main(String[] args) {
        int N = 10;
        System.out.println(f1(N));
        System.out.println(f2(N));
    }
}

题目二：选择排序

package com.ketty.day01;

/**
 * @author 孺子愠
 * @create 2021-10-18 2:14
 * <p>
 * 选择排序
 * 0 ~ N-1上选出最小值放到 0 位置上
 * 1 ~ N-1上选出最小值放到 1 位置上
 * 2 ~ N-1上选出最小值放到 2 位置上
 */
public class Code04_SelectionSort {

    public static void selectArray(int[] arr) {
        // 边界条件，为空或者长度小于2 不需要排序
        if (arr == null || arr.length < 2) {
            return;
        }
        int N = arr.length;
        for (int i = 0; i < N; i++) {
            int minValueIndex = i;
            for (int j = i + 1; j < N; j++) {
                minValueIndex = arr[j] < arr[minValueIndex] ? j : minValueIndex;
            }
            swap(arr, i, minValueIndex);
        }
    }

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

    // 打印数组
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 65, 7, 9, 53, 23, 76, 98, 323, 53, 65, 76, 87, 96, 42};
        printArray(arr);
        selectArray(arr);
        printArray(arr);
    }
}

题目三：冒泡排序

package com.ketty.day01;

/**
 * @author 孺子愠
 * @create 2021-10-18 2:30
 * <p>
 * 冒泡排序
 */
public class Code05_BubbleSort {

    public static void bubbleSort(int[] arr) {
        // 边界条件，为空或者长度小于2 不需要排序
        if (arr == null || arr.length < 2) {
            return;
        }
        int N = arr.length;
        for (int end = N - 1; end >= 0; end--) {
            for (int second = 1; second <= end; second++) {
                if (arr[second - 1] > arr[second]) {
                    swap(arr, second - 1, second);
                }
            }
        }
    }

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

    // 打印数组
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 65, 7, 9, 53, 23, 76, 98, 323, 53, 65, 76, 87, 96, 42};
        printArray(arr);
        bubbleSort(arr);
        printArray(arr);
    }
}

题目四：插入排序

package com.ketty.day01;

/**
 * @author 孺子愠
 * @create 2021-10-18 23:59
 * 插入排序
 */
public class Code06_insertSort {

    public static void insertSort(int[] arr) {
        // 边界条件，为空或者长度小于2 不需要排序
        if (arr == null || arr.length < 2) {
            return;
        }
        int N = arr.length;
        for (int end = 1; end < N; end++) {
//            第一种方式
//            int newNumIndex = end;
//            while (newNumIndex - 1 >= 0 && arr[newNumIndex - 1] > arr[newNumIndex]) {
//                swap(arr, newNumIndex - 1, newNumIndex);
//                newNumIndex--;
//            }
//            第二种方式
            for (int pre = end-1; pre >=0 && arr[pre]>arr[pre+1] ; pre--) {
                swap(arr,pre,pre+1);
            }
        }
    }

    /**
     * 交换
     * @param arr
     * @param i
     * @param j
     */
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[j];
        arr[j] = arr[i];
        arr[i] = tmp;
    }

    // 打印数组
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {1, 4, 65, 7, 9, 53, 23, 76, 98, 323, 53, 65, 76, 87, 96, 42};
        printArray(arr);
        insertSort(arr);
        printArray(arr);
    }
}

孺子韫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
算法学习——位运算/简单排序

第一节课：1. 整数打印32位二进制int num1=31313121;对计算机来说，整型，底层是二进制数：32位Long num2=317831378423L;对计算机来说，Long型，底层是二进制数：64位实现函数：打印num1的32位public static void print(int num){ for(int i=31;i>=0;i--){ System.out.print((num & (1<<i))=
复制链接

扫一扫