《算法笔记》第四章源代码

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量91 收藏
点赞数
分类专栏： 算法笔记学习 文章标签： 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53218344/article/details/120242516
版权

P99

#include<iostream>
using namespace std;
const int n = 8;
int a[n] = {8,7,6,5,4,3,2,1};
void selectSort();
int main(){
	selectSort();
	for(int i = 0; i < n; i++){
		printf("%d ",a[i]);
	}
	return 0;
}
void selectSort(){
	for(int i = 0; i < n; i++){
		int k = i;
		for(int j = i; j < n; j++){
			if(a[j] < a[k]){
				k = j;
			}
		}
		int temp = a[k];
		a[k] = a[i];
		a[i] = temp;
	}
}

P101

#include<iostream>
using namespace std;
const int n = 8;
int a[n] = {8,7,6,5,4,3,2,1};
void insertSort();
int main(){
	insertSort();
	for(int i = 0; i < n; i++){
		printf("%d ",a[i]);
	}
	return 0;
}
void insertSort(){
	for(int i = 1; i < n; i++){
		int j = i,temp = a[j];
		while(j > 0 && temp < a[j-1]){
			a[j] = a[j-1];
			j--;
		}
		a[j] = temp;
	}
}

P105

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
struct Student {
	char id[15];
	int score;
	int location_number;
	int local_rank;
}stu[30010];
bool cmp(Student a, Student b){
	if(a.score != b.score){
		return a.score > b.score;
	}else{
		return a.id < b.id;
	}
}
int main(){
	int n,k,num = 0;
	scanf("%d",&n);
	for(int i = 1; i <= n; i++){
		scanf("%d",&k);
		for(int j = 0; j < k; j++){
			scanf("%s %d",stu[num].id,&stu[num].score);
			stu[num].location_number = i;
			num++;
		}
		sort(stu + num - k, stu + num, cmp);
		stu[num - k].local_rank = 1;							//第一种排名法
		for(int j = num - k + 1; j < num; j++){					//
			if(stu[j].score == stu[j - 1].score){				//
				stu[j].local_rank = stu[j - 1].local_rank;		//
			}else{												//
				stu[j].local_rank = j + 1 - (num - k);			//
			}													//
		}
	}
	sort(stu, stu + num, cmp);
	printf("%d\n",num);
	int r = 1;													//第二种排名法
	for(int i = 0; i < num; i++){								//
		if(i > 0 && stu[i].score != stu[i - 1].score){			//
			r = i + 1;											//
		}														//
		printf("%s %d %d %d\n",stu[i].id,r,stu[i].location_number,stu[i].local_rank);
	}	
	return 0;
}

P107(1)

#include<iostream>
using namespace std;
const int maxn = 10010;
bool hashTable[maxn] = {false};
int main(){
	int n,m,x;
	scanf("%d %d",&n,&m);
	for(int i = 0; i < n; i++){
		scanf("%d",&x);
		hashTable[x] = true;
	}
	for(int i = 0; i < m; i++){
		scanf("%d",&x);
		if(hashTable[x] == true){
			printf("YES\n");
		}else{
			printf("NO\n");
		}
	}
	return 0;
}

P107(2)

#include<iostream>
using namespace std;
const int maxn = 10010;
int hashTable[maxn] = {0};
int main(){
	int n,m,x;
	scanf("%d %d",&n,&m);
	for(int i = 0; i < n; i++){
		scanf("%d",&x);
		hashTable[x]++;
	}
	for(int i = 0; i < m; i++){
		scanf("%d",&x);
		printf("%d\n",hashTable[x]);
	}
	return 0;
}

P110

#include<iostream>
using namespace std;
const int maxn = 100;
char S[maxn][5], temp[5];
int hashTable[26 * 26 * 26 + 10] = {0};
int hashFunc(char S[], int len){
	int id = 0;
	for(int i = 0; i < len; i++){
		id = id * 26 + (S[i] - 'A');
	}
	return id;
}
int main(){
	int n,m;
	scanf("%d %d",&n,&m);
	for(int i = 0; i < n; i++){
		scanf("%s",S[i]);
		int id = hashFunc(S[i], 3);
		hashTable[id]++;
	}
	for(int i = 0; i < m; i++){
		scanf("%s",temp);
		int id = hashFunc(temp, 3);
		printf("%d",hashTable[id]);
	}
	return 0;
}

