目录
Java的基本数据类型中,数值类型(byte、short、int、long、float、long)这几种都是有符号数,最高位为符号位,0-->非负数,1-->负数,
1个字节代表8个bit位,即8位二进制数,byte、short、int、long,分别对应1、2、4、8个字节,8、16、32、64个bit位
例如:int类型-->一共有2^32个数,表示的范围是( -2^31 ~ 2^31-1 ),
负数其实就是正数先取反再加1,这么做的目的,是为了在底层运算时实现同一套逻辑运算规则
例如:+5(0 000000.....101)
-5 (1 111111......010)先取反,(1 111111......011)再加1
二进制 0的相反数还是0 --->0 000000......000 原因是 取反再加1之后得到相反数 理论上应该是 1 11111......111,再加1,是100000......000,但溢出了,首位1就被舍去了,最后还是0 000000......000
二进制最大数是 0 111111......111 ,最小数理论上是符号位先是1 最后所有位都是1,但是负数最小值的绝对值比正数最大值多1,给1 111111.....111加上1后,进位变成1 100000......000 ,但是溢出了,首位1就被舍去了,所以就变成了 1 000000......000
如何让一个数(例如int类型的),以二进制形式输出
public static void print(int num){
//直接打印num,现实的是十进制,通过它在进行位运算的时候,默认以二进制形式,那么我们在不改变它的值的时候
for(int i = 31; i >= 0; i--){
//让它每次与1左移i位的数进行与运算,这样原本第i位是0的最终结果是0,第i位是1的结果保留1,一共进行了32次运算,把结果拼起来就是32位二进制表达式
System.out.print((num&(1 <<i)) == 0 ? "0":"1");
}
System.out.println();
}
位运算
位运算:左移1位 <==>十进制的值 * 2^1 ; 左移n位 <==>十进制的值 * 2^n 二进制数字逐个向左移动1位其余位拿0来补
>>1 带符号右移1位 ; >>>1 不带符号右移1位
算法是什么
1.有具体的问题
2.有设计解决这个问题的具体流程
3.有评价处理流程的可量化指标
算法的分类
算法的分类有很多,对于新手特别重要的一个分类
1.明确知道怎么算的流程
2.明确知道怎么尝试的流程
选择排序
一、选择排序(Selection sort)
是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
二、算法实现(设有n个元素)
①.从第一个元素开始,比较所有未排序的元素,并标记最小(大)元素,将最小(大)元素与未排序的第一个元素进行交换。 ②.此时第一个元素已经确保为整个序列最小的,再次排序时,接着遍历数组中除第一个元素外的剩余部分,找到剩余部分中的最小元素,将其与第二个元素交换位置。
③不断重复①②步骤,直到数组中所有元素都排序完成。
三、代码实现
public class SelectionSort {
//选择排序,把给定数组,从小到大排序
public static void selectSort(int[] arr) {
//边界条件
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length; i++) {
//从0~n-1的范围选一个最小值放在此范围开头-->从1~n-1的范围选一个最小值放在开头
// -->从2~n-1的范围选一个最小值放在此范围开头
//假设i的位置是最小值
int minValueIndex = i;
//i往后所有位置看一遍,看是否更新最小值位置
for (int j = i + 1; j < arr.length; j++) {
//如果j位置元素比当初定的位置最小元素还要小,那么更新,j位置变成最小位置,否则维持不变
minValueIndex = arr[j] < arr[minValueIndex] ? j : minValueIndex;
}
//最小位置的数和 i 进行交换,让最小排在开头
swap(arr, i, minValueIndex);
}
}
//交换元素
public static void swap(int[] arr, int i, int j) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
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 = {2, 4, 3, 5, 1, 4, 1, 4, 32, 5, 52, 10};
//打印未排序数组
printArray(arr);
//给数组排序
selectSort(arr);
//打印排序后的数组
printArray(arr);
}
}
冒泡排序
一、冒泡排序(Bubble Sort)
通过对待排序序列从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒。
二、算法实现
①.每两个相邻的数依次比大小,大的数交换排后面,
②. 重复步骤①直到把最大的数排到最后一位,
③.接着从头开始进行相邻数比较、交换,直到把第二大的交换排到倒数第二位,
④重复①~③步骤,直到把整个数组排成从小到大的顺序
三、代码实现
public class BubbleSort {
//冒泡排序
public static void bubbleSort(int[] array) {
//边界条件
if (array == null || array.length < 2) {
return;
}
int N = array.length ;
//从最后一个位置开始比较,确保每次比较后,后面位置的数是最大的数
//从后往前依次确定位置,最大的数在最后一个位置,第二大的在倒数第二位置
for (int end = N-1; end >= 0; end--) {
//从第二个位置(second)开始 两两相邻的数 依次比较,直到比到末尾
for (int second = 1;second <= end;second++){
//如果前一个数 大于 后一个数 就交换位置
if (array[second-1]>array[second]){
swap(array,second-1,second);
}
}
}
}
//交换元素
private static void swap(int[] array,int i,int j) {
int temp = array[j];
array[j] = array[i];
array[i] = temp;
}
//打印数组
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] arr = {2, 34, 1, 5, 3, 2, 5, 6, 8, 65, 3, 2};
printArray(arr);
bubbleSort(arr);
printArray(arr);
}
}
插入排序
一、直接插入排序(Insertion Sort)类比于斗地主的摸牌理牌阶段
整个区间被分为
有序区间 和 无序区间 每次选择无序区间的第一个元素,在有序区间内选择合适的位置, 然后再插入这个元素. 其中第一部分有序区间的排序也是通过再次拆分为两部分来进行的.
二、算法实现
一般来说,插入排序都采用in-place在数组上实现。具体算法描述如下:
①. 从第一个元素开始,该元素可以认为已经被排序 ②. 取出下一个元素,在已经排序的元素序列中从后向前扫描 ③. 如果该元素(已排序)大于新元素,将该元素移到下一位置 ④. 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置 ⑤. 将新元素插入到该位置后 ⑥. 重复步骤②~⑤
三、代码实现
public class InsertionSort {
public static void main(String[] args) {
int[] arr = {2, 34, 1, 5, 3, 2, 5, 6, 8, 65, 3, 2};
printArray(arr);
insertionSort01(arr);
printArray(arr);
insertionSort02(arr);
printArray(arr);
}
//插入排序
private static void insertionSort01(int[] array) {
//边界条件
if (array == null || array.length < 2) {
return;
}
int N = array.length;
//从第二个位置开始作为插入位置
for (int end = 1; end < N; end++) {
//新来的数插入位置放在已排序列的尾部
int newnumIndex = end;
//如果新来的数所在位置左边有数,并且左边的数大于新来的数
//新来的数所在位置左边没有数,或者没有比它大的数,就停止
while (newnumIndex - 1 >= 0 && array[newnumIndex - 1] > array[newnumIndex]) {
//交换位置
swap(array, newnumIndex - 1, newnumIndex);
//新来的数所在位置向前移动
newnumIndex--;
}
}
}
//插入排序2
private static void insertionSort02(int[] array) {
//边界条件
if (array == null || array.length < 2) {
return;
}
int N = array.length;
//从第二个位置开始作为插入位置
for (int end = 1; end < N; end++) {
//pre 新数的前一个位置
for (int pre = end - 1;pre >= 0 && array[pre] > array[pre+1];pre--){
swap(array,pre,pre+1);
}
}
}
//打印数组
private static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
//交换元素
private static void swap(int[] array, int i, int j) {
int temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}