第1节 位运算、算法是什么、简单排序

最新推荐文章于 2024-05-21 23:16:53 发布
最新推荐文章于 2024-05-21 23:16:53 发布
阅读量201 收藏
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaosong0623/article/details/125172842
版权

前言：

最近在看左神的算法课，因为我数据结构和算法非常薄弱，几乎是纯小白，所以我是从新手版开始看的~~在这里做个笔记，方便自己记忆。

文章索引：

前言：

首先先来实现一道简单的算法题，把一个整数打印32位状态（32位信息）。

关于&：

关于反码和补码

取反

负数为什么要取反+1？

右移

相反数的其他表达方式

所谓算法就是

算法的分类

为什么图灵是我们的祖师爷？

题目一 N的阶乘

题目二 选择排序

冒泡排序

冒泡排序和选择排序的区别：

插入排序：

首先先来实现一道简单的算法题，把一个整数打印32位状态（32位信息）。

大家都知道，我们平时用的都是10进制，我们指的整型就是我们常用的十进制的数字，比如1,2,3，我们看着是1、2、3其实他们是十进制的1、2、3。

在计算机底层，整型都是用2进制保存的，是用32位信息储存的。（long类型是用64位储存的）

32位信息的来源是指在计算机储存中用四个字节储存，每个字节是8位二进制，四个数一共是32位。

先看实现代码，然后再讲原理：

public class Code01_PrintBinary {

	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();
	}

	public static void main(String[] args) {
		// 32位
		int num = 4;
        print(num)
	}
}

打印出来的结果：

00000000000000000000000000000100

从右侧开始是第0~31位信息，

任何一个整数在计算机底层都是用32位信息存储的，在java中的整型都指的是有符号的整型，也就是1、2、3和-1、-2、-3这类的，所以他的最左边的那一位就是符号位，代表正数和负数。0代表正数，1代表负数。

我们看到的10进制数字其实是做了10进制定制，好让我们看到10进制的数字。

那么怎么计算一个整数的32位信息呢？

那么怎么知道每一位是0还是1呢？

就是要用num与1与左移i位进行与操作，如果两者不相同则会返回0，如果两者相同则会返回两者的数字，所以这里运用了一个三元运算符：

(num & (1 << i)) == 0 ? "0" : "1"

首先说明一下，与操作!=and！ 与操作不仅是逻辑运算符，还是位运算符，会把左右两侧的数字转换为二进制进行运算。

比如上面这个例子，num=4时，第一次的i从31出发，不断--，i和num都转化成二进制进行对比，只有当两者二进制重合是1时才会留下来，在该位写入“1”，否则将写入0，这样位位对比，终于得出最终结果。

关于&：

12&5 的值是多少？答：12转成二进制数是1100（前四位省略了），5转成二进制数是0101，则运算后的结果为0100即4 这是两侧为数值时；

关于反码和补码

刚刚我们讲了，在java中用32位信息来表示一个整数，那么表示的范围就是-2^{31}~2^{31}-1。

为什么负数可以表示2的31次方，而正数却要减一呢？前面我们说了，第一位是符号位，如果第一位是1的话代表负数，也就是说负数可以用32位的数来表示，而正数不行，因为正数有个0！

0要占一位！而负数没有0！他可以取反之后加个1！（详情看后面的取反）

正数的表示是第一位是0，后面的2的0次方、2的1次方这样以此类推加起来。

而负数的表示是第一位是1，值就是后面的状态取反+1

比如-1的信息：

11111111111111111111111111111111

可以看到后面都是1,1取反就是0，再+1就等于1。

系统最小，表示出来就是：

 10000000000000000000000000000000

首先第一位符号位1代表负数，后面的位都是0,0取反就是1，结果就是-2^{31}

取反

取反的符号是~，所谓取反就是0的地方写1，1的地方写0，如果是负数，就需要取反之后在+1

比如：

		int b = 123823138;
		int c = ~b;
		print(b);
		print(c);

结果：

00000111011000010110010000100010
11111000100111101001101111011101

因为1比较瘦所以看起来短了一截 - -。实际上都是32位。 

负数为什么要取反+1？