P112

#include<iostream>
using namespace std;
int F(int n){
	if(n == 0){
		return 1;
	}else{
		return F(n-1)*n;
	}
}
int main(){
	int n;
	scanf("%d",&n);
	printf("%d",F(n));
	return 0;
}

P114

#include<iostream>
using namespace std;
int F(int n){
	if(n == 0 || n==1){
		return 1;
	}else{
		return F(n-2) + F(n-1);
	}
}
int main(){
	int n;
	scanf("%d",&n);
	printf("%d",F(n));
	return 0;
}

P115

#include<iostream>
using namespace std;
const int maxn = 11;
int n,P[maxn],hashTable[maxn] = {false};
void generateP(int index){
	if(index == n + 1){
		for(int i = 1; i <= n; i++){
			printf("%d ",P[i]);
		}
		printf("\n");
		return;
	}
	for(int i = 1; i <= n; i++){
		if(hashTable[i] == false){
			P[index] = i;
			hashTable[i] = true;
			generateP(index + 1);
			hashTable[i] = false;
		}
	}
}
int main(){
	n = 3;
	generateP(1);
	return 0;
}

P116

#include<iostream>
#include<math.h>
using namespace std;
int count = 0;
const int maxn = 11;
int n,P[maxn],hashTable[maxn] = {false};
void generateP(int index){
	if(index == n + 1){
		bool flag = true;
		for(int i = 1; i <= n; i++){
			for(int j = i + 1; j <= n; j++){
				if(abs(i - j) == abs(P[i] - P[j])){
					flag = false;
				}
			}		
		}
		if(flag){
			count++;
		}
		return;
	}
	for(int x = 1; x <= n; x++){
		if(hashTable[x] == false){
			P[index] = x;
			hashTable[x] = true;
			generateP(index + 1);
			hashTable[x] = false;
		}
	}
}
int main(){
	n = 8;//n皇后问题 此时 n = 8
	generateP(1);
	printf("%d",count);
	return 0;
}

P117

#include<iostream>
#include<math.h>
using namespace std;
int count = 0;
const int maxn = 11;
int n,P[maxn],hashTable[maxn] = {false};
void generateP(int index){
	if(index == n + 1){
		count++;
		return;
	}
	for(int x = 1; x <= n; x++){
		if(hashTable[x] == false){
			int flag = true;
			for(int pre = 1; pre < index; pre++){
				if(abs(pre - index) == abs(P[pre] - x)){
					flag = false;
					break;
				}
			}
			if(flag){
				P[index] = x;
				hashTable[x] = true;
				generateP(index + 1);
				hashTable[x] = false;
			}
		}
	}
}
int main(){
	n = 8;
	generateP(1);
	printf("%d",count);
	return 0;
}

P120

#include<iostream>
#include<algorithm>
using namespace std;
struct mooncake{
	double store;
	double sell;
	double price;
}cake[1010];
bool cmp(mooncake a, mooncake b){
	return a.price>b.price;
}
int main(){
	int n;
	double D;
	scanf("%d %lf",&n,&D);
	for(int i = 0; i < n; i++){
		scanf("%lf",&cake[i].store);
	}
	for(int i = 0; i < n; i++){
		scanf("%lf",&cake[i].sell);
		cake[i].price = cake[i].sell / cake[i].store ;
	}
	sort(cake, cake + n, cmp);
	double ans = 0;
	for(int i = 0; i < n; i++){
		if(cake[i].store <= D){
			D -= cake[i].store;
			ans += cake[i].sell;
		}else{
			ans += D * cake[i].price;
			break;
		}
	}
	printf("%.2f\n",ans);
	return 0;
}

P121

#include<iostream>
using namespace std;
int main(){
	int count[10];Y
	for(int i = 0; i < 10; i++){
		scanf("%d",&count[i]);
	}
	for(int i = 1; i < 10; i++){
		if(count[i] > 0){
			printf("%d",i);
			count[i]--;
			break;
		}
	}
	for(int i = 0; i < 10; i++){
		for(int j = 0; j < count[i]; j++){
			printf("%d",i);
		}
	}
	return 0;
}

