算法初步

日期问题

闰年和平年的区别：闰年的2月29天，平年的2月28天

闰年分类

• 普通闰年：年份是4的倍数不是100的倍数
• 世纪闰年：年份为400的倍数

排序

两种排序方法

• 插入排序
• 选择排序

排序题

• c++ sort(首元素,最后一个排序元素的下一个位置,比较函数) 函数实现排序

  bool cmpc3(Student a,Student b) {
  if(a.score == b.score) {
      return a.id < b.id;
  } else {
      return a.score < b.score;
  }
  

  注意return中的大于小于(大于：从大到小，小于：从小到大排序)

void solve1927(){
    char strs[200];
    while(gets(strs)){
        sort(strs,strs + strlen(strs));
        cout << strs << endl;
    }
    
} 

字符串的整行读取： gets(strs)

排序： sort(strs,strs + strlen(strs))

进制转换

m进制转n进制的思路：m进制转换为10进制，10进制再转换为m进制

m进制转换10进制

sum = 0;
p = 1;
while(k!=0){
    sum += (k%10)*p;
    k /= 10;
    p = p *m;
}

10进制转换m进制

i = 0;
do{
    num[i++] = k%m;
    k = k/m;
    // 逆序输出即为结果
}while(k!=0);

辗转相除法的简单实现

哈希

散列

散列是一种以空间换事件的策略

将那个输入的数作为数组的下标对数的性质进行统计

• 注意输出是否与输入的顺序有关，如果有关，可能需要一个数组记录输入的数据

使用goto语句一次跳出多个循环：

# codeup6112
#include <iostream>
#include<stdio.h>

using namespace std;
void solve6112(){
	int n;
abc:while(~scanf("%d",&n)){
		int ans[10000] = {0};
		int pos[n];
		for(int i=0;i!=n;++i){
			cin >> pos[i];
			ans[pos[i]]++;
		}
		int count = 0;
		for(int i=0;i!=n;++i){
			if(ans[pos[i]] == 1){
				cout << pos[i] << endl;
				goto abc;
			}
		}
		cout << "None" << endl;
	}
}

int main(int argc, char *argv[]) {
	solve6112();
	return 0;
}

codeup 1968众数

题目描述

输入20个数，每个数都在1-10之间，求1-10中的众数（众数就是出现次数最多的数，如果存在一样多次数的众数，则输出权值较小的那一个）。

输入

测试数据有多组，每组输入20个1-10之间的数。

输出

对于每组输入,请输出1-10中的众数。

注意如果存在一样多次数的众数，则输出权值较小的那一个。

int main()
{

	int n;
	while(~scanf("%d",&n)){
		int hashTable[12] = {0};
		hashTable[n]++;
		for(int i=0;i!=19;++i){
			cin >> n;
			hashTable[n]++;
		}
		int max = 1;
		for(int i=2;i!=11;++i){
			if(hashTable[max] < hashTable[i]){
				max = i;
			}
		}
		cout << max << endl;
		
	}
	return 0;
}

字符串Hash初步

将字符串（字符数组）映射为一个整数，使这个整数能够唯一地代表字符串

以A-Z组成字符串为例，可以将A-Z映射到0-25，这样大写字母就对应到26进制中。

接下来只要将26进制转换为10进制即可，此时这个整数可以唯一地代表这个字符串

大写字母组成的字符串

int hashStr(char a[], int len) {
	int id = 0;
	for (int i = 0; i != len; ++i) {
		id += id * 26 + (a[i] - ‘A‘);
	}
	return id;
}

char b[] = {‘B‘, ‘C‘, ‘A‘};

cout << hashStr(b, 3) << endl; // 783

小写字母组成的字符串

将A-Z视为0-25，将a-z视为26-51，映射为52进制即可

int hashStr2(char a[], int len) {
	int id = 0;
	for (int i = 0; i != len; ++i) {
		if (a[i] >= ‘A‘ && a[i] <= ‘Z‘) {
			id = id * 52 + (a[i] - ‘A‘);
		} else if (a[i] >= ‘a‘ && a[i] <= ‘z‘) {
			id = id * 52 + (a[i] - ‘a‘) + 26;
		}
	}
	return id;
}

char b2[] = {‘B‘, ‘C‘, ‘a‘};
cout << hashStr2(b2, 3) << endl; // 2834

大小写字母和末尾为一位数字组成的字符串

前面hash得到的值加上最后一位数字即可

int hashStr3(char a[], int len) {
	int id = 0;
	for (int i = 0; i != len - 1; ++i) {
		if (a[i] >= ‘A‘ && a[i] <= ‘Z‘) {
			id = id * 52 + (a[i] - ‘A‘);
		} else if (a[i] >= ‘a‘ && a[i] <= ‘z‘) {
			id = id * 52 + (a[i] - ‘a‘) + 26;
		}
		id = id * 10 + (a[len - 1] - ‘0‘);
	}
	return id;
}	
char b3[] = {‘B‘, ‘c‘, ‘3‘};
cout << hashStr3(b3, 3) << endl; // 7043

由以上可知，当字符串（字符数组）的长度较大时，整数值也会变得很大

这种方法适用字符串长度较小的情况

递归

算法初步

原文：https://www.cnblogs.com/lanying13/p/14394146.html