编程算法题--持续更新

最新推荐文章于 2023-05-25 09:00:00 发布
最新推荐文章于 2023-05-25 09:00:00 发布
阅读量261 收藏
点赞数
分类专栏： 202005 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LeZhi_126/article/details/106159428
版权

题目描述

求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）

public class Solution {
    public int Sum_Solution(int n) {
        int sum = (int)Math.pow(n,2)+n;
        return sum>>1;
    }
 

题目描述

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

import java.util.ArrayList;
import java.util.*;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        
        ArrayList<String> result = new ArrayList<>();
        if(str.length()==0 ||str == null){
            return result;
        }
        PermutationHelper(str.toCharArray(),0,result);
        Collections.sort(result);
        return result;
    
    }
  private void PermutationHelper(char[] chars,int i,ArrayList<String> result){
        //已经递归到了字符串最后一位，判断集合中有没有这个字符串，没有则加入
        if(i== chars.length-1){
            if(!result.contains(new String(chars))){
                result.add(new String(chars));
                return;
            }
        }else{
            //首次传进来的i为0，代表首位字符
            //依次处理i与i后面的每个字符(索引j)交换
            for(int j=i; j<chars.length; j++){
                swap(chars,i,j);//交换
                PermutationHelper(chars,i+1,result);//继续递归交换后的子串
                swap(chars,i,j);//还原
            }
        }
    }
    private void swap(char[] chars,int i,int j){
        if(i != j){
            char temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
        }
    }

};
 

输入描述:

输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

题目描述

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<TreeNode> treelist = new ArrayList<TreeNode>();
        ArrayList<Integer> tlist = new ArrayList<Integer> ();
        if(root == null){
            return tlist;
        }
        if(root!= null){
            treelist.add(root);
            tlist.add(root.val);
        }
        for (int i = 0; i<treelist.size(); i++){
            TreeNode node = treelist.get(i);
            if(node.left != null){
                treelist.add(node.left);
                tlist.add(node.left.val);
            }
            if(node.right != null){
                treelist.add(node.right);
                tlist.add(node.right.val);
            }
        }
        return tlist;
        
    }
}

题目描述

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

public class Solution {
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        if (root1 ==null)
            return false;
        if(root2 ==null) 
            return false;
        return isSubtree(root1, root2)||HasSubtree(root1.left, root2)||HasSubtree(root1.right, root2);
    }
    public static boolean isSubtree(TreeNode root1,TreeNode root2){
        if (root2 == null)
            return true;
        if(root1 ==null){
            return false;
        }
        if(root1.val == root2.val){
            return isSubtree(root1.left, root2.left)&&isSubtree(root1.right, root2.right);
        }
        return false;
    }
}

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则

public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        ListNode list = null;
        if(list1 ==null&&list2 == null)
            return null;
        if(list1 == null)
            return list2;
        if(list2 == null)
            return list1;
        if(list1.val <=list2.val){
            list = list1;
            list.next = Merge(list1.next, list2);
        }else
        {
            list = list2;
            list.next = Merge(list1, list2.next);
        }
        return list;
    }
}

题目描述

输入一个链表，反转链表后，输出新链表的表头。

public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head == null)
            return null;
        ListNode pre = null;
        ListNode next = null;
        while(head!= null){
            //先用next保存下一节点的信息
            next = head.next;
            //保存完next，就可以让head从指向next变成指向pre了
            head.next = pre;
            //head指向pre后，就继续依次反转下一个节点
            //让pre，head，next依次向后移动一个节点，继续下一次的指针反转
            pre = head;
            head = next;
            
        }
        //如果head为null的时候，pre就为最后一个节点了，但是链表已经反转完毕，pre就是反转后链表的第一个节点
        return pre;

    }
}

题目描述

输入一个链表，输出该链表中倒数第k个结点。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if (head == null)
            return null;
        ListNode p1 = head;
        ListNode p2 = head;
        while(k>0&&p2!=null){
            p2 = p2.next;
            k--;
        }
        if(p2==head || (p2==null&&k>0))
            return null;
        while(p2!= null){
            p1 = p1.next;
            p2 = p2.next;
            
        }
        return p1;

    }
}

题目描述

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

//冒泡排序法

public class Solution {
    public void reOrderArray(int [] array) {
        int len = array.length;
        for (int i =0; i<len; i++){
            for(int j=0;j<len-1; j++){
                if(array[j]%2==0&&array[j+1]%2!=0){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1]=temp;
                }
            }
        }
     
    }
}

 

题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。

(n<=39)

class Solution {
public:
    int Fibonacci(int n) {
        if(n<=1)
            return n;
        int res = 0;
        int n1 =0; 
        int n2 =1;
        for (int i =2; i<=n; i++){
            res = n1+n2;
            n1=n2;
            n2= res;
        }
        return res;

    }
};