P122

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 110;
struct Inteval{
	int x,y;
}I[maxn];
bool cmp(Inteval a, Inteval b){
	if(a.x != b.x){
		return a.x > b.x;
	}else{
		return a.y < b.y;
	}
}
int main(){
	int n;
	while(scanf("%d",&n), n != 0){
		for(int i = 0; i < n; i++){
			scanf("%d %d",&I[i].x,&I[i].y);
		}
		sort(I, I + n, cmp);
		int ans = 1, lastX = I[0].x;
		for(int i = 1; i < n; i++){
			if(I[i].y <= lastX){
				ans++;
				lastX = I[i].x;
			}
		}
		printf("%d\n",ans);
	}
	return 0;
}

P126(递归)

#include<iostream>
using namespace std;
int binarySearch(int A[], int left, int right, int x){
	if(left <= right){
		int mid = (right + left) / 2;
		if(x == A[mid]){
			return mid;
		}else if(x < A[mid]){
			return binarySearch(A, left, mid - 1, x);
		}else{
			return binarySearch(A, mid + 1, right, x);
		}
	}else{
		return -1;
	}
}
int main(){
	const int n = 10;
	int A[n] = {1, 3, 4, 6, 7, 8, 10, 11, 12, 15};
	printf("%d %d",binarySearch(A, 0, n - 1, 6),binarySearch(A, 0, n - 1, 9));
	return 0;
}

P126

#include<iostream>
using namespace std;
int binarySearch(int A[], int left, int right, int x){
	int mid;
	while(left <= right){
		mid = left + (right - left) / 2;
		if(A[mid] == x){
			return mid;
		}else if(A[mid] > x){
			right = mid - 1;
		}else{
			left = mid + 1;
		}
	}
	return -1;
}
int main(){
	const int n = 10;
	int A[n] = {1, 3, 4, 6, 7, 8, 10, 11, 12, 15};
	printf("%d %d",binarySearch(A, 0, n - 1, 6),binarySearch(A, 0, n - 1, 9));
	return 0;
}

P128~129

#include<iostream>
using namespace std;
int lower_bound(int A[], int left, int right, int x){
	int mid;
	while(left < right){
		mid = left + (right - left) / 2;
		if(A[mid] >= x){
			right = mid;
		}else{
			left = mid + 1;
		}
	}
	return left;
}
int upper_bound(int A[], int left, int right, int x){
	int mid;
	while(left < right){
		mid = left + (right - left) / 2;
		if(A[mid] > x){
			right = mid;
		}else{
			left = mid + 1;
		}
	}
	return left;
}
int main(){
	const int n = 5;
	int A[n] = {1, 3, 3, 3, 6};
	printf("%d %d",lower_bound(A, 0, n, 3),upper_bound(A, 0, n, 3));//以3为例
	return 0;
}

P131

#include<iostream>
#include<math.h>
using namespace std;
const double eps = 1e-5;
double f(double x){
	return x * x;
}
double calSqrt(){
	double left = 1 , right = 2 , mid;
	while(right - left > eps){
		mid = (right - left) / 2 + left;
		if(f(mid) > 2){
			right = mid;
		}else{
			left = mid;		
		}
	}
	return mid;
}
int main(){	
	printf("%lf",calSqrt());
	return 0;
}

p133

#include<iostream>
#include<math.h>
using namespace std;
const double eps = 1e-5;
const double PI = acos(-1.0);
double f(double R, double h){
	double alpha = 2 * acos((R - h) / R);
	double L = 2 * sqrt(R * R - (R - h) * (R - h));
	double S2 = PI * R * R / 2;
	double S1 = alpha * R * R / 2 - (R - h) * L / 2;
	return S1 / S2;
}
double solve(double R, double r){
	double left = 0, right = R, mid;
	while(right - left > eps){
		mid = (left + right) / 2;
		if(f(R,mid) > r){
			right = mid;
		}else{
			left = mid;
		}
	}
	return mid;
}
int main(){
	double R, r;
	scanf("%lf %lf", &R, &r);
	printf("%lf",solve(R,r));
	return 0;
}

P135

P138

