算法题笔记第二周加油

已于 2023-08-11 08:57:28 修改
阅读量1.8k 收藏
点赞数
文章标签： 算法 排序算法 c++
于 2022-01-11 00:20:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yxps165231/article/details/122418285
版权

算法题笔记第二周

课程目录

1、递归基础知识

//le-509
class Solution {
public:
    int fib(int n) {
        if(n==0) return 0;
        if(n==1) return 1;
        else
            return fib(n-1) + fib(n-2) ;
    }
};

2、冒泡排序基础知识

O(n2)

#include<iostream>
using namespace std;

void f(int a[], int n){
    for(int i=0; i<n-1; i++){
        for(int j=0; j<n-i-1; j++){
            if(a[j] > a[j+1]){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp; j+1, 不是j+i，莫写错了
            }
        }
    }
}
void print(int a[], int n){
    for(int i=0; i<n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

int main()
{
    int length;
    cin >> length;
    int i=0;
    int a[1000]={0};
    while(i < length){
        cin >> a[i++];
    }
    cout << "原数组："<<endl;
    print(a,length);
    f(a, length);
    cout << "冒泡后："<<endl;
    print(a,length);
    
    return 0;
}

3、选择排序基础知识

O(n2)

#include<iostream>
using namespace std;

void f(int a[], int n){
    for(int i=0; i<n-1; i++){
        int index = i;
        for(int j=i+1; j < n; j++){
            if(a[j] < a[index]){
                index = j; //index是最小元素的下标
            }
        }
        int temp = a[i]; 
        a[i] = a[index];
        a[index] = temp; //每次循环都是把最小元素调到最前面
    }
}
void print(int a[], int n){
    for(int i=0; i<n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

int main()
{
    int length;
    cin >> length;
    int i=0;
    int a[1000]={0};
    while(i < length){
        cin >> a[i++];
    }
    cout << "原数组："<<endl;
    print(a,length);
    f(a, length);
    cout << "选择排序后："<<endl;
    print(a,length);
    
    return 0;
}

4、插入排序基础知识

O(n2)


5 1 3 4 2 
#include<iostream>
using namespace std;

void f(int a[], int n){
    for(int i=1; i<n ;i++){
        int key = a[i];
        int j = i-1;
        while(j >= 0 && a[j]>key){
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = key;
    }
    
}
void print(int a[], int n){
    for(int i=0; i<n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

int main()
{
    int length;
    cin >> length;
    int i=0;
    int a[1000]={0};
    while(i < length){
        cin >> a[i++];
    }
    cout << "原数组："<<endl;
    print(a,length);
    f(a, length);
    cout << "插入排序后："<<endl;
    print(a,length);
    
    return 0;
}

5、快速排序基础知识

#include<iostream>
using namespace std;

int part(int nums[], int left, int right){
    int pivot = nums[left];
    while(left < right){
        while(left<right && nums[right]>pivot){
            right--;
        }
        nums[left] = nums[right];
        while(left < right && nums[left] <= pivot){
            left++;
        }
        nums[right] = nums[left];
    }
    nums[left] = pivot;
    return left;
}

void quickSort(int a[], int left, int right){
    if(left >= right){
        return;
    }
    int mid = part(a,left,right);
    quickSort(a,left,mid-1);
    quickSort(a, mid+1, right);
}

void f(int a[], int n){
    quickSort(a, 0, n-1);
}
void print(int a[], int n){
    for(int i=0; i<n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

int main()
{
    int length;
    cin >> length;
    int i=0;
    int a[1000]={0};
    while(i < length){
        cin >> a[i++];
    }
    cout << "原数组："<<endl;
    print(a,length);
    f(a, length);
    cout << "快速排序后："<<endl;
    print(a,length);
    
    return 0;
}

7、归并排序

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
void print_arr(int arr[], int n){
    for(int i=0;i<n;i++){
        printf("%d ", arr[i]);
    }
    putchar('\n');
}
//合并
void merge(int arr[], int tempArr[],int left,int mid,int right){
    //标记左半区第一个未排序的元素
    int l_pos = left;
    //标记右半区第一个未排序的元素
    int r_pos = mid+1;
    //临时数组元素的下标
    int pos = left;
    //合并
    while(l_pos <= mid && r_pos <= right){
        if(arr[l_pos] < arr[r_pos])
            tempArr[pos++] = arr[l_pos++];
        else
            tempArr[pos++] = arr[r_pos++];
    }
    //合并左半区剩余元素
    while(l_pos <= mid)
        tempArr[pos++] = arr[l_pos++];
    //合并右半区剩余元素
    while(r_pos <= right)
        tempArr[pos++] = arr[r_pos++];
    //把临时组数中合并后的元素复制回原来的数组
    while(left <= right){
        arr[left] = tempArr[left];
        left++;
    }
}
void msort(int arr[],int tempArr[],int left, int right){
    //如果只有一个元素，就不需要划分
    //只有一个元素的区域，本身就是无序的，只需要被归并
    if(left < right){
        int mid = (left+right)/2;
        //递归划分左半区域
        msort(arr,tempArr,left,mid);
        //递归划分右半区域
        msort(arr,tempArr,mid+1,right);
        merge(arr, tempArr, left,mid,right);
    }
}
void merge_sort(int arr[], int n){
    //分配一个辅助数组
    int *tempArr = (int *)malloc(n * sizeof(int));
    if(tempArr){//辅助数组分配成功
        msort(arr,tempArr,0,n-1);
        free(tempArr);
    }
    else{
        printf("error: failed to allocate memory");
    }
} 


int main()
{
    int arr[] = {9,5,2,7,12,4,3,1,11};
    int n=9;
    print_arr(arr,n);
    merge_sort(arr, n);
    print_arr(arr,n);
    return 0;
}

归并排序的课堂版
#include<iostream>
using namespace std;
#include "dayin.hpp"
void merge(int arr[], int reg[], int start,int end)
{
    if(start >= end){
        return ;
    }
    int len =end-start, mid = (len>>1) + start;
    int start1=start, end1=mid;
    int start2 =mid+1, end2 = end;
    merge(arr,reg,start1, end1);
    merge(arr, reg, start2,end2);
    int k = start;

    while(start1<=end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++]:arr[start2++];
    while(start1 <= end1){
        reg[k++] = arr[start1++];
    }
    while(start2 <= end2){
        reg[k++] = arr[start2++];
    }
    for(k=start; k <= end;k++){
        arr[k] = reg[k];
        cout << " arr[k]"<< arr[k] << " ";
    }
    cout << endl;
    

}



int main()
{
    int length;
    cin >> length;
    int i=0;
    int a[1000]={0};
    while(i < length){
        cin >> a[i++];
    }
    cout << "原数组："<<endl;
    print(a,length);
    int reg[10]={0};

    merge(a, reg, 0,length-1);

    cout << "归并排序后："<<endl;
    print(a,length);
    
    return 0;
}

8、剑指offer 40. 最小k个树

9、剑指offer 41.数据流中的中位数

10、剑指offer 51.数组中的逆序对

11、合并k个升序链表

12、合并两个有序数组

13、颜色分类

14、部分排序

15、计算右侧小于当前元素个数

16、有序数组的平方

17、盛最多水的容器

//le-11
class Solution {
public:
    int maxArea(vector<int>& height) {
        int res = 0,s;
        int left = 0, right = height.size()-1;
        while(left < right){
            if(height[left] <= height[right]){
                s = height[left] * (right-left);
                if(s > res) res = s;
                left++;
            }
            else{
                s = height[right] * (right-left);
                if(s>res) res = s;
                right--;
            }
        }
        return res;
    }
};

18、两数之和

//le-1
class Solution{
public:
    vector<int> twoSum(vector<int> &nums,int  target){
        unordered_map<int,int> m;
        for(int i=0; i < nums.size(); i++){
            int t = target - nums[i];
            if(m.count(t) == 1){
                return vector<int>{m[t],i};
            }
            m[nums[i]] = i;
        }
        return vector<int>();
    }
};

19、分发饼干

20、柠檬水找零

21、用最少数量的箭引爆气球

22、移掉k位数字

23、跳跃游戏

24、摆动序列

25、三数之和

26、最接近三树之和

27、加油站

28、合并区间

li1倒着输出

输入这种“I love China!”，然后你输出"China! love I",哈哈哈，双相奔赴

#include <cstdio>
#include <cstring>

int main()
{
	char a[100] = { "I love China!" };
	//char a[100] = { "the"};
	int len = strlen(a);
	char b[100] = { 0 };
	for (int i = len; i >= 0; i--)
	{
		int j = 0;
		while (a[i] != ' '&&i>=0)
		{
			b[j++] = a[i];
			i--;
		}
		//printf("%s ", b);
		for (int k = j; k >= 0; k--)
		{
			printf("%c", b[k]);
		}
		printf(" ");
		memset(b, 0, sizeof(b));
	}

	return 0;
}

li2输出最小公倍数

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>

int gcd(int a, int b)
{
	if (b == 0)
	{
		return a;
	}
	return gcd(b, a % b);
}

int main()
{
	int a, b;
	char c;
	while (1)
	{
		printf("continue or quit: ");
		scanf("%c", &c);
		if (c == 'Y' || c == 'y')
		{
			printf("please input two numbers: ");
			scanf("%d %d", &a, &b);
			printf("%d 和 %d 的最小公倍数是: %d\n", a, b, (a * b) / gcd(a, b));
			getchar();
		}
		else
		{
			break;
		}
	}
	return 0;
}

在这里插入图片描述

li3求字符串的回文子串个数

一开始有点头大，不知道怎么分析，看了网上的例题过后有点思路了，总体就是回文字串长度入手，要么这个回文子串长度是奇数，要么是偶数，奇偶分开，就不会有考虑到判断重复的字符串了。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdio>
#include <cstring>

int cnt;

void func(int i, int j, int len, char a[])
{
	while(i >= 0 && j < len && a[i] == a[j] )
	{
		cnt++;
		i--;
		j++;
	}
}


int main()
{

	char a[100] = { 0 };
	scanf("%s", a);
	int len = strlen(a);
	for (int i = 0; i < len; i++)//从每一个元素开始找，从这个元素为中心，找奇数个子串回文数个数，和偶数个的子串回文数个数
	{
		func(i,i,len,a);
		func(i,i+1,len,a);
	}
	printf("cnt = %d\n", cnt);
	return 0;
}
谭哈哈thh
关注
最新算法面试题汇总_面试算法题
2401_84302816的博客
05-02 1263
给你一个字符串s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。单词是指仅由字母组成、不包含任何空格字符的最大子字符串。
【力扣刷题笔记第三期】Python 数据结构与算法
许虹蕾的博客
05-21 1255
简单题汇总
算法题笔记第一周加油
yxps165231的博客
01-03 675
算法题笔记第一周课程目录0、时间复杂度与空间复杂度1、链表基础知识（单链表）2、反转链表3、相交链表4、合并两个有序链表5、分割链表新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 课程目录 0、时间复杂度与空间复杂度 时间
算法题笔记第4周加油
yxps165231的博客
01-26 292
算法题笔记第四周课程目录1、二叉树基础知识2、二叉树前序遍历3、二叉树中序遍历4、二叉树后序遍历5、二叉树层序遍历6、二叉树锯齿形层序遍历7、从前序与中序遍历序列构造而叉树8、路径总和9、二叉树的最近公共祖先10、 二叉树的右视图11、二叉树展开链表 课程目录 1、二叉树基础知识 1、有且仅有一个节点 2、每个节点最多有两个孩子，并且有左右之分 3、除了跟节点外，其余节点只有一个父节点 4、每个节点都构成以它为根的树。 2、二叉树前序遍历 3、二叉树中序遍历 4、二叉树后序遍历 5、二叉树层序遍历 6、二叉
算法学习笔记
yjh_________的博客
07-20 501
此式是分治法的时间复杂性所满足的递归关系，即一个规模为n的问题被分为规模均为n/b的a个子问题，递归求解这a个子问题，然后通过对这a个子问题的解综合，得到原问题的解。分治法的基本思想是将一个规模为n的问题分解为k个规模较小的子问题，这些子问题互相独立且与原问题相同。求该序列的子段和的最大值。一个算法的复杂性的高低体现在运行该算法所需的计算机资源（主要是指时间和空间资源）的多少上。（4）有限性：算法中每条指令执行次数是有限的，执行每条指令的时间是有限的。（3）确定性：组成算法的每条指令是清晰的，无歧义的。
力扣题库刷题笔记134-加油站
m0_60032667的博客
04-19 239
个人的代码逻辑其实没有问题，主要是数据量过大会超时。相较于题解的思路，差异其实在对于数组排序的地方。我的思路是循环找到起始加油站下标，然后将gas和cost重新排序；而题解的思路相同的地方在于找到下标，差异在于他没有进行数组重新排序，直接只从下标往后看，不管下标前的数据。b、如果第0个加油站的油小于到第一个加油站的油，那么从第1个加油站作为起始点。这里由于一定有解，所以只需要判断第一个加油站开始，到最后一个加油站油够用就行了，不需要再关心第0个加油站，以此类推。3、基于题解思路的个人Python代码实现。
代码随想录阅读笔记-贪心算法【加油站】
weixin_46184703的博客
04-24 575
在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。示例 2: 输入:输出: -1解释: 你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。我们从 2 号加油站出发，可以获得 4 升汽油。
左程云老师算法课笔记（一）
njh1147394013的博客
09-20 1822
左程云老师算法课笔记（一）
数据结构与算法学习笔记（第二章）
木原
04-16 316
算法 上章学习了数据结构，了解了一些相关概念以及数据结构的定义，我们了解到数据结构通常与算法是分不开的，没有算法的数据结构犹如演双簧少了一个人，失去了他的乐趣，本章开始学习算法。（没错，要有难度了，做好准备！） 首先来看算法的定义： 算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。 我们为什么学习算法呢？假设我们让计算机计算1+2+3+4+…+...
分享刷LeetCode算法题pdf笔记，看完你就是面试官
12-31 1184
废话不多说，直接上算法刷题笔记 百度网盘地址链接：https://pan.baidu.com/s/1Z0j_F4KSJE8q9j5Rs8p6Lg 提取码：you1 关于算法刷题的困惑和疑问也经常听朋友们提及。这份笔记里面共包含作者刷LeetCode算法题后整理的数百道题，每道题均附有详细题解过程。很多人表示刷数据结构和算法题效率不高，甚是痛苦。有了这个笔记的总结，对校招和社招的算法刷题帮助之大不言而喻，果断推荐给大家。 第二章算法专题 Array Backtracking Bina...
算法题刷题笔记
using namespace 数学工具构造器;
10-16 1086
双指针 977. 有序数组的平方 baseline class Solution: def sortedSquares(self, A: List[int]) -> List[int]: return sorted([x**2 for x in A]) 双指针 class Solution: def sortedSquares(self, A: List[int]) -> List[int]: N = len(A) start =
Javascript算法——双指针法移除元素、数组去重、比较含退格字符、有序数组平方
警警的博客
10-17 287
暴力求解法（两层for循环）,length单词拼写错误❌二次嵌套for的length设置。return位置❌ ,核心基础。双指针法（一层for循环）
二叉树系列 10/11
2301_78191305的博客
10-11 429
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
【算法】深入了解 CRC 校验码的计算过程
qq_20623849的博客
10-16 436
CRC（循环冗余校验，Cyclic Redundancy Check）是一种常见的错误检测方法，它通过生成冗余码来确保数据传输的可靠性。在这篇文章中，我们将探讨 CRC 码的基本原理，并详细介绍其计算过程。通过对数据进行 CRC 校验，我们可以在传输过程中检测到潜在的错误并采取适当的纠正措施。这个新的数据包在传输时，如果接收方再次计算 CRC 校验码并与附带的校验码进行比较，可以确定数据是否在传输过程中出现了错误。：将附加了零位的数据通过生成多项式进行二进制除法运算，得出的余数就是 CRC 校验码。
【LeetCode每日一题】——523.连续的子数组和
IronmanJay的博客
10-17 438
给你一个整数数组 nums 和一个整数 k ，如果 nums 有一个 好的子数组 返回 true ，否则返回 false： 一个 好的子数组 是： 长度 至少为 2 ，且 子数组元素总和为 k 的倍数。 注意： 子数组 是数组中 连续 的部分。 如果存在一个整数 n ，令整数 x 符合 x = n * k ，则称 x 是 k 的一个倍数。0 始终 视为 k 的一个倍数。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 249
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
前缀和算法专题（2）
最新发布
我要学编程的博客
10-17 588
LeetCode相关刷题
【C++刷题】力扣-#163-缺失的区间
会写代码的饭桶
10-17 159
给定一个整数数组 nums 和两个整数 lower 和 upper，找出数组中在范围 [lower, upper] 内缺失的所有整数，包括边界。
力扣10.13
qq_40052678的博客
10-13 387
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值