题目描述

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array == null||array.length ==0)
            return 0;
        if(array.length ==1)
            return array[0];
        
        for(int i = 0; i<array.length;i++){
            if(array[i]>array[i+1])
                return array[i+1];
        }
        return 0;
    }
}

 

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

public class Solution {
    public int JumpFloor(int target) {
        if(target ==1)
            return 1;
        if(target ==2)
            return 2;
        return JumpFloor(target-1)+JumpFloor(target-2);

    }
}

题目描述

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int row = (int)array.size();
        int col = (int)array[0].size();
        int i=0;
        int j=col-1;
        //0row and 0col
        if(row==0||col==0){
            return false;
        }
        if(target>array[row-1][col-1]||target<array[0][0])
        {
            return false;
        }
        while(i<row&&j>=0){
            if(target>array[i][j]){
                i++;
            }
            else if(target<array[i][j]){
                j--;     
            }
            else{
                return 1;
            }
           
        }
         return 0;
            
        }
    };

题目描述

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。​​​​​​

/*
分析
将长度为1的空格替换为长度为3的“%20”，字符串的长度变长。
如果允许我们开辟一个新的数组来存放替换空格后的字符串，
那么这道题目就非常简单。设置两个指针分别指向新旧字符串首元素，
遍历原字符串，如果碰到空格就在新字符串上填入“%20”，
否则就复制元字符串上的内容。但是如果面试官要求
在原先的字符串上操作，并且保证原字符串有足够长的空间来存放替换后的字符串，
那么我们就得另想方法。
如果从前往后替换字符串，那么保存在空格后面的字符串肯定会被覆盖，
那么我们就考虑从后往前进行替换。
首先遍历原字符串，找出字符串的长度以及其中的空格数量，
根据原字符串的长度和空格的数量我们可以求出最后新字符串的长度。
设置两个指针point1和point2分别指向原字符串和新字符串的末尾位置。
如果point1指向内容不为空格，那么将内容赋值给point2指向的位置，
如果point1指向为空格，那么从point2开始赋值“02%”
直到point1==point2时表明字符串中的所有空格都已经替换完毕。
*/

class Solution {
public:
    void replaceSpace(char *str,int length) {
        //遍历出原字符串长度和空格个数
        int oldstringlen;
        int blankNum = 0;
        for(oldstringlen = 0; str[oldstringlen]!='\0'; oldstringlen++){
            if(str[oldstringlen] == ' '){
                blankNum++;
            }
        }
        
        //计算出新字符串的长度
        int newstringLen = oldstringlen + blankNum * 2 ;
        //int newstringLen = oldstringLen + blankNumber * 2;
            if(newstringLen > length){
                return;
            }
        str[newstringLen] = '\0'; //字符串最后一位置为\0
        int point1 = oldstringlen -1;
        int point2 = newstringLen -1;
        while(point1 >=0 && point2>point1){
            if(str[point1] == ' '){
                str[point2--] = '0';
                str[point2--] = '2';
                str[point2--] = '%';
            }
            else{
                str[point2--] = str[point1];
            }
            point1--;
        }

    }
};

题目描述

求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

利用递归以及&&的短路原理：

前面的限制条件，表明最好的方法是用递归的方法，但是需要做一个判断，从n到1，当小于1的时候，自动结束

class Solution {
public:
    int Sum_Solution(int n) {
        int sum = n;
        sum&&(sum+=Sum_Solution(n-1));
        return sum;
    }
};

 

 