#include<iostream>
using namespace std;
int a[6] = {1, 2, 3, 4, 5, 6};
int M = 8;
int main(){
	int ans = 0, i = 0, j = 5;
	while(i < j){
		if(a[i] + a[j] == M){
			ans++;
			printf("%d %d %d\n", a[i], a[j], ans);
			i++;
			j--;
		}else if(a[i] + a[j] < M){
			i++;
		}else{
			j--;
		}
	}
	printf("%d",ans);
	return 0;
}

P139

#include<iostream>
using namespace std;
int A[5] = {1, 3, 5, 7, 8}, B[5] = {2, 4, 6, 9, 10}, C[10000];
int merge(int A[], int B[], int C[],int m,int n){
	int i = 0, j = 0, index = 0;
	while(i < n && j < m){
		if(A[i] <= B[j]){
			C[index++] = A[i++];
		}else{
			C[index++] = B[j++];
		}
	}
	while(i < n){
		C[index++] = A[i++];
	}
	while(j < m){
		C[index++] = B[j++];
	}
	return index;
}
int main(){
	int max = merge(A, B, C, 5, 5);
	for(int i = 0; i < max; i++){
		printf("%d ",C[i]);
	}
	return 0;
}

P140

#include<stdio.h>
#include<algorithm>
using namespace std;
int a[10]={10,9,8,7,6,5,4,3,2,1};
void merge(int a[],int l1,int r1,int l2,int r2){//将两个相邻的段按顺序合成一个新的段
	int i=l1,j=l2,num=0;
	int temp[1000];
	while(i<=r1&&j<=r2){
		if(a[i]<=a[j]){
			temp[num++]=a[i++];
		}else{
			temp[num++]=a[j++];
		}
	}
	while(i<=r1){
		temp[num++]=a[i++];
	}
	while(j<=r2){
		temp[num++]=a[j++];
	}
	for(int i=0;i<num;i++){
		a[l1++]=temp[i];
	}
}
void select(int a[],int l,int r){
	if(l<r){
		int mid=(l+r)/2;
		select(a,l,mid);
		select(a,mid+1,r);
		merge(a,l,mid,mid+1,r);
	}
}
int main(){
	select(a,0,9);
	for(int i=0;i<10;i++){
		printf("%d  ",a[i]);
	}
	return 0;
}

P141

#include<stdio.h>
#include<algorithm>
using namespace std;
int a[10]={10,9,8,7,6,5,4,3,2,1};
void merge(int a[],int l1,int r1,int l2,int r2){//将两个相邻的段按顺序合成一个新的段
	int i=l1,j=l2,num=0;
	int temp[1000];
	while(i<=r1&&j<=r2){
		if(a[i]<=a[j]){
			temp[num++]=a[i++];
		}else{
			temp[num++]=a[j++];
		}
	}
	while(i<=r1){
		temp[num++]=a[i++];
	}
	while(j<=r2){
		temp[num++]=a[j++];
	}
	for(int i=0;i<num;i++){
		a[l1++]=temp[i];
	}
}
void select(int a[],int n){
	for(int step=2;step/2<=n;step*=2){//左边一半元素大于n时即可退出
		for(int j=0;j<n;j+=step){
			int mid=j+step/2-1;//j到mid有step/2个元素
			if(mid+1<=n){
				int k=0;
				if(n<j+step-1){//寻找此时两个段的最右元素 因为在处理最右边的两个段时 右半<=左半
					k=n;
				}else{
					k=j+step-1;
				}
				merge(a,j,mid,mid+1,k);//两个段有序合并
			}
		}
	}
}
int main(){
	select(a,9);//从0开始操作故为9
	for(int i=0;i<10;i++){
		printf("%d  ",a[i]);
	}
	return 0;
}

P143

#include<stdio.h>
int a[10]={10,9,8,7,6,5,4,3,2,1};
int part(int a[],int l,int r){
	int temp=a[l];
	while(l<r){
		while(a[r]>temp&&l<r){
			r--;
		}
		a[l]=a[r];
		while(a[l]<=temp&&l<r){
			l++;
		}
		a[r]=a[l];
	}
	a[l]=temp;
	return l;
}
void quicksort(int a[],int l,int r){
	if(l<r){
		int pos=part(a,l,r);
		quicksort(a,l,pos-1);
		quicksort(a,pos+1,r);
	}		
}
int main(){
	quicksort(a,0,9);
	for(int i=0;i<10;i++){
		printf("%d   ",a[i]);
	}
	return 0;
}