所有的+ - * / 这些符合 在计算机底层都是用位运算来实现的，而设计这套系统的人不想正数负数的加减乘除要分别写两套算法，他只想写一套，定义成取反+1就可以在+ - * /时使用同一套算法就能实现。

右移

右移有两个，

>>带符号右移 拿符号位来补 

>>>不带符号右移 拿0来补

相反数的其他表达方式

我们都知道在正数前面加个-，就会拿到负数。

而我们还可以取反+1，也可以得到相同的结果。

不管是正数还是负数都可以用这一套逻辑计算。

系统最小取反之后还是他自己。

因为系统最小是10000000000000……

取反之后变成0111111111111111……再加上1又回去了，跟之前一模一样，所以系统最小还是他自己。

0取反之后还是他自己，因为0的二进制表达是000000000000000000……

取反之后是111111111111111111111111111

然后再加1，就是1000000000000000……（因为溢出了就不要了，所以还是他自己 哈哈哈嗝）

所谓算法就是

  • 有具体的问题
  • 有假设及解决这个问题的具体流程
  • 有评价处理流程的可量化指标

算法的分类

算法的分类特别多，大体上可以分为两类，

  • 明确知道怎么算的流程（比如，负数就是取反+1，比如1+1=2）
  • 明确知道怎么尝试的流程（比如一个数的所有因子，我不知道怎么算，但我可以一个一个试出来）

为什么图灵是我们的祖师爷？

在计算机之前，有很多计算器，在图灵之前所有的计算器都有一个特点，我知道他怎么算，只是用机器来说更快。

是图灵破解出怎么试出来，才奠定了计算机的基础。

所谓的图灵机就是表示把一个不知道怎么算只知道怎么试的东西给他变成理论。

题目一 N的阶乘

给定一个参数N，返回：1！+2！+3！4+！+……+N！的结果。

算法是不需要语言的，会伪代码就可以。

首先说一下这个符号！叫阶乘。

阶乘(factorial)是基斯顿·卡曼(Christian Kramp, 1760 – 1826)于1808年发明的运算符号。阶乘，也是数学里的一种术语。阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。例如所要求的数是4，则阶乘式是1×2×3×4，得到的积是24，24就是4的阶乘。 例如所要求的数是6，则阶乘式是1×2×3×……×6，得到的积是720，720就是6的阶乘。例如所要求的数是n，则阶乘式是1×2×3×……×n，设得到的积是x，x就是n的阶乘。

 哈哈哈，有两种方法，先算一的阶乘，再算二的阶乘，再算三的阶乘……以此类推加起来。

第二种方法是先算1的阶乘，然后用1的阶乘*2就算出2的阶乘，然后用2的阶乘*3就算出3的阶乘……以此类推。

虽然我们还没有学到时间复杂度，但是能明显感觉出来，第二种方法比第一种要更好，节约时间/资源。

两者代码：


public class Code02_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));
	}

}

题目二 选择排序

给你一个数组从小到大排序。

所谓选择排序就是：

0~N-1选除最小值放到0位置

1~N-1选除最小值放到1位置

2~N-1选除最小值放到2位置

……

以此类推

public class Code03_Sort {

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

	public static void selectSort(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 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 <= end; second++) {
				if (arr[second - 1] > arr[second]) {
					swap(arr, second - 1, second);
				}
			}
		}
	}

	public static void insertSort1(int[] arr) {
		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--;
			}
		}
	}

	public static void insertSort2(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		int N = arr.length;
		for (int end = 1; end < N; end++) {
			for (int pre = end - 1; pre >= 0 && arr[pre] > arr[pre + 1]; pre--) {
				swap(arr, pre, pre + 1);
			}
		}
	}

	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 = { 7, 1, 3, 5, 1, 6, 8, 1, 3, 5, 7, 5, 6 };
		printArray(arr);
		insertSort2(arr);
		printArray(arr);
	}

}

冒泡排序

[A B C D E F G……N]

先用A和B进行比较，如果A比B大，则位置进行交换，再用B和C进行比较，B比C大则进行交换，直到N，此时N位置上的一定是数组最大值，所以就不用管了。

然后在进行重复，将A~N-1范围重复上述过程，交换完后N-1位置上的上的一定是当前数组最大值，不断重复后就得到了一个有序列表。

代码实现：