LeZhi_126
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
经典的10个常见的算法问题及(java、python)代码示例，你知多少，卷起来吧
qq_28245087的博客
06-23 3100
以下是10道算法题，包括斐波那契数列、回文字符串、冒泡排序、找到数组中的最大值和最小值、二叉树的深度、字符串中出现次数最多的字符、快速排序、找到数组中两个数的和等于目标值、堆排序以及二叉树的前序遍历、中序遍历和后序遍历。在Python中，使用递归的方式实现三种遍历，分别将遍历的结果存储在。这两个函数都接受一个整数数组和一个目标值参数，并返回数组中两个数的索引，使得这两个数的和等于目标值。，使用字典（dictionary）记录已经遍历过的数和它们的索引，以便在后面的遍历中查找目标数的补数。
一些算法编程题整理
xiedelong的博客
05-08 5552
1.在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 思路： 矩阵是有序的，从左下角来看，向上数字递减，向右数字递增， 因此从左下角开始查找，当要查找数字比左下角数字大时。右移 要查找数字比左下角数字小时，上移 public class Solution { publi...
一文搞定剑指Offer刷题(Python&&C++)【已完结】
小陈说CV的博客
07-30 506
03 数组中重复的数字 04 二维数组中的查找 05 替换空格 06 从尾到头打印链表 07 重建二叉树 09 用两个栈实现队列 10-1 斐波那契数列 10-2 青蛙跳台阶问题 11 旋转数组的最小数字 12 矩阵中的路径 13 机器人的运动范围 14-1 剪绳子 14-2 剪绳子2 15 二进制中1的个数 16 数值的整数次方 17 打印从1到最大的n位数 18 删除链表的节点 19 正则表达式匹配 20 表示数值的字符串 21 调整数组顺序使奇数位于偶数前面 22 链表中倒数第k个节点 24 反转链表
C_C++编程题：20道算法题
1226
08-30 6827
1、在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> int FindNumber(int arr[4][4], int k) { int i = 0; for (i = 0; i < 4; i++) { int j = 0;
Java基础算法题
Lirene_的博客
03-17 3715
Java基础算法题 前言1、打印1000-2000年的闰年2、判断是否为素数3、打印1-100之间的素数4、水仙花数5、最大公约数6、最小公倍数7、年龄打印8、模拟密码登录总结 前言 本文章主要是一些初学者编程算法题，由Java进行编译。 1、打印1000-2000年的闰年 普通闰年：公历年份是4的倍数且不是100的倍数为普通闰年（如2004、2020年就是闰年）。 世纪闰年：公历年份是整百数的，必须是400的倍数才是世界闰年（如2000.
cs-notes:持续更新算法题
03-14
"cs-notes:持续更新算法题" 这个标题暗示了这是一个关于计算机科学，特别是算法的资源集合，且内容会不断更新。它可能是由某位开发者或者教育者创建，用来记录和分享算法解决方案，可能涵盖数据结构、排序、搜索、...
leetcode题库-leetcode:算法代码-JavaScript
06-29
通过LeetCode的持续练习，你不仅可以巩固JavaScript的基础知识，还能提升对算法的理解和应用能力，这对于参加技术面试、解决实际工作中的复杂问题都将大有裨益。记得，实践是检验真理的唯一标准，只有不断尝试和改进...
Python-100daysofalgorithms算法100天的练习题
08-10
《Python-100daysofalgorithms算法100天的练习题》是针对Python编程者设计的一个进阶学习项目，旨在通过100天的持续训练，提升开发者在算法和设计模式方面的技能。这个练习计划涵盖了从基础到高级的各种算法，旨在...
leetcode题库-LeetCode:算法
06-29
LeetCode是一个全球知名的在线编程挑战平台，它专注于提升程序员的算法能力和解决实际问题的技巧。在这个题库中，你可以找到各种难度级别的编程题目，涵盖多种编程语言，如Java、Python、C++等。本篇文章将深入探讨...
JAVA基础编程练习题50题及经典算法90题【含源码及答案】
07-19
JAVA基础编程练习题50题及经典算法90题【含源码及答案】
JAVA算法编程题全集(50题及答案)
01-18
Java算法编程题，一共50道，答案完整，可以检测Java的掌握情况
编程算法题（适合初学人看看）
08-18
本人自己无聊时写的一些编程算法 适和给初级想学编程的人看看互相学习学习
100个经典的C算法，经典编程题
04-01
100个经典的C算法.经典程序，C语言编程题_经典40题(附解答)
leetcode题库-Algorithm:算法实践
06-29
通过系统地刷题、交流和实践，开发者可以逐步建立自己的算法思维，提高编程效率，为职业生涯铺平道路。而"Algorithm-master"这样的资源，则是实现这一目标的重要工具。在这个过程中，不断挑战自我，持续学习，将是每...
C语言基础经典算法题（1—10）
weixin_44775694的博客
03-19 6491
C语言经典算法100题
29道面试基础算法题，试试看会不会
最新发布
Android茶话会
05-25 7383
本文主要整理了一些面试常见的算法题，涵盖 数组、字符串、哈希表、链表、二叉树。
150道基础算法分类总结（2022）
小朱小朱绝不认输的博客
03-02 3013
在刷了一部分leetcode算法题之后，想要回头系统复习一下，发现刷的比较乱，特此整理一下，方便后续二刷，主要是对各种类型算法的一个分类，以及比较典型的题目的整理。 学习说明 题目来源lettcode 参考代码是用Java写的 供自己方便学习 算法分类 1. 二叉树 树也是一种非常重要的数据结构，因为很多容器的底层都设计到树，所以树也成了面试常问的重点了。特别是二叉树及二叉搜索树的算法。 二叉树的考点 题目来源 扩展 题解参考 二叉树的遍历（递归和迭代实现） 102. 二叉树的层序遍历
矩阵转圈打印算法解析 - 程序员面试必备
在编程面试中，数组和矩阵是常见的数据结构，它们经常作为基础问题出现，涉及算法设计和优化。本章主要讨论如何处理数组和矩阵相关的编程问题，特别是关于转圈打印矩阵的技巧。 转圈打印矩阵是一种常见的矩阵操作，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值