P144

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main(){
	srand((unsigned)time(NULL));
	for(int i=0;i<7;i++){
		printf("%d  ",rand());
	}
	return 0;
}

P145(1)

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main(){
	srand((unsigned)time(NULL));
	int a,b;
	scanf("%d %d",&a,&b);
	for(int i=0;i<7;i++){
		printf("%d  ",rand()%(b-a+1)+a);
	}
	return 0;
}

P145(2)

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>

int main(){
	srand((unsigned)time(NULL));
	int a,b;
	scanf("%d %d",&a,&b);
	for(int i=0;i<7;i++){
		printf("%d  ",(int)(round(1.0*rand()/RAND_MAX*(b-a)))+a);//round为四舍五入函数 
	}
	return 0;
}

P146

#include<iostream>
#include<time.h>
#include<math.h>
using namespace std;
int a[10]={10,9,8,7,6,5,4,3,2,1};
int part(int a[],int l,int r){
	int p=(round(1.0*rand()/RAND_MAX*(r-l)+l));
	swap(a[l],a[p]);
	int temp=a[l];
	while(l<r){
		while(a[r]>temp&&l<r){
			r--;
		}
		a[l]=a[r];
		while(a[l]<=temp&&l<r){
			l++;
		}
		a[r]=a[l];
	}
	a[l]=temp;
	return l;
}
void quicksort(int a[],int l,int r){
	if(l<r){
		int pos=part(a,l,r);
		quicksort(a,l,pos-1);
		quicksort(a,pos+1,r);
	}		
}
int main(){
	srand((unsigned)time(NULL));
	quicksort(a,0,9);
	for(int i=0;i<10;i++){
		printf("%d   ",a[i]);
	}
	return 0;
}

P148

#include<iostream>
#include<string.h>
using namespace std;
const int MAXN = 100010;
const int MOD = 1000000007;
char str[MAXN];
int leftNumP[MAXN] = {0};
int main(){
	gets(str);
	int len = strlen(str);
	for(int i = 0; i < len; i++){
		if(i > 0){
			leftNumP[i] = leftNumP[i - 1];
		}
		if(str[i] == 'P'){
			leftNumP[i]++;
		}
	}
	int ans = 0, rightNumT = 0;
	for(int i = len - 1; i >= 0; i--){
		if(str[i] == 'T'){
			rightNumT++;
		}else if(str[i] == 'A'){
			ans = (ans + leftNumP[i] * rightNumT) % MOD;
		}		
	}
	printf("%d\n",ans);
	return 0;
}

P149

#include<iostream>
#include<time.h>
#include<math.h>
using namespace std;
int randPartition(int A[],int left,int right){
	int p=(round(1.0*rand()/RAND_MAX*(right-left)+left));
	swap(A[p],A[left]);
	int temp=A[left];
	while(left<right){
		while(left<right&&A[right]>temp){
			right--;
		}
		A[left]=A[right];
		while(left<right&&A[left]<temp){
			left++;
		}
		A[right]=A[left];
	}
	A[left]=temp;
	return left;
}
int randSelect(int A[],int left,int right,int K){
	if(left==right){
		return A[left];
	}
	int p=randPartition(A,left,right);
	int M=p-left+1;
	if(M==K){
		return A[p];
	}else if(K<M){
		return randSelect(A,left,p-1,K);
	}else{
		return randSelect(A,p+1,right,K-M);
	}
}
int main(){
	int A[10]={5,6,8,7,9,3,1,2,4,0};
	int x=10;//查找在A数列中第x大的数  x=1 输出0 x=2 输出1 x=10 输出9
	printf("%d",randSelect(A,0,9,x));
	
	return 0;
}

P150