package class01;

import java.util.Arrays;

public class Code05_BubbleSort {

	public static void bubbleSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int end = arr.length - 1; end > 0; end--) {
			for (int i = 0; i < end; i++) {
				if (arr[i] > arr[i + 1]) {
					swap(arr, i, i + 1);
				}
			}
		}
	}

	// 交换arr的i和j位置上的值
	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			bubbleSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		bubbleSort(arr);
		printArray(arr);
	}

}

冒泡排序和选择排序的区别：

冒泡每次都是2 2交换，以此类推……

选择排序只是找到一个最小的，直接与0位置交换，以此类推……

插入排序：

[A B C D E F G……N]

插入排序顺序：

0-0  首先先看一个A的位置，此时就一个数，所以肯定有序

0-1  由于0-0已经有序了，此时只要再看1位置上的B，用B和A进行比较，如果B比A小则进行交换。

0-2  由于0-1位置已经有序了，此时只需要看2位置上的C，此时C跟B进行比较，如果比B小则进行交换，交换完后，此时交换后的B在于A进行比较，如果比A还小，则再进行交换，再往前看，由于没有数了就到此停止。

0-3 由于0-2位置已经有序了，此时只需要看3位置上的D，此时的D跟C进行比较，如果比C小则交换，不比他小则停止……跟上面步骤一样，以此类推……

0-4……

为什么叫插入排序呢，就像我们平时玩斗地主，手里的牌已经有序了，只需要一一比对，插入到合适的位置。

代码实现：

package class01;

import java.util.Arrays;

public class Code06_InsertionSort {

	public static void insertionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 1; i < arr.length; i++) { // 0 ~ i 做到有序
			for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
				swap(arr, j, j + 1);
			}
		}
	}

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

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		// Math.random() ->  [0,1) 所有的小数，等概率返回一个
		// Math.random() * N -> [0,N) 所有小数，等概率返回一个
		// (int)(Math.random() * N) -> [0,N-1] 所有的整数，等概率返回一个
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())]; // 长度随机 
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) 
					- (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100; // 随机数组的长度0～100
		int maxValue = 100;// 值：-100～100
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			insertionSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				// 打印arr1
				// 打印arr2
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		insertionSort(arr);
		printArray(arr);
	}

}

