算法学习class1

最新推荐文章于 2025-11-24 15:27:16 发布
原创 最新推荐文章于 2025-11-24 15:27:16 发布 · 590 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #java

本文档介绍了Java编程中四种排序算法（冒泡、选择、插入和快速排序）的实现，以及两个实用函数的示例，包括阶乘相加和数组操作。适合初学者理解基本算法并提升编程技能。 
package class01;

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);
//    
//    
//    int test = 1123123;
//    print(test);
//    print(test<<1);
//    print(test<<2);
//    print(test<<8);
//    
//    
//    int a = Integer.MAX_VALUE;
//    System.out.println(a);

//    print(-1);
//    int a = Integer.MIN_VALUE;
//    print(a);

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

//    print(-5);

//    System.out.println(Integer.MIN_VALUE);
//    System.out.println(Integer.MAX_VALUE);

//    int a = 12319283;
//    int b = 3819283;
//    print(a);
//    print(b);
//    System.out.println("=============");
//    print(a | b);
//    print(a & b);
//    print(a ^ b);

//    int a = Integer.MIN_VALUE;
//    print(a);
//    print(a >> 1);
//    print(a >>> 1);
//    
//    int c = Integer.MIN_VALUE;
//    int d = -c ;
//    
//    print(c);
//    print(d);

   }

}

阶乘相加

package class01;

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;//1*2*3*4
		}
		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 = 3;
		System.out.println(f1(N));
		System.out.println(f2(N));
	}

}

package class01;

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

}

package class01;

import java.util.Arrays;

public class Code04_SelectionSort {

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

	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;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			selectionSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				printArray(arr1);
				printArray(arr2);
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

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

}

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

}

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

}