#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
const int maxn=100010;
int A[maxn],n;
int randPartition(int A[],int left,int right){
	int p=(round(1.0*rand()/RAND_MAX*(right-left)+left));
	swap(A[p],A[left]);
	int temp=A[left];
	while(left<right){
		while(left<right&&A[right]>temp){
			right--;
		}
		A[left]=A[right];
		while(left<right&&A[left]<temp){
			left++;
		}
		A[right]=A[left];
	}
	A[left]=temp;
	return left;
}
void randSelect(int A[],int left,int right,int K){
	if(left==right){
		return;
	}
	int p=randPartition(A,left,right);
	int M=p-left+1;
	if(M==K){
		return;
	}else if(K<M){
		randSelect(A,left,p-1,K);
	}else{
		randSelect(A,p+1,right,K-M);
	}
}
int main(){
	srand((unsigned)time(NULL));
	int sum=0,sum1=0;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&A[i]);
		sum+=A[i];
	}
	randSelect(A,0,n-1,n/2);
	for(int i=0;i<n/2;i++){
		sum1+=A[i];
	}
	printf("%d",(sum-sum1)-sum1);	
	return 0;
}
LuxArcher
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《算法》第四版阅读笔记
Leonhardtskw的博客
10-14 179
《算法》第四版阅读笔记 第1章 基础 1.1 基础编程模型 1.1.1 java程序的基本结构 七种语法： 原始数据：整形、浮点型、布尔值； 语句：声明、赋值、条件、循环、调用、返回； 数组：同种数据类型的值得集合； 静态方法：封装并重用代码； 字符串：java内置一些操作； 标准输入/输出：与外界联系的桥梁； 数据抽象：支持面向对象的编程。 1.1.2 原始数据类型与表达式 4种java语言原始数据类型： 整形(int)：32位*（不根据机器改变），−231-2^{31}−231~+231+1+2
javaee第四章源代码
06-09
这个第四章的源代码很可能是围绕JavaEE的核心技术展开的，包括但不限于Servlet、JSP、JavaBeans、EJB（Enterprise JavaBeans）以及相关的MVC（Model-View-Controller）设计模式等内容。 在JavaEE体系中，Servlet是...
算法笔记实践
02-08
各种数据结构和算法的注释和实践代码。 内容： 数组 链表 弦 树木 字典和哈希图 套
Algorithm-Exercises:《算法笔记》习题代码
03-09
算法练习 《算法笔记》习题代码 《算法笔记》学习过程中运作的OJ习题代码。 此书的习题分散于不同平台，因此将其统一归类存档。 更多学习笔记： OJ平台：
算法笔记.胡凡(详细书签).zip
05-19
不是伪代码，不是伪代码，不是伪代码。通俗易懂，适合萌新小白前期打好算法基础。里面对题目进行了多种算法描述，而且是可以实现的。
Algorithm:算法笔记
05-06
算法笔记 发起时间：2021/02/14 背景介绍：由大学开始接触程式，大半靠着网路上的资源自学，大二因缘际会下，参与了ACM竞赛，经过一学期的磨练后，无论是对演算法的理解，还是程式的码风都有大幅的改变，因此想透过笔记的形式好好梳理一次掌握的算法，也在未来了解新的算法时，记录自己学习的历程。 更新： 更新日期 分类 算法 2021/02/14 数据结构 树状数组 2021/02/15 数据结构 并查集与种类并查集 2021/02/16 数据结构 线段树 2021/02/17 其他 离散化 2021/02/17 数据结构 st表 2021/02/19 数据结构 分块 2021/03/01 分治 三分搜寻 2021/03/06 数论 质数筛法 2021/03/08 数论 扩展欧几里德与模逆元 每个算法标题为该算法的笔记，下方的连结为模板code 数据结构 数论 扩展欧几里德与模逆元 扩展欧几里
算法笔记.rar
03-25
算法笔记:Visual Basic（简称VB）是Microsoft公司开发的一种通用的基于对象的程序设计语言，为结构化的、模块化的、面向对象的、包含协助开发环境的事件驱动为机制的可视化程序设计语言。是一种可用于微软自家产品开发的语言。
第四章源代码打包.rar
12-01
【标题】第四章源代码打包rar 在IT行业中，源代码打包是一个至关重要的步骤，它涉及到项目的可部署性和维护性。本章主要关注的是如何将一个基于Vue.js的前端项目与Koa服务器相结合，进行有效的打包和部署。在这个...
疯狂android讲义第四章源代码
07-01
《疯狂Android讲义》是Android开发领域的一本经典教材，其第四章的源代码涵盖了Android应用开发中的核心概念和技术。这一章可能涉及了Android应用程序的基本架构、UI设计、事件处理、数据存储、网络通信等多个方面。...
java面向对象程序设计第4章源代码
03-09
描述中的"第4章"可能涵盖了如何创建和实例化类，以及如何使用构造函数初始化对象。构造函数是一个特殊的方法，用于在创建对象时执行特定的初始化任务。 其次，对象是类的实例，是实际存在的数据结构。通过使用new...
Javaee第二章源代码
06-09
这个“JavaEE第二章源代码”很可能是某个教程或课程中关于JavaEE的基础部分，涵盖了Web应用的基本构建块。在这一章中，我们可以期待学习到以下几个关键知识点： 1. **Servlet**：Servlet是JavaEE的核心组件之一，...
算法笔记 书中的样例源码
weixin_46546622的博客
01-15 433
算法笔记 胡凡.书中的样例源码. 目前只有这些.上个学期课余时间抄录的.难免有一些纰漏.也希望大家帮我挑挑错. 2 2.2.6,常用math函数 #include<cstdio> #include<math.h> //变量取绝对值 int test1() { double db = -12.56; printf("%.2f\n", fabs(db)); return 0; } //向上取整,向下取整 int test2() { double db1 = -5.2, db
codeup《算法笔记》题目索引（题目+解析+代码）
热门推荐
漫浸天空的雨色的备忘录~
04-27 3万+
黑色的题目没有题解（题目本身错误，或者后端判题机有问题，或者博主本身能力不足做不出来= =），还请多担待~~ 如果想考PAT，不是很建议刷codeup里面的题目，如果有时间可以看一下我总结的经验，希望能帮助到你~~传送门——PAT考试经验总结（甲乙级均适用）~~想满分的请看这里！~~ 《算法笔记》2.1小节——C/C++快速入门->基本数据类型 《算法笔记》2.2小节——C/C++快速入...
《算法笔记》学习笔记 part1
Chris Lee
12-31 6801
一. 前言 我开始写这篇笔记时，2019年研究生考试已经过去一周了，虽然还不知道初试结果，但还是要开始准备复试了。复试中机试又占了很大的比例，故这里开始复习算法知识了，主要用书为《算法笔记》。 这份笔记将主要分两个部分。本篇笔记为part1。主要包括两个内容，一是我觉得有必要记录的知识点；另外就是一些专题，内容是一些归纳和自己的思考。 希望能顺利的通过复试（如果过了...
《算法笔记》和《算法笔记上机训练指南》学习笔记汇总
weixin_38120348的博客
02-18 1万+
为了准备3月份的PAT，最近在刷《算法笔记》和配套的《算法笔记上机训练指南》胡凡 著，这篇博客将记录下学习的历程。第二章 c/c++快速入门     这一章是c语言的基础语法知识讲解，在《算法笔记上机训练指南》没有配套的练习题。变量类型 （1.1 变量的定义 1.2 变量的类型 1.3 强制类型转换 1.4 符号常量和const常量 1.5 运算符）顺序结构  (2.1 赋值表达式 2.2 使用s...
算法笔记
github_38818603的博客
10-07 591
#双向链表的头在0的索引处， 这样的话，用双向链表实现栈的时候，就是从0处入栈，从0处出栈 实现队列的时候，就是从0处入队，从s.len-1处出队 #deque 是双端队列 offer---insert; poll---remove; peak---examine #面试常问问题：双向链表和单项链表的区别 区别主要在头结点，for遍历，有无前驱结点地址。  单向链表的头结点不是哑元（
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 585
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 655
后缀表示法。
[Leetcode 136][Easy]-只出现一次的数字
2201_75413354的博客
07-03 220
②后面研究，发现对于对于查找数组中唯一一个出现一次的元素，我们更适合使用线性扫描和位操作的方法。异或运算满足交换律，且一个数异或自己结果是0，一个数异或0结果是自己。因此把数组中所有元素进行异或运算，得到结果是唯一数。①首先看到数组中重复的数字，想到快慢指针，但是数组的元素是乱序的不好求。使用了STL库的sort函数，时间复杂度O(nlogn)不符合题目要求，空间复杂度O(1)。
行业景气上行，迈入发展快车道
03-13
"钨行业景气度上行，章源钨业业绩增长，钨产品广泛应用于航空航天、光伏、电子信息等领域，公司拥有丰富的矿山资源和扩产计划，预期未来业绩将持续增长，给予‘推荐’评级。" 这篇报告的核心是分析了钨行业的现状与...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值