- 博客(72)
- 收藏
- 关注
RSS订阅原创 rust编程-链表：使用struct实现链表，使用堆合并k个升序链表，自定义Display
此处代码中的链表不是泛型，还没有找到泛型实现Display的方法。。。
2022-06-06 21:21:21
271
1
原创 rust编程-线程：无畏并发
目前了解到，Rust实现线程间通信依靠的是消息传递和共享内存两种方式，消息传递必须使用move/clone，而共享内存使用mutex性能有开销。Rust也无法避免死锁和循环引用（ 类似于Rc，Arc也不能幸免，但可以使用Atomic Weak来避免循环引用）。use std::thread;use std::time::Duration;use std::sync::mpsc;use std::sync::{Arc,Mutex};fn main(){//线程 println!("===
2022-05-30 03:35:35
466
原创 rust编程-智能指针：实现单链表、共享链表、双链表
使用Box实现单链表#[derive(Debug)]struct Node{ value : i32, next : Box<Option<Node>>,}fn main(){ let a = Node{ value : 1, next : Box::new(None), }; let b = Node{ value : 2, next : Box::new(Some(a
2022-05-30 02:48:00
432
原创 rust编程-链表：使用枚举实现一个链表
//实现一个链表use List::*;//使用enum创建链表enum List{ Cons(u32,Box<List>),// Cons：元组结构体，包含链表的一个元素和一个指向下一节点的指针 Nil,// Nil：末结点，表明链表结束}//为List创建方法impl List{ //创建一个空的List实例 fn new() -> List{ Nil //这里的Nil实际上为List::Nil }
2022-05-18 16:36:02
278
原创 rust编程-元组Display：交换元组的元素
use std::fmt::{self, Formatter, Display};#[derive(Debug)]struct Matrix(f32, f32, f32, f32);//自定义Matrix输出为2行impl Display for Matrix { fn fmt(&self, f: &mut Formatter) -> fmt::Result { write!(f, "({0} {1}) \n({2} {3})",self.0,se
2022-05-17 21:34:48
215
原创 rust编程-结构体Display：一个例子
为Color 结构体实现 fmt::Display，应得到如下的输出结果：RGB (128, 255, 90) 0x80FF5ARGB (0, 3, 254) 0x0003FERGB (0, 0, 0) 0x000000代码为：use std::fmt::{self, Formatter, Display};#[derive(Debug)]struct Color { red: u8, green: u8, blue: u8,}impl Display for
2022-05-17 21:04:10
681
原创 rust编程-格式化输出
Debugfn main() { println!("{} days", 31);// 不加后缀的话，31 就自动成为 i32 类型。 println!("{} days", 31i64); // 用变量替换字符串有多种写法。 // 比如可以使用位置参数。 println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob"); // 可以使用命名参数。 println!("{subject}
2022-05-17 19:01:42
260
原创 rust编程：借用
引用和借用引用并不会拥有变量的所有权。默认不允许修改引用的值，但使用可变引用就可以修改引用的值。在同一时间，只能有一个对某一特定数据的可变引用。多个不可变引用是可以的，但是不能在拥有不可变引用的同时拥有可变引用。不可变引用的用户可不希望在他们的眼皮底下值就被意外的改变了。字符串的clear尝试获得一个可变引用，所以下面的程序会报错。fn first_word(s: &String) -> &str { let bytes = s.as_bytes();
2022-04-26 22:28:56
203
1
原创 rust编程：所有权
给函数传值时，类似于赋值函数，可能移动或复制。fn main() { let s = String::from("hello"); // s 进入作用域 takes_ownership(s); // s 的值移动到函数里 ... // ... 所以到这里不再有效 let x = 5; // x 进入作用域 makes_copy(x);
2022-04-25 16:21:29
209
原创 rust编程：函数返回值
与C++不同的一点是，rust语句不返回值。下面程序是错的：fn main() { let x = (let y = 6);}但是表达式可以返回值。注意：表达式的结尾没有分号，不然就变成语句了。下面程序正确：fn main() { let y = { let x = 3; x + 1 }; println!("The value of y is: {}", y);}在 Rust 中，函数（->）的返回值等同于函数体最
2022-04-25 13:10:55
2598
原创 rust编程：基本数据类型
浮点数默认是f64类型，和f32速度差不多。元组元组中每个数据元素可以不是同一个类型。元组的长度是固定的。没有任何值的元组 () 只有一个元素。数组数组中每个数据元素必须是同一个类型。元组的长度是固定的。...
2022-04-25 10:34:44
177
原创 rust编程：let和mut的变量和可变性
加上mut关键字之后，就不可以改变变量类型!!!下面程序正确fn main() { let spaces = " "; let spaces = spaces.len();}下面程序错误fn main() { let mut spaces = " "; spaces = spaces.len();}
2022-04-25 09:33:57
644
原创 rust编程：let和mut在大括号的作用域
下面这段程序，第一个x输出为12，第二个x输出为6（可以理解大括号内的let为重新定义的变量）fn main() { let x = 5; let x = x + 1; { let x = x * 2; println!("The value of x in the inner scope is: {}", x); } println!("The value of x is: {}", x);}下面这段程序，第一.
2022-04-25 09:24:31
265
原创 C++编程：仅用递归函数和栈操作逆序一个栈
int getBottom(stack<int>& st){ //获取栈底元素 int result = st.top(); st.pop(); if(st.empty()){ //到栈底了 return result; } else{ int last = getBottom(st); st.push(result); return last; }}void resve
2022-03-03 21:11:48
462
原创 C++编程：双栈排序
C++编程：双栈排序使用一个栈实现另一个栈的排序，最多可以使用一个int型变量。void func(stack<int>& st1,stack<int>& st2){ int tmp; while (!st1.empty()) { tmp = st1.top(); st1.pop(); while (!st2.empty() && tmp<st2.top()) {
2022-03-03 20:21:54
383
原创 C++编程：关于二叉排序树的一道有疑问的题目待优化
//题目要求：一颗二叉排序树，给定一个数字target，尽量优化的方式去寻找target和节点的差的绝对值最小的节点//算法思想：其实就是找一条路径，target肯定在这条路径上才可以找到最小的值//下面的解法不一定正确，后续可能会有优化。//使用st保存这条路径上的节点，执行完func之后，对栈里的元素进行遍历，找到最小的绝对差值//虽然每一步都push节点了，但是其实小于节点的时候，只递归了左子树，并未考虑右子树void func(TreeNode* root,int target,stack
2022-02-23 22:29:38
359
原创 C++编程：常用排序算法
C++编程：常用排序算法冒泡排序算法思想：比较相邻的元素。如果第一个比第二个大，就交换它们两个；对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；针对所有的元素重复以上的步骤，除了最后一个；重复步骤1~3，直到排序完成。void mySort(vector<int>& nums){ if(nums.size()<2){ return; } for(int i = 0; i<n
2022-02-23 00:54:53
742
原创 C++编程：单例模式的几种写法
C++编程：单例模式的几种写法懒汉式#include <iostream>using namespace std;//懒汉式class Single{public: //静态的获取实例的方法 static Single* getInstace(){ if(NULL == instance){ instance = new Single(); } return instance; }
2022-02-21 20:02:39
1551
原创 C++编程：自定义String类的构造函数、析构函数、拷贝构造函数和赋值函数
C++编程：自定义String类的构造函数、析构函数、拷贝构造函数和赋值函数头文件如下：//类Stringclass String{public: String(const char *str = NULL);//普通构造函数 ~String(void); String(const String &other); String & operator = (const String &other); private:
2022-02-19 00:30:26
863
原创 算法-二叉树：二叉树的最近公共祖先
算法-二叉树：二叉树的最近公共祖先元素不重复。普通二叉树的最近公共祖先思路解析：从叶子节点自下而上去查找祖先，自然选择后序遍历。如果一个节点，左子树出现p右子树出现q（或左q右p），那么就说明这个节点是最近的公共祖先。同样可以采用递归写法。注意：当递归有返回值的时候，搜索一条边或一个元素可以return，搜索整棵树时不可以return。因为后者要用到返回值做逻辑判断。TreeNode* lowest(TreeNode* root, TreeNode*p,TreeNode*q){ if(ro
2022-02-10 02:20:39
549
原创 算法-二叉树：二叉搜索树中的众数
算法-二叉树：二叉搜索树中的众数将二叉搜索树中出现次数最多的元素的集合输出，当有多个要输出的元素时不用考虑输出顺序。思路解析：如果是普通二叉树的话，可以这么做：遍历一遍树，存入map，key为元素，value为出现次数；将map转存为vector，根据value从大到小排序；遍历vector，如果和vector[0].second相等的话，就存入集合，否则直接break结束程序。对于二叉搜索树来说，可以这么做：采用一次中序遍历（利用pre和cur）得到每个元素的出现次数（用数组
2022-02-10 01:37:03
558
原创 算法-二叉树：二叉搜索树的最小绝对差
算法-二叉树：二叉搜素树的最小绝对差给出一颗所有节点为非负值的二叉搜索树，请计算树中任意两个节点的差的绝对值的最小值。方法一：中序遍历后转为有序数组，然后遍历一遍数组去求最小绝对差。在此不做过多说明。方法二：中序遍历递归，依旧定义一个pre指向前一个节点。TreeNode* pre = NULL;int result = INT_MAX;void traversal(TreeNode* root){ if(root == NULL) return ; traversal(root
2022-02-10 00:37:05
275
原创 算法-二叉树：验证二叉搜索树
算法-二叉树：验证二叉搜索树题目描述：若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值。若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值。它的左右子树也分别是二叉搜索树。方法一：使用中序遍历将二叉搜索树存入数组，判断数组是不是有序的即可。void traversal(TreeNode* root,vector<int>& nums){ if(root == NULL ) return ; traversal(root->lef
2022-02-10 00:20:26
808
原创 算法-二叉树：在二叉搜索树中寻找节点
算法-二叉树：在二叉搜索树中寻找节点确定一个节点是否在二叉搜索树中，如果在，则返回这个节点，如果不在，则返回NULL。树中没有重复元素。方法一：递归TreeNode* searchNode(TreeNode* root,int target){ if(root == NULL || root->val == target) return root; if(target < root->val){ return searchNode(root->l
2022-02-09 23:16:20
895
原创 算法-二叉树：合并两颗二叉树
算法-二叉树：合并两颗二叉树思路解析：使用t1和t2节点同时遍历两棵树，将两颗树的每个根节点相加；如果t1为空，那么合并之后就是t2；如果t2为空，那么合并之后就是t1。方法一：采用递归，下面程序使用前序遍历（前中后都可）。TreeNode* plusTree(TreeNode* t1,TreeNode* t2){ if(t1 == NULL) return t2; if(t2 == NULL) return t1; //重新定义了一棵树，也可以不定义而是直接加到t1
2022-02-09 23:02:36
1353
原创 算法-二叉树：构造一颗二叉树（前序+中序）
算法-二叉树：构造一颗二叉树（前序+中序）思路解析：以前序的第一个元素作为切割点，去切割中序数组；根据中序数组切割的长度去切割前序数组；递归，直至前序数组的长度变为1，就找到了叶子节点。//nums1为中序数组，nums2为前序数组TreeNode* toTree(vector<int> nums1,vector<int>nums2){ if(nums2.size() == 0) return NULL; TreeNode* root = new Tr
2022-02-09 22:30:13
249
原创 算法-二叉树：构造一颗二叉树（中序+后序）
算法-二叉树：构造一颗二叉树使用中序与后序遍历序列（没有重复元素）构造一颗二叉树。思路解析：后序最后一个元素去切割中序数组；中序数组分为中序左数组和中序右数组，对应的将后序数组切割为后序左数组和后序右数组；对后序左数组、右数组依次做上述步骤，直至后序数组被切割为一个元素。//nums1为中序数组，nums2为后序数组TreeNode* toTree(vector<int> nums1,vector<int>nums2){ if(nums2.size()==0
2022-02-09 22:03:59
357
原创 算法-二叉树：路径总和-找出所有路径
算法-二叉树：路径总和-找出所有路径void pathSum(TreeNode* root,vector<int>& path,vector<string>& str,int target){ if(root == NULL) return; path.push_back(root->val);//中 if(!root->left && !root->right && target==root
2022-02-07 20:29:21
159
原创 算法-二叉树：路径总和（是否存在路径）
算法-二叉树：路径总和（是否存在路径）判断是否存在一条从根节点到叶子节点的路径，使这个路径的节点总和等于目标值。//方法一：递归bool pathSum(TreeNode* root,int target){ if(root == NULL) return false; if(!root->left && !root->right && target==root->val) { //遇到叶子节点 return true;
2022-02-07 20:08:16
311
原创 算法-二叉树：二叉树的所有路径
算法-二叉树：二叉树的所有路径给出一个二叉树，返回所有从根节点到叶子节点的路径。思路解析：需要从父节点指向子节点，显然使用前序遍历比较方便。//方法一：递归void allPath(TreeNode* root,vector<int>& path, vector<string>& str){ //中 path.push_back(root->val); if(root->left==NULL && root-
2022-02-07 18:39:04
339
原创 算法-二叉树：平衡二叉树
算法-二叉树：平衡二叉树判断一棵树是不是平衡二叉树。平衡二叉树：每一个节点的左子树和右子树的高度差的绝对值不超过1。思路解析：求二叉树的高度，只能从下到上去查找，所以需要后序遍历。和求深度不同。//方法一：递归int height(TreeNode* root){ if(root == NULL) return 0; int leftHeight = height(root->left); if(-1 == leftHeight) return -1; int
2022-02-07 17:53:16
573
原创 算法-二叉树：二叉树的最小深度
算法-二叉树：二叉树的最小深度求一颗二叉树的最小深度，根节点的深度为1。最小深度：从根节点到最近叶子节点的最短路径上的节点数量。//方法一：递归int height(TreeNode* root){ if(root == NULL) return 0; //如果左子树为空，那么最小深度按照右子树计算 if(!root->left && root->right){ return 1+height(root->right)
2022-02-07 17:10:12
1381
原创 算法-二叉树：二叉树的最大深度
算法-二叉树：二叉树的最大深度求一颗二叉树的最大深度，根节点的深度为1。思路解析：构造二叉树时，一般选择前序遍历；求普通二叉树的属性，一般选择后序遍历；求二叉搜索树的属性，一般选择中序遍历。注意：对于普通二叉树单纯求深度使用前序遍历就行。//方法一：递归int height(TreeNode* root){ if(root == NULL) return 0; int left = height(root->left); int right = height
2022-02-07 16:27:25
368
原创 算法-二叉树：对称二叉树
算法-二叉树：对称二叉树给出一个二叉树，判断其是不是中心轴对称的。//方法一：递归实现bool compare(TreeNode* left,TreeNode* right){ //左右均为空，返回true if(left==NULL && right==NULL){ return true; } //左空右不空 else if(left==NULL && right!=NULL){ return
2022-02-07 16:12:24
264
原创 算法-二叉树：反转二叉树
算法-二叉树：反转二叉树思路解析：只要把每个节点的左右孩子反转一下就可以了，注意不要采用中序遍历，因为可能会把某些节点的左右孩子反转两次。以下方法采用前序遍历，方法一采用递归，方法二采用迭代。//方法一：前序遍历递归实现TreeNode* traversal(TreeNode* root){ if(root == NULL) return root; swap(root->left,root->right); traversal(root->left);
2022-02-07 00:34:02
394
原创 算法-二叉树：二叉树的层序遍历
算法-二叉树：二叉树的层序遍历#include <iostream>#include <vector>#include <queue>#include <stack>#include <algorithm>using namespace std;struct TreeNode{ int val; TreeNode *left; TreeNode *right; TreeNode(int val) :
2022-02-07 00:01:00
214
原创 算法-二叉树：前、中、后序的统一迭代法
算法-二叉树：前、中、后序的统一迭代法思路解析：将要访问的节点放入栈，将要处理的节点放入栈之后紧接着放入一个空指针作为标记。#include <iostream>#include <vector>#include <queue>#include <stack>#include <algorithm>using namespace std;struct TreeNode{ int val; TreeNode *lef
2022-02-06 22:45:39
69
原创 算法-二叉树：前、中、后序的迭代遍历
算法-二叉树：前、中、后序的迭代遍历使用栈可以实现迭代遍历。#include <iostream>#include <vector>#include <queue>#include <stack>#include <algorithm>using namespace std;struct TreeNode{ int val; TreeNode *left; TreeNode *right; Tree
2022-02-06 22:15:24
322
原创 算法-二叉树：前、中、后序的递归遍历
算法-二叉树：前、中、后序的递归遍历#include <iostream>#include <vector>#include <queue>#include <algorithm>using namespace std;struct TreeNode{ int val; TreeNode *left; TreeNode *right; TreeNode(int val) : val(val),left(nullpt
2022-02-06 12:59:55
345
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人