单分类算法：One Class SVM
Rnan_prince的博客
07-15 3万+
安全检测常用算法有：Isolation Forest，One-Class Classification等，孤立森林参见另一篇，今天主要介绍One-Class Classification单分类算法。 一，单分类算法简介 　　One Class Learning 比较经典的算法是One-Class-SVM，这个算法的思路非常简单，就是寻找一个超平面将样本中的正例圈出来，预测就是用这个超平面做决策，在圈内的样本就认为是正样本。由于核函数计算比较耗时，在海量数据的场景用的并不多； 　　另一个算法是...
【算法学习】蓝耘云智算|利用DeepSeek R1模型提升数据结构与算法学习效率
null18的博客
02-12 6119
数据结构与算法的学习过程可能充满挑战，但使用诸如DeepSeek R1模型，你可以通过智能学习引擎、个性化学习路径和实时反馈系统，轻松克服学习中的难点，快速提高自己的编程能力。无论你是编程新手还是经验丰富的开发者，DeepSeek R1都能为你提供一个系统化、高效的学习平台，帮助你在最短时间内掌握最重要的算法和数据结构知识。如果你处于大一大二，正在为学习数据结构与算法而烦恼，不妨尝试在蓝耘云智算平台利用DeepSeek R1模型，开始你更加智能化的学习之旅吧！
java中package的运用
m0_67233919的博客
03-13 4791
java中package的运用 package test; public class Test01 { public static void main(String[] args) { System.out.println("Hello World!"); } } package必须在源文件的第一行。 package的命名规则： 必须以小写字符命名，不能加特殊符号。 采取域名倒置的规则。例如xxx.daidu.com.cn这时就可以命名为cn.com.baidu.xx 这个packa
2022.04.06_数据结构—左程云01
fuyuanduan的博客
04-06 1618
左神YYDS～
n&(1＜＜i)的含义
qq_60236552的博客
07-18 1343
1<<i 是将1左移i位，即第i位为1，其余位为0； 例如1<<2 则0001->0100 n&(1<<i)是将左移i位的1与n进行按位与，即为保留n的第i位，其余位置零 如果n第i位为0，则n&(1<<i)的值为0 否则不为0 常用if(n&(1<<i)==0)用于判断n的第i位是否为0 ———————————————— 版权声明：本文为优快云博主「feiyu_diary」的原创文章，遵循CC 4.0 B
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 35万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
算法学习day1
qq_45960599的博客
02-15 3269
算法学习
K-近邻算法学习总结
weixin_52527244的博客
05-30 1817
最近学习了K-近邻算法，在这里进行一个总结。 简单地说，K 近邻算法采用测量不同特征值之间的距离方法进行分类。它具有的优缺点如下： 优点：精度高、对异常值不敏感、无数据输入假定。 缺点：计算复杂度高、空间复杂度高。 K 近邻算法适用数据范围为：数值型和标称型。 在输入想要得到标签得的数据之后，将输入数据的每个特征与样本集中的数据相对应的特征进行比较，之后通过提取前k个最相似的分类标签，这也是K近邻算法中K的出处，通常K的值是不大于20的证书。最后根据K个最相似数据中出现最多的标签分类作为输入数据的分
算法学习：1-1 贪心算法
Linke66的博客
09-27 4027
所谓贪心算法，就是每次操作保证都是局部最优解，以至于最终的结果是全局最优解。 习题1：455.分发饼干 使用贪心算法，关键在于找到贪心策略，即每一步操作都是局部最优解。 由题可知，要尽可能满足多的孩子，只要给胃口值最小的孩子分配能让他满足的最小尺寸的饼干，这就是本题的贪心策略。 class Solution { public: int findContentChildren(vector<int>& g, vector<int>& s) {
机器学习算法——决策树
2401_87863416的博客
04-21 4752
决策树（Decision Tree）是一种以树形结果展示决策规则和分类结果的模型。作为一种归纳算法模型，它可以从看似无序、杂乱的数据中提取出数据分类的规律，并用其进行新数据分类或预测。决策树可被用于解决分类和回归问题。例如：通过一个西瓜的多种特征，如其纹理、色泽、触感，等判断其是否是好瓜；或通过一天的天气情况，如是否晴天、风力大小、空气湿度等，判断这一天是否适合进行户外运动等。
机器学习十大算法案例
weixin_41744192的博客
06-14 5万+
机器学习十大算法案例实现监督学习1. 线性回归2. 逻辑回归3. 神经网络4. SVM支持向量机5. K邻近6. 贝叶斯7. 决策树8. 集成学习非监督学习9. 降维—主成分分析10. 聚类分析 监督学习 1. 线性回归 2. 逻辑回归 3. 神经网络 4. SVM支持向量机 5. K邻近 6. 贝叶斯 7. 决策树 8. 集成学习 非监督学习 9. 降维—主成分分析 10. 聚类分析 跳转 —>聚类分析综述与案例实现 ...
基于蚁群算法改进One-Class SVM的电力离群用户检测算法研究
10-15
相比文献[1]中的GA-SVM（遗传算法优化SVM）和文献[5]中的高斯核局部离群因子方法，蚁群优化的One-Class SVM在学习时间、局部最优避免和离群点检测效果上有优势。文献[6]中未优化参数的One-Class SVM则可能面临学习...
机器学习之无监督学习三大聚类算法应用实战
06-13
本课程主要讲解介绍无监督学习 、聚类算法 、常见聚类算法的应用和优化 、tensorflow的基本处理流程。通过课程学习可以了解机器学习中的无监督学习 2.可以学习到Python下TensorFlow处理问题的流程 3.选择无监督的...
机器学习分类算法总结
12-21
classcount.get(votelabel, 0) + 1 ：classcount字典中如果没有votelabel则字典classCount中生成voteIlabel元素，并使其对应的数字为0，然后加1；如果有votelabe，取出值对应值，然后加1（0不起作用） so
C++ 字符串 模拟 力扣 14. 最长公共前缀 每日一题 题解
Q741_147的博客
11-23 654
本文围绕LeetCode 14“最长公共前缀”这一字符串经典入门题展开，解析其作为面试高频题的核心价值——夯实模拟思维、边界处理与代码优化能力。文章详细阐述横向遍历（两两对比）与纵向遍历（逐位验证）两种核心算法原理，提供完整可运行的C++代码，拆解关键细节与易错点，并进行复杂度分析。同时总结解题核心考点、思路迁移方向及常见错误，帮助读者不仅掌握本题解法，更能提升字符串处理能力，为后续复杂题型奠定基础，兼具入门指导与面试备考价值。
代码随想录 63.不同路径Ⅱ
最新发布
m0_63814538的博客
11-24 423
4.确定遍历顺序：从递归公式可以看出一定是从左到右一层一层的遍历，这样保证推导dp[i][j]的时候，dp[i - 1][j]和dp[i][j - 1]一定是有数值的。所以本题的初始化代码如下所示：一旦遇到obstacleGrid[i][0] == 1的情况就停止dp[i][0]的赋值1的操作，dp[0][j]同理。1.确定dp数组（dp table）及其下标的含义：dp[i][j]表示从（0，0）出发，到（i，j）有dp[i][j]条不同的路径。下标（0，j）的初始化情况同理。
算法：二叉搜索树的最近公共祖先
czlczl20020925的博客
11-24 459
下面是详细的解释，说明为什么这是必然的。对于我们当前所在的任何节点。
P1522 [USACO2.4] 牛的旅行 Cow Tours(连通块+Floyd）
2302_79372568的博客
11-22 65
思路：先用dfs标记一下每个点在哪个连通块，然后求出每个连通块内每个点的最大最短路，求任意两点之间的距离＋数据范围，我们可以知道这道题要使用Floyd进行求解，求到了任意两点之间的距离后，我们就可以求出每个点到所在连通块其他点的最短路中的最大值，然后再从同一连通块的所有点的最大值中选出最大值，就是连通块的直径了。题目大意：给你n个坐标点（x,y)，再给一个n*n的矩阵，代表两点之间的连边关系，连边之后会构成若干个连通块，定义连通块的直径为最远的两个点的距离（距离指的是两点间最短路径的长度）。
第二次测试题解
2402_89056915的博客
11-23 796
第 3 刀：要最大化分区，第 3 个平面必须与前 2 个平面都相交（得到 2 条不重合的交线，且这 2 条交线在第 3 个平面上相交）—— 相当于在第 3 个平面上，用 2 条相交直线分成了 4 块，因此新增 4 个区域 →。前 3k+2 项的和：3k 项和 + a₃ₖ₊₁ + a₃ₖ₊₂ ≡ 0 + p + q ≡ (p+q) mod 2（a₁+a₂ 的奇偶性）余数 r=2（n=3k+2）→ Sₙ ≡ 1+1=2≡0 → 0（偶）→ 代码逻辑：if n%3==1 → 1，else → 0。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值