Andy393939
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
论文研究 - 用于对实数进行排序的NC算法
05-21
我们将对n个实数进行实时排序的最新重要结果应用于在时间和运算上对实数进行排序的并行算法的设计。 这是已知的第一个采用用于对实数进行排序的运算的NC算法。 √登录
《信息学竞赛宝典-基础算法》视频讲解-第8章 高精度算法
03-15
《信息学竞赛宝典--基础算法》，人民邮电出版社 c++基础算法视频讲解---第8章 第8章 8.1.2高精度加法 8.1.6高精度数除以低精度数1 8.1.1被限制的加法 ...第07章 排序算法 第08章 高精度算法 第09章 搜索算法
贪心法_题目1038：Sum of Factorials
Denallo的专栏
03-07 818
时间限制：1 秒 内存限制：32 兆 特殊判题：否 提交：691 解决：255   题目描述：     John von Neumann, b. Dec. 28, 1903, d. Feb. 8, 1957, was a Hungarian-American mathematician who made important contribution
数据结构与算法XS班-左程云第一节课笔记（位运算、算法是什么、简单排序）
DiPingXianhorizon的博客
02-05 722
这是数据结构与算法新手班-左程云第一节课的笔记
【算法学习】位运算，算法是什么，简单排序
kuilian的博客
07-18 265
右移带符号右移符号位补不带符号右移用0补。
算法扫盲：01位运算、算法是什么、简单排序
tom春的博客
08-30 100
位运算 << 、<<< 左插入 ~取反 冒泡排序 插入排序
01.位运算、算法是什么、简单排序
M_Love_U的博客
07-13 202
位运算、算法是什么、简单排序
算法新手（一）——位运算、算法是什么、介绍位运算和简单排序
moneywenxue的博客
04-21 1011
i >= 0;// 32位//////////print(-1);print(a);////
时间复杂度和插入排序冒泡排序位运算算法
cyuyanxiaobai56的博客
11-26 203
今天学了一下数据结构和算法，数据结构和算法对于编程可谓是十分重要，数据结构和算法决定了这个程序员厉不厉害，一个优秀的算法可以让计算机的效率快好几百倍好几千倍，成指数级增长。好的算法是需要积累的，虽然说算法不能靠背，但是不背还真不行，起码一些很有名的算法，必须要掌握。企业的面试经常会有数据结构和算法题。在面试的之前，有一些东西可以提前几天背，完全可以完成面试，但是数据结构和算法却不可以，必须要懂得这个算法是怎么计算的。其实数据结构和算法有点类似于高数，高数好的人会觉得高数很简单，高数不好的人怎么都
【算法笔记】位运算详解
天生我材必有用，千金散尽还复来。
10-18 4758
突然想到位运算是个好东西，就来水一波文章了……注意：我把能想到的有关位运算的所有内容都放进来了，所以篇幅较长，请谅解！若有写的不清楚或者不够详细的地方欢迎在评论区补充，谢谢支持！本文中参考代码均使用C++编写。废话不多说，下面步入正题。有一定基础的可以跳过该部分。 位运算分为如下几种：取反（）是最简单的位运算操作，只有一个参数xxx。将参数上的每一位对应取反即可。例如： 性质：按位与（）有两个参数xxx和yyy。对于xxx和yyy中的每个对应位，参照下表输出到结果的对应位：例子： 性质：按位与（）有两
《信息学竞赛宝典-基础算法》视频讲解-第9章 搜索算法
03-15
《信息学竞赛宝典--基础算法》，人民邮电出版社 c++基础算法视频讲解---第9章 第9章 9.1.2迷宫问题 9.1.1四色地图 9.1.6单词接龙 9.1.5机器人搬重物 ...第07章 排序算法 第08章 高精度算法 第09章 搜索算法
多目标遗传算法NSGA-II.zip
04-30
NSGA-Ⅱ就是在第一代非支配排序遗传算法的基础上改进而来，其改进主要是针对如上所述的三个方面：①提出了快速非支配排序算法，一方面降低了计算的复杂度，另一方面它将父代种群跟子代种群进行合并，使得下一代的...
质数和约数
2302_77099705的博客
05-21 701
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
算法刷题笔记 逆序对的数量（C++实现）
hanmo22357的博客
05-18 315
AcWing上的算法基础课题目 逆序对的数量 刷题笔记记录
P1135 奇怪的电梯
loongnoy的博客
05-17 281
大楼的每一层楼都可以停电梯，而且第 𝑖i 层楼（1≤𝑖≤𝑁1≤i≤N）上有一个数字 𝐾𝑖Ki​（0≤𝐾𝑖≤𝑁0≤Ki​≤N）。例如： 3,3,1,2,53,3,1,2,5 代表了 𝐾𝑖Ki​（𝐾1=3K1​=3，𝐾2=3K2​=3，……），从 11 楼开始。第一行为三个用空格隔开的正整数，表示 𝑁,𝐴,𝐵N,A,B（1≤𝑁≤2001≤N≤200，1≤𝐴,𝐵≤𝑁1≤A,B≤N）。对于 100%100% 的数据，1≤𝑁≤2001≤N≤200，1≤𝐴,𝐵≤𝑁1≤A,B≤N，0≤𝐾𝑖≤𝑁0≤Ki​≤N。
【算法】前缀和——二维前缀和模板题
最新发布
2302_79031646的博客
05-21 182
用“二维前缀和模板题”来介绍二位前缀和算法模板
【二叉树算法题记录】从中序与后序遍历序列构造二叉树，从前序与中序遍历序列构造二叉树
weixin_43627638的博客
05-15 383
这样我们就能确定整棵树的根节点在。
算法练习第22天|39. 组合总和、40.组合总和II
Brillian123的博客
05-15 814
39. 组合总和39. 组合总和 - 力扣（LeetCode）
基于线性表的多项式运算算法设计及实现
09-03
基于线性表的多项式运算算法设计及实现，可以采用链表或数组来表示多项式。对于链表表示法，每个节点包含多项式的系数和指数，通过指针连接起来形成链表。对于数组表示法，可以将多项式的系数存储在数组中，数组下标...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Andy393939

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值