数据结构--【顺序表与链表】笔记

news2025/3/10 9:45:09

顺序表

template <class T>
class arrList :public List<T> //表示 arrList 类以公有继承的方式继承自 List<T> 类
//公有继承意味着 List<T> 类的公共成员在 arrList 类中仍然是公共成员，受保护成员在 arrList 类中仍然是受保护成员。
{
private:
	T* aList;  //存储顺序表的实例，以后可以直接拿aList[]当数组用
	int maxSize;
	int curLen;   //顺序表的当前长度
	int position;  //当前处理位置
public:
	arrList(const int size)
	{
		maxSize = size;
		aList = new T[maxSize];
		curlen = position = 0;
	}
	~arrList()
	{
		delete[] aList;
	}
	void clear()
	{
		delete[] aList;
		curLen = position = 0;
		aList = new T[maxSize];
	}
	//查找操作
	bool arrList<T>::getPos(int& p, const T value)
	{
		for (int i = 0; i <= curLen; i++)
		{
			if (aList[i] == value)
			{
				p = i;
				return true;
			}
		}
		return false;
	}
	//插入操作
	bool arrList <T> ::insert(const int p, const T value)
	{
		if (curLen >= maxSize)  //检测当前数组是否越界
 		{ 
			cout << "overflow";  
			return false;
		}
		if (p<0 || p>curLen)   //检测插入位置是否合法
		{
			cout << "illegal";
			return false;
		}
		for (int i = curLen; i > p; i--)
		{
			aList[i] = aList[i = 1];
		}
		aList[p] = value;
		curLen++;
		return true;
	}
	//删除操作
	bool arrList<T> ::delete(const int p)
	{
		if (curLen <= 0)  //判断元素是否为空，空表不能删除
		{
			cout << "no element to delete \n"<<endl;
			return false;
		}
		if (p<0 || p>curLen-1)  //注意这里是p>curLen-1不是curLen
		{
			cout << "illegal";
			return false;
		}
		for (int i = p; i < curLen-1; i++)
		{
			aList[i] = aList[i + 1];
		}
		curLen--;//这里不需要再对aList[curLen-1]进行清零，因为curLen长度已经减小了
		//最后一个元素不在操作范围内
		return false;
	}
};

链表 

单链表

head 是指向单链表开始结点的指针，tail 是指向单链表尾结点的指针，对链表的访问只能通过头尾指针进行操作

头结点：虚拟结点，值被忽略，不被看做表中的实际元素，避免对空表的处理

操作分别有：

  1. 结点的定义
  2. 单链表的类型定义
  3. 定义链表的构造函数和析构函数
  4. 链表的检索
  5. 链表的插入操作
  6. 链表的删除操作 

说明：Link是模板类，代表着结点

lnkList是单链表类，里面存储着管理链表的方法以及首尾指针 

template <class T> class Link  //代表链表中的一个结点
{
public:
	T data;  //保存结点的内容
	Link<T>* next;  //指向后继结点的指针（指向Link类的指针）
	//函数重载，一个是有一个参数的，另一个是有两个参数的
	Link(const T info, const Link<T>* nextValue = NULL)//既有下一个结点的地址，又有data
		//这里是默认值为NULL，即当只传入data时，默认为最后一个结点
	{
		data = info;
		next = nextValue;
	}
	Link(const Link<T>* nextValue)//只指向下一个结点的指针，但是并没有值
	{
		next = nextValue;
	}
};
//单链表的类型定义
//在定义模板类时，必须在类名之前加上模板参数声明template <class T>
template <class T> class lnkList:public List<T>
{
private:
	Link<T>* head, * tail;
	Link<T>* setPos(const int p);   //返回线性表指向第p个元素的指针值
public:
	lnkList(int s);
	~lnkList();
	bool isEmpty();
	...
    bool getPos(int& p, const T value);
};
//带有头结点的单链表的构造函数和析构函数
template<class T> lnkList<T>::lnkList(int defSize)
//在类外定义函数的时候要把模板类写完整了，加上<T>
{
	head = tail = new Link<T>;
}
template <class T> lnkList<T>::~lnkList()
{
	Link<T>* tmp;
	while (head != NULL)
	{
		tmp = head;
		head = head->next;
		delete tmp;
//要先将head值给tmp（注意这里是指针的关系），然后再让head等于下一个指针
//删除了tmp也就相当于删除了第一个head
//如果直接delete head就会丧失对下一个结点的访问权
	}
}
//链表的检索
template <class T> Link<T>* lnkList<T>::setPos(int i)
{
	int count = 0;
	if (i == -1) return head;
	Link<T>* p = head->next;  //创建一个新结点，p指针是一个指向Link类型变量的指针，
	//在这个Link类型变量中是
	while (p != NULL && count < i)
	{
		p = p->next;
		count++;
	}
	return p;
}
//链表的插入
template <class T> bool lnkList<T> ::insert(const int i, const T value)
{
	Link<T>* p,*q;
	//调用 setPos 函数找到插入位置的前一个节点
	if ((p = setPos(i - 1)) == NULL)
	{
		cout << "非法插入点";
		return false;
	}
	q = new Link<T>(value, p->next); //q是新构建的结点
	p->next = q; //将新的q结点插入至p结点之后，也就是说p是q的上一个结点
	if (p == tail)
		tail = q;
	return true;
}
//链表的删除
template <class T> bool lnkList<T>::delete(const int i)
{
	Link<T>* p, * q;
	if ((p = setPos(i - 1)) == NULL || p == tail)
	{
		cout << "非法删除点";
		return false;
	}
	q = p->next;//q是真正的待删结点
	if (q == tail)
	{
		tail = p;
		p->next = NULL;
		delete q;
	}
	else if (q != NULL)
	{
		p->next = q->next;
		delete q;
	}
	return true;
}

链表实验题

顺序表做法

偶遇顺序表难题，用指针+结构体做拼尽全力无法战胜，用数组做十分钟轻松战胜（但是sstream学了一阵子）

#include<iostream>
#include<cmath>
#include<sstream>
using namespace std;
int a[10000], b[10000];
int main()
{
	string line1, line2;
	getline(cin, line1);
	getline(cin, line2);

	stringstream ss1(line1);
	stringstream ss2(line2);
	int m, n;//m是系数，n是指数
	while (ss1 >> m >> n)
	{
		a[n] = m;
	}
	while (ss2 >> m >> n)
	{
		b[n] = m;
	}
	int len = max(sizeof(a) / 4, sizeof(b) / 4);
	for (int i = 0; i < len; i++)
	{
		a[i] += b[i];
	}
	for (int i = len - 1; i >= 0; i--)
	{
		if (a[i] == 0)   continue;
		cout << a[i] << " " << i << " ";
	}
	return 0;
}

链表做法

#include<iostream>
#include<cmath>
#include<sstream>
using namespace std;
class node
{
	int data;
	node* next;
	node(const int info,node* nextnode)
	{
		data = info;
		next = nextnode;
	}
	node(node* nextnode)
	{
		next = nextnode;
	}
};
class list {

};
int main()
{

}
#include<iostream>
#include<cmath>
#include<sstream>
using namespace std;
struct node  //创建新结点
{
	int m;//系数
	int n;//指数
	node* next;
	node(int a, int b)
	{
		m = a;
		n = b;
		next = nullptr;
	}
};
node* creat()//创建多项式列表
{
	node* head = nullptr;  //表示指向第一个结点的指针
	node* tail = nullptr;  //表示当前最新结点的指针，等全部录入完毕就是指向最后一个结点
	string ss1;
	getline(cin, ss1);
	stringstream sss(ss1);
	int a, b;
	while (sss >> a >> b)
	{
//每次新建一个结点，给它一个新的指针
		node* newnode = new node(a, b);  //返回内存地址
		if (!head) head = tail = newnode;
		else
		{
//假设原来链表为A-->B-->C，此时tail指向C，当执行ail->next = newnode时候将C和新结点D连接在一起，
// 链表变成A-->B-->C-->D，然后再把tail更新成最新的D			
			tail->next = newnode; tail = newnode;
		}
	}
	return head;  //返回头指针就是返回整条链表
}
node* add(node* f1, node* f2) {
	node index(0, 0);
	node* tail = &index;
	while (f1 && f2) {
		if (f1->n > f2->n) {
//经典操作，同创建链表里头的
			tail->next = f1;
			tail = tail->next;
			f1 = f1->next;
		}
		else if (f1->n < f2->n) {
			tail->next = f2;
			tail = tail->next;
			f2 = f2->next;
		}
		else {
//如果相等的话就复杂了
			int sum = f1->m + f2->m;
			node* tmp1 = f1;
			node* tmp2 = f2;
//先都往后移动一个结点
			f1 = f1->next;
			f2 = f2->next;
			if (sum != 0) {
				tmp1->m = sum;
//经典操作，连接新结点tmp1并更新tail
				tail->next = tmp1;
				tail = tail->next;
				tail->next = nullptr; // 防止遗留指针，相当于切断了和原来链的联系
//假设 f1 链表为 A(系数 3, 指数 2) -> B(系数 1, 指数 1)，f2 链表为 C(系数 2, 指数 2) -> D(系数 4, 指数 1)。
// 当处理到指数为 2 的节点 A 和 C 时，系数相加结果为 3 + 2 = 5，将 A 的系数更新为 5 并连接到新链表尾部。
// 如果不将 tail->next 置为 nullptr，A 原本的 next 指针仍然指向 B，这会导致新链表中在 A 后面错误地连接了 B，
// 而后续可能会继续错误地处理这些遗留节点。
			}
			else {
				delete tmp1;
			}
//tmp2总是要删的
			delete tmp2;
		}
	}
//其实后面 f1?f1:f2 才是一个整体，如果f1存在，那么就接上f1的值
	tail->next = f1 ? f1 : f2;
//返回首结点的地址
	return index.next;
};

void print(node* f1)
{
	node* cur = f1;
	bool first = true;
	while (cur)
	{
		if (!first)
		{
			cout << " ";
		}
		cout << cur->m << " " << cur->n;
		first = false;
		cur = cur->next;
	}
}
void free(node* f)
{
	while (f)
	{
		node* tmp = f;
		f = f->next;
		delete tmp;
	}
}
int main()
{
	node* f1 = creat();
	node* f2 = creat();
	node* summ = add(f1, f2);
	print(summ);
	free(summ); 
    free(f1);
    free(f2);
	return 0;
}

链表实验选做题

 照葫芦画瓢总算出来一个，但是需要逆序输出，但是爷爷懒得写直接存个数组里头逆序输出了hhh

#include<iostream>
#include<sstream>
using namespace std;

struct node
{
	int data;
	node* next;
	node(int a)
	{
		data = a;
		next = nullptr;
	}
};
node* creat()
{
	node* head=nullptr;
	node* tail=nullptr;
	
	string s;
	getline(cin, s);
	stringstream ss(s);
	int a;
	while (ss >> a)
	{
		node* newnode = new node(a);
		if (!head) head = tail = newnode;
		else 
		{
			tail->next = newnode;
			tail = newnode;
		}
	}
	return head;
}
node* order(node* f1, node* f2)
{
	node index(0);
	node* tail = &index;
	while (f1 && f2)
	{
		if (f1->data < f2->data)
		{
			tail->next = f1;
			tail = tail->next;
			f1 = f1->next;
		}
		else if (f1->data > f2->data)
		{
			tail->next = f2;
			tail = tail->next;
			f2 = f2->next;
		}
		else
		{
			
			f1 = f1->next;
			f2 = f2->next;
			
			tail->next = f1;
			tail = tail->next;
			tail->next = f2;
			tail = tail->next;
			
		}
	}
	tail->next= f1 ? f1 : f2;
	return index.next;
}
void print(node* head)
{
	int count = 0;
	int a[100000] = { 0 };
	node* tail = head;
	while (tail)
	{
		count++;
		a[count] = tail->data;
		tail = tail->next;
	}
	for (int i = count; i >= 1; i--) cout << a[i] << " ";
}
void free(node* f)
{
	while (f)
	{
		node* cur = f;
		f = f->next;
		delete cur;
	}
}
int main()
{
	node* f1 = creat();
	node* f2 = creat();
	node* result = order(f1, f2);
	print(result);
	free(result);
	return 0;
}

洛谷 单向链表

题目描述

实现一个数据结构，维护一张表（最初只有一个元素 1）。需要支持下面的操作，其中 x 和 y 都是 1 到 106 范围内的正整数，且保证任何时间表中所有数字均不相同，操作数量不多于 105：

  • 1 x y ：将元素 y 插入到 x 后面；
  • 2 x ：询问 x 后面的元素是什么。如果 x 是最后一个元素，则输出 0；
  • 3 x：从表中删除元素 x 后面的那个元素，不改变其他元素的先后顺序。

输入格式

第一行一个整数 q 表示操作次数。

接下来 q 行，每行表示一次操作，操作具体见题目描述。

输出格式

对于每个操作 2，输出一个数字，用换行隔开。

输入输出样例

输入 

6
1 1 99
1 99 50
1 99 75
2 99
3 75
2 1

输出

75
99

一开始写的完美无瑕的代码结果T了两个点

#include<iostream>
#include<sstream>
using namespace std;
struct node
{
	int data;
	node* next;
	node(int n)
	{
		data = n;
		next = nullptr;
	}
};
node* setpos(node* head,int x)  
{
	node* cur = head;
	while (cur->data != x)
	{
		cur = cur->next;
	}
	return cur;
}
node* insert(node* head,int x,int y)
{
	node* cur = setpos(head, x);
	node* cur2 = cur->next;
	node* newnode=new node(y);
	newnode->next = cur2;
	cur->next = newnode;
	return head;
}
node* remove(node* head,int x)
{
	node* cur = setpos(head, x);
	node* cur1 = cur->next;	
	cur->next=cur1->next;
	delete cur1;
	return head;
}
void print(node* curnode)
{
	cout <<curnode->data<<endl;
}
void free(node* head)
{
	while (head)
	{
		node* tmp = head;
		head = head->next;
		delete tmp;
	}
}
int main()
{
	int n,k,x,y;
	cin >> n;
	node* index = new node(1);
	node* cur = nullptr;

	for (int i = 0; i < n; i++)
	{
		cin >> k;
		if (k == 1)
		{
			cin >> x >> y;
			index = insert(index, x, y);
		}
		else if (k == 2)
		{
			cin >> x;
			cur= setpos(index, x);
			cur = cur->next;
			if (!cur) {cout << 0<< endl; continue;}
			print(cur);
		}
		else if (k == 3)
		{
			cin >> x;
			index = remove(index, x);
		}
	}
	free(index);
	return 0;
}

 那应该是还得优化，但是怎么优化呢，网上优化代码看不懂思密达，但是我会写数组呀嘻嘻

#include<iostream>
#include<sstream>
using namespace std;
int a[1000000];  //a[i]中i表示data，a[i]表示下一个结点的地址（就是第几位）
void insert()
{
	int x, y;
	cin >> x >> y;
	a[y] = a[x];
	a[x] = y;
}
void remove()
{
	int x;
	cin >> x;
	a[x] = a[a[x]];
}
int main()
{
	a[1] = 0;
	int k,n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> k;
		if (k == 1) insert();
		if (k == 2)
		{
			int x;
			cin >> x;
			if (!a[x])
			{
				cout << 0 << endl;
				continue;
			}
			else cout << a[x]<<endl;
		}
		if (k == 3) remove();
	}
	return 0;
}

洛谷 临值查找

题目描述

给定一个长度为 n 的序列 A，A 中的数各不相同。

对于 A 中的每一个数 Ai​，求：

min1≤j<i​∣Ai​−Aj​∣

以及令上式取到最小值的 j（记为 Pi​）。若最小值点不唯一，则选择使 Aj​ 较小的那个。

输入格式

第一行输入整数 n，代表序列长度。

第二行输入 n 个整数 A1​∼An​，代表序列的具体数值，数值之间用空格隔开。

输出格式

输出共 n−1 行，每行输出两个整数，数值之间用空格隔开。

分别表示当 i 取 2∼n 时，对应的 min1≤j<i​∣Ai​−Aj​∣ 和 Pi​ 的值。

输入输出样例

输入

3
1 5 3

输出 

4 1
2 1

 全WA（笑）后来发现题目理解错了，人家让找最小的data，不是最小的id

修改后还是错

#include<iostream>
#include<sstream>
#include<cmath>
#include<climits> //使用INT_MAX
using namespace std;
struct node
{
	int data;
	int id;
	node* next = NULL;
	node(int n,int z)
	{
		data = n;
		id = z;
	}
};
void result(node* head, node* cur)
{
	int min_ans = INT_MAX;
	int index = -1;
	int select_val = INT_MAX;
	while (head != cur)
	{
		int cur_data = abs(cur->data - head->data);
		if (cur_data< min_ans||cur_data==min_ans&&head->data<select_val)
		{
			min_ans = cur_data;
			select_val = head->data;
			index = head->id;
		}
		head = head->next;
	}
	cout << min_ans << " " << index << endl;
}

int main()
{
	int n,k;
	cin >> n;
	node* head = NULL;
	node* tail = NULL;
	bool flag = true;
	for (int i = 1; i <= n; i++)
	{
		cin >> k;
		node* newnode = new node(k,i);
		if (!head) { head = tail = newnode; flag = false; }
		tail->next = newnode;
		tail = newnode;
		if(i!=1) result(head, tail);
	}
	return 0;
}

这里出现问题的在于

if (!head) { head = tail = newnode; flag = false; }
		tail->next = newnode;
		tail = newnode;

这里在首结点吧tail的next赋值newnode，造成循环链表，正确写法应该是：

if (!head) { head = tail = newnode; flag = false; }
		else {tail->next = newnode;
		tail = newnode;}

全部改完以后没问题了，但是还是T了四个点

用set优化，快速排序，这样就不用一个一个找了

#include<iostream>
#include<sstream>
#include<cmath>
#include<set>
#include <climits> // 添加头文件以使用INT_MAX
using namespace std;
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n, val;
	
	cin >> n;
	set<pair<int,int>> nums;
	for (int i = 1; i <= n; i++)
	{
		cin >> val;
		int min_diff = INT_MAX;//记录最小差值
		int min_val = INT_MAX;//记录最小的Aj
		int ans_id = -1;
		if (i == 1)
		{
			nums.insert({ val,i });
			continue;
		}
		auto it = nums.lower_bound({val,0});
		//nums.end() 返回的末尾迭代器不指向任何有效元素
		if (it != nums.end())
		{
			if (abs(val - it->first) < min_diff || abs(val - it->first) == min_diff && it->first < min_val)
			{
				min_diff = abs(val - it->first);
				min_val = val;
				ans_id = it->second;
			}
		}
		if (it != nums.begin()) 
		{
            it--;
		    if (abs(val - it->first) < min_diff || abs(val - it->first) == min_diff && it->first < min_val)
		    {
			    min_diff = abs(val - it->first);
			    min_val = val;
			    ans_id = it->second;
		    }
		}
		cout << min_diff << " " << ans_id<<'\n';
		nums.insert({ val,i });
	}
	return 0;
}

 学到了用set的很多知识，比如：

1.set中每一个元素的键值都唯一，所以在向set中插入相同的数据的时候，会插不进去

2.所有元素都会根据元素的字典序进行排序，先比较第一个，第一个一样大就比较第二个，默认从小到大

3.迭代器声明时用auto it=nums容器中某个元素，表示这个元素的时候就用 it->first 和 it->second 来表示

4.nums.end()返回的末尾迭代器不指向任何有效元素

5.用于解除cin和cout的绑定，加快速度防止TLE

ios::sync_with_stdio(false);
cin.tie(0);

6.set声明：set<pair<int,int>> 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2311966.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

算法.习题篇

算法.习题篇

算法 — 地大复试 模拟 while循环和MOD循环计数 1.约瑟夫问题 http://bailian.openjudge.cn/practice/3254 using namespace std;bool isNoPeople(vector<bool> c)//判断当前数组是否一个小孩都没有了 {bool nopeople true;for (bool ival : c){if ( ival true)nop…
阅读更多...
大语言模型进化论：从达尔文到AI的启示与展望

大语言模型进化论：从达尔文到AI的启示与展望

文章大纲 引言大语言模型中的“进化论”思想体现遗传变异过度繁殖和生存斗争大模型“过度繁殖”与“生存竞争”机制解析**一、过度繁殖：技术迭代的指数级爆发****二、生存竞争：计算资源的达尔文战场****三、生存竞争胜出关键要素****四、行业竞争格局演化趋势**核心结论自然选…
阅读更多...
编程考古-Borland历史：《.EXE Interview》对Anders Hejlsberg关于Delphi的采访内容（上）

编程考古-Borland历史：《.EXE Interview》对Anders Hejlsberg关于Delphi的采访内容（上）

为了纪念Delphi在2002年2月14日发布的25周年（2020.2.12），这里有一段由.EXE杂志编辑Will Watts于1995年对Delphi首席架构师Anders Hejlsberg进行的采访记录。在这次采访中，Anders讨论了Delphi的设计与发展，以及即将到来的针对Windows 95的32位版本。 问： Delphi是如何从T…
阅读更多...
系统架构设计师—系统架构设计篇—基于体系结构的软件开发方法

系统架构设计师—系统架构设计篇—基于体系结构的软件开发方法

文章目录 概述基于体系结构的开发模型-ABSDM体系结构需求体系结构设计体系结构文档化体系结构复审体系结构实现体系结构演化 概述 基于体系结构&#xff08;架构&#xff09;的软件设计&#xff08;Architecture-Based Software Design&#xff0c;ABSD&#xff09;方法。 AB…
阅读更多...
基于Python+Django的网上招聘管理系统

基于Python+Django的网上招聘管理系统

项目介绍 PythonDjango网上招聘系统的设计与实现(Pycharm Django Vue Mysql) 平台采用B/S结构&#xff0c;后端采用主流的Python语言进行开发&#xff0c;前端采用主流的Vue.js进行开发。整个平台包括前台和后台两个部分。 - 前台功能包括&#xff1a;首页、岗位详情页、简历中…
阅读更多...
Vue23Web 基礎性拉滿的面試題(2025版)還沒更新完...

Vue23Web 基礎性拉滿的面試題(2025版)還沒更新完...

Vue2&3 基礎性1. 關於Vue2和Vue3生命週期的差別2. Vue2&3組件之間傳參不同點Vue2 傳遞與接收Vue3 傳遞與接收 (使用script setup語法糖)Vue3 傳遞與接收 (不使用script setup語法糖) 3. Vue2&3 keep-alive 組件Vue2 keep-aliveVue3 keep-alive 進階性爲什麽POST請求…
阅读更多...
GitHub神秘组织3小时极速复刻Manus

GitHub神秘组织3小时极速复刻Manus

一、背景 昨夜科技圈被两个关键词刷屏&#xff1a;​Manus激活码炒至6万&#xff0c;​GitHub神秘项目OpenManus突然开源。 Manus之所以如此火爆&#xff0c;是因为在演示视频中自主分析股票、筛选简历、规划旅行的能力。同时&#xff0c;想要体验Manus就需要内测邀请码&…
阅读更多...
文件上传漏洞（upload靶场）

文件上传漏洞（upload靶场）

目录 Pass-01&#xff1a;前端绕过 方法一&#xff1a;浏览器禁用js 方法二:直接修改或删除js脚本 方法三&#xff1a;修改后缀绕过 Pass-02:服务器检测 Pess-03:黑名单绕过 Pass-04:.htaccess文件 Pass-05:windows特性和user.ini 方法一&#xff1a;php.自动解析为ph…
阅读更多...
苦瓜书盘官网，免费pdf/mobi电子书下载网站

苦瓜书盘官网，免费pdf/mobi电子书下载网站

苦瓜书盘&#xff08;kgbook&#xff09;是一个专注于提供6英寸PDF和MOBI格式电子书的免费下载平台&#xff0c;专为电子阅读器用户设计。该平台为用户提供了丰富的电子书资源&#xff0c;涵盖文学、历史、科学、技术等多个领域&#xff0c;旨在打造一个全面的电子书资源库。用…
阅读更多...
Linux:理解进程，系统调用，进程，进程切换，调度，分时操作系统和实时操作系统，

Linux:理解进程，系统调用，进程，进程切换，调度，分时操作系统和实时操作系统，

操作系统要向上提供对应的服务 操作系统&#xff0c;不相信任何用户或者人&#xff1b;------------银行------窗口 因此提供了系统调用&#xff0c;&#xff08;函数调用&#xff09;-->用户和操作系统之间进行某种数据交互 一&#xff1a;系统调用 计算机的各种硬件资…
阅读更多...
【javaEE】多线程（基础）

【javaEE】多线程（基础）

1.❤️❤️前言~&#x1f973;&#x1f389;&#x1f389;&#x1f389; Hello, Hello~ 亲爱的朋友们&#x1f44b;&#x1f44b;&#xff0c;这里是E绵绵呀✍️✍️。 如果你喜欢这篇文章&#xff0c;请别吝啬你的点赞❤️❤️和收藏&#x1f4d6;&#x1f4d6;。如果你对我的…
阅读更多...
vscode - 操作整理

vscode - 操作整理

文章目录 vscode - 操作整理概述笔记打开文件后&#xff0c;编码另存为配置指定后缀的文件的语言模式语言模式配置 - Batch 安装eol插件配置文件如果用vscode打开的文件没有显示回车&#xff0c;原因及处理vscode启用了信任模式&#xff0c;需要信任工作区才行。 将打开的文件中…
阅读更多...
linux 基本命令教程，巡查脚本，kali镜像

linux 基本命令教程，巡查脚本，kali镜像

linux实操 shutdown练习 Shutdown -h 5 意思是五个小时之后进行重启 新用户密码设置&#xff0c; Useradd 用户名 新建用户 Passwd 进行设置密码 覆盖关机时间 Shutdown -c 取消重启设置 top练习 查看进程 僵尸进程 kill&#xff1a;查看jobs号直接杀死 kill %num 查看…
阅读更多...
R语言使用scitable包交互效应深度挖掘一个陌生数据库

R语言使用scitable包交互效应深度挖掘一个陌生数据库

很多新手刚才是总是觉得自己没什么可以写的&#xff0c;自己不知道选什么题材进行分析&#xff0c;使用scitable包后这个完全不用担心&#xff0c;选题多到你只会担心你写不完&#xff0c;写得不够快。 今天演示一下使用scitable包深度挖掘一个陌生数据库 先导入R包和数据 li…
阅读更多...
【记录一下学习】Embedding 与向量数据库

【记录一下学习】Embedding 与向量数据库

一、向量数据库 向量数据库&#xff08;Vector Database&#xff09;&#xff0c;也叫矢量数据库&#xff0c;主要用来存储和处理向量数据。 在数学中&#xff0c;向量是有大小和方向的量&#xff0c;可以使用带箭头的线段表示&#xff0c;箭头指向即为向量的方向&#xff0c…
阅读更多...
【Linux-网络】从逻辑寻址到物理传输：解构IP协议与ARP协议的跨层协作

【Linux-网络】从逻辑寻址到物理传输：解构IP协议与ARP协议的跨层协作

&#x1f3ac; 个人主页&#xff1a;谁在夜里看海. &#x1f4d6; 个人专栏&#xff1a;《C系列》《Linux系列》《算法系列》 ⛰️ 道阻且长&#xff0c;行则将至 目录 &#x1f4da;前言 &#x1f4d6; IP地址的组成 &#x1f516;IPv4 &#x1f516;IPv6 &#x1f4da…
阅读更多...
解锁前端表单数据的秘密旅程：从后端到用户选择！✨

解锁前端表单数据的秘密旅程：从后端到用户选择！✨

&#x1f604; 解锁前端表单数据的秘密旅程&#xff1a;从后端到用户选择&#xff01;✨ 嘿&#xff0c;技术爱好者们&#xff01;&#x1f44b; 你有没有在开发中遇到过这样的困惑&#xff1a;表单里的数据&#xff08;比如图片附件、识别点 ID&#xff09;从哪儿来的&#x…
阅读更多...
【机械视觉】C#+visionPro联合编程———【一、C# + VisionPro 联合编程详解以及如何将visionPro工具加载到winform】

【机械视觉】C#+visionPro联合编程———【一、C# + VisionPro 联合编程详解以及如何将visionPro工具加载到winform】

机械视觉与 C# VisionPro 联合编程详解 目录 机械视觉与 C# VisionPro 联合编程详解 概念 应用场景 1. 工业检测与质量控制缺陷检测 2. 定位与机器人引导 3. 识别与分类 4. 复杂流程控制 将visionPro工具加载到winform 环境准备 一、创建winform项目 二、打开窗体…
阅读更多...
江科大51单片机笔记【9】DS1302时钟可调时钟（下）

江科大51单片机笔记【9】DS1302时钟可调时钟（下）

在写代码前&#xff0c;记得把上一节的跳线帽给插回去&#xff0c;不然LCD无法显示 一.DS1302时钟 1.编写DS1302.c文件 &#xff08;1&#xff09;重新对端口定义名字 sbit DS1302_SCLKP3^6; sbit DS1302_IOP3^4; sbit DS1302_CEP3^5;&#xff08;2&#xff09;初始化 因为…
阅读更多...
发行思考：全球热销榜的频繁变动

发行思考：全球热销榜的频繁变动

几点杂感&#xff1a; 1、单机游戏销量与在线人数的衰退是剧烈的&#xff0c;有明显的周期性&#xff0c;而在线游戏则稳定很多。 如去年的某明星游戏&#xff0c;最高200多万在线&#xff0c;如今在线人数是48名&#xff0c;3万多。 而近期热门的是MH&#xff0c;在线人数8…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023