目录
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;
}
}
732
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
