个人算法重刷记录
Posted 流楚丶格念
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了个人算法重刷记录相关的知识，希望对你有一定的参考价值。
文章目录
- 对于一个字符串，请设计一个高效算法，找到第一次重复出现的字符保证字符串中有重复的字符，字符串的长度小于等于 500
- 实现拷贝数组函数
- 写一排序算法，输入 10 个数字，以逗号分开，可根据参数选择升序或者 降序排序，须注明是何种排序算法
- 判断字符串是否是这样的组成的，第一个字母，后面可以是字母、数字、下划线、总长度为 5-20
- 已排好序的数组 A，一般来说可用二分查找可以很快找到，现有一特殊数组 A，它是循环递增的，如 a[]=17, 19 ,20, 25, 1, 4, 7, 9，在这样的数组中找一元素，看看是否存在。请写出你的算法，必要时可写伪代码，并分析其空间，时间复杂度
- 请编写一个完整的程序，实现如下功能：从键盘输入数字 n，程序自动计算 n!并输出。（注 1：n！=1\\*2\\*3...\\*n, 注 2：请使用递归实现）
- 递归实现二分查询
- 编写一段 Java 程序，把一句英语中的每个单词中的字母次序倒转，单词次序保持不变，例入输入为“There is a dog.”,输出结果应该是“erehT si a god.”要求不使用 Java 的库函数，例如 String 类的 split，reverse 方法
- 手写 9x9 乘法表，冒泡排序
- 给定一个整数数组，找到是否该数组包含任何重复数字。你的函数应该返回 true 只要有任何数字 在该数组中重复出现，否则返回 false。
- 给定一个数组 nums， 写一个函数来移动所有 0 元素到数组末尾，同时维持数组中非 0 元素的相对顺序不变。要求不能申请额外的内存空间，并且最小化操作次数。
- 给定一颗二叉树，返回节点值得先序遍历，请使用迭代（非递归）方式实现。
- 验证一棵树是否为有效的二叉搜索树 BST
- 给定含有 n 个整数的数组 S，S 中是否存在三个元素 a,b,c 使得 a + b + c = 0? 找到所有这样的三元 组，并且结果集中不包含重复的三元组。
- 子集问题
- 编辑距离题目：给定两个单词 word1 和 word2，找到最小的操作步骤使得 word1 转换成 word2，每次操作算作一 步。你可以对单词进行以下三种操作：1）插入一个字符 2）删除一个字符 3）替换一个字符
- 买卖股票问题：题目： 你有一个数组，第 i 个元素表示第 i 天某个股票的价格，设计一个算法找到最大的利润，并且你只能最多完成两次交易。
- 任给 n 个整数和一个整数 x。请计算 n 个整数中有多少对整数之和等于 x。
- 请说明快速排序算法的设计思想和时间复杂度，并用高级语言写出对整数数组进行一趟快排的函数实现。
- 对于一段形如：1，-1~3,1~15×3 的输入
- 有两个字符串：目标串 S=“s1s2.......sn”，模式串 T="t1t2.......tm"。 若存在 T 的每个字符一次和 S 中的一个连续字符序列相等，则匹配成功，返 回 T 中第一个字符在 S 中的位置。否则匹配不成功，返回 0。写出你的算法， 要求线性时间复杂度
- 如何生成一个 0-100 的随机整数
- 请编写一段 Java 程序将两个有序数组合并成一个有序数组
- 统计一篇英文文章单词个数
- 输入年月日，计算该日期是这一年的第几天
- 回文素数：所谓回文数就是顺着读和倒着读一样的数(例如：11，121，1991…)，回文素数就是既是回文数又是素数(只能被 1 和自身整除的数)的数。编程找出 11～9999 之间的回文素数。
- 全排列：给出五个数字 12345 的所有排列。
- 对于一个有 N 个整数元素的一维数组，找出它的子数组（数组中下标连续的元素组成的数组）之和的最大值。
- 用递归实现字符串倒转
- 输入一个正整数，将其分解为素数的乘积
- 一个有 n 级的台阶，一次可以走 1 级、2 级或 3 级，问走完 n 级台阶有多少种走法。
- 写一个算法判断一个英文单词的所有字母是否全都不同（不区分大小写）
- 有一个已经排好序的整数数组，其中存在重复元素，请将重复元素删除掉，例如，A= [1, 1, 2, 2, 3]，处理之后的数组应当为 A= [1, 2, 3]。
- 给一个数组，其中有一个重复元素占半数以上，找出这个元素
- 编写一个方法求一个字符串的字节长度?
对于一个字符串，请设计一个高效算法，找到第一次重复出现的字符保证字符串中有重复的字符，字符串的长度小于等于 500
代码如下：
package com.yyl.algorithm.questions;
public class FirstRepeat
public static void main(String[] args)
System.out.println(findFirstRepeat("pmedmitjtckhxwhvpwemznh mhzhpueainchqrftkm" +
"bjlradhmjekcqzansyzkvqhwnrdgzdbzewdmxkzrscik daugbvygntrifnolehdtrqjlasofuvz" +
"eijbmzehkxknmjekcxswqldknysfsxr qaqzp", 152));
/**
* 查找第一个重复的字符
* @param A 字符串
* @param n 字符串长度
* @return 第一个重复的字符
*/
public static char findFirstRepeat(String A, int n)
char[] chars = A.toCharArray();
for (int i=0;i<n;i++)
// 重复字符的下标
int index =0;
// 当前字符的数量
int num=0;
// 对于每一个值，都需要从前开始遍历
while (index<i)
if (chars[i]==chars[index])
num++;
index++;
// 如果该值出现了两次，说明重复了
if (num>0)
return chars[i];
// 如果只能到末尾，说明没有重复的
return '×';
实现拷贝数组函数
代码如下：
package com.yyl.algorithm.questions;
import java.util.Arrays;
public class CopyArray
public static void main(String[] args)
int[] arr1 = 10, 20, 30, 40, 50;
int[] arr2 = CopyArrays(arr1);
System.out.println(Arrays.toString(arr2));
private static int[] CopyArrays(int[] arr)
int[] arr2 = new int[arr.length];
for (int i = 0; i < arr.length; i++)
arr2[i] = arr[i];
return arr2;
写一排序算法，输入 10 个数字，以逗号分开，可根据参数选择升序或者 降序排序，须注明是何种排序算法
代码如下：
package com.yyl.algorithm.questions;
import java.util.Scanner;
public class SortDemo
/**
* 将String类型的数组转换成int类型的数组
*
* @param s
* @return
*/
private static int[] getInt(String[] str)
int arr[] = new int[str.length];
for (int i = 0; i < str.length; i++)
arr[i] = Integer.parseInt(str[i]);
return arr;
/**
* 给定的字符串使用，号分隔
*
* @param str
* @return
*/
private static String[] split(String str)
String[] strSplit = str.split(",");
return strSplit;
/**
* 排序算法
*
* @param arr
*/
public static void sort(int[] arr)
// 很久没写冒泡了，先冒个泡
for (int i = 0; i < arr.length - 1; i++)
for (int j = 0; j < arr.length - 1 - i; j++)
if (arr[j] > arr[j + 1])
swap(arr, j, j + 1);
// 很久没写快排了，快个排
public static void quicksort(int[] arr, int left, int right)
// 递归终止条件
if (left > right)
return;
int i = left, j = right;
// 以左边为基准
while (i < j)
while (i < j && arr[j] >= arr[left])
j--;
while (i < j && arr[i] <= arr[left])
i++;
swap(arr, i, j);
// 交换i的位置与left基准
swap(arr, i, left);
// 再快排左右
quicksort(arr, left, i - 1);
quicksort(arr, i + 1, right);
/**
* 两数交换的方法
*
* @param arr 数组
* @param x 数组中元素的下标
* @param y 数组中元素的下标
*/
public static void swap(int[] arr, int x, int y)
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.println("请输入一个数字串，每个数字以逗号分隔 ");
String str = input.next();
//调用方法
String[] s = split(str);//使用逗号分隔
int[] arr = getInt(s);//调有获得整型数组的方法
// sort(arr);//调用排序的方法
quicksort(arr, 0, s.length-1);//调用排序的方法
for (int i : arr)
System.out.print(i + "\\t");
判断字符串是否是这样的组成的，第一个字母，后面可以是字母、数字、下划线、总长度为 5-20
代码如下：
package com.yyl.algorithm.questions;
import java.util.Scanner;
public class StringDemo
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.println("请输入一个字符串，第一个字符必须是字母：");
String str = input.next();
if (str.length() < 5 || str.length() > 20)
System.out.println("对不起，字符串的长度必须在5-20之 间!");
else
char[] ch = str.toCharArray();
//判断第一个字符是否是 字母
if (Character.isLetter(ch[0]))
for (int i = 1; i < ch.length; i++)
if (!Character.isLetterOrDigit(ch[i]) && ch[i] != '_')
System.out.println("字符串不符合要求");
break;
已排好序的数组 A，一般来说可用二分查找可以很快找到，现有一特殊数组 A，它是循环递增的，如 a[]=17, 19 ,20, 25, 1, 4, 7, 9，在这样的数组中找一元素，看看是否存在。请写出你的算法，必要时可写伪代码，并分析其空间，时间复杂度
**思路说明：**循环递增数组有这么一个性质：以数组中间元素将循环递增数组划分为两部 分，则一部分为一个严格递增数组，而另一部分为一个更小的循环递增数组。
当中间元素大于首元素时，前半部分为严格递增数组，后半部分为循环递增数组；
- 例如：【3 4 5 6 7 1 2】
当中间元素小于首元素时，前半部分为循环递增数组；后半部分为严格递增数组。
- 例如：【6 7 1 2 3 4 5】
记要检索的元素为 e，数组的首元素为 a[low]，中间元素为 a[mid]，末尾元素为 a[high]。
那么我们可以总结出：
-
当 e 等于 a[mid] 时，直接返回 mid 的值即可；
-
当 e 不等于 a[mid] 时:
- a[mid] > a[low]，即数组前半部分为严格递增数组，后半部分为循环递增数组时，若 key 小于 a[mid]并且不小于 a[low]时，则 key 落在数组前半部分；否则，key 落在数组后半部分。
- a[mid] < a[high]，即数组前半部分为循环递增数组，后半部分为严格递增数组时，若 key 大于 a[mid]并且不大于 a[high]时，则 key 落在数组后半部分；否则，key 落在数组前半部分。
这种方式的时间复杂度为：O(log(n))，空间复杂度为 O(1)。
代码如下：
package com.yyl.algorithm.questions;
public class BinarySearchDemo
public static void main(String[] args)
// 定义数组
int[] a = 17, 19, 20, 21, 25, 1, 4,33, 7;
// 调用改进后的二分查找法求索引
int pos = binarysearch(a, 7);
System.out.println("要查找的元素的索引为：" + pos);
/**
* 改进后的二分查找法
* @param a 查找的数组
* @param e 要查找的元素
* @return 下标
*/
private static int binarysearch(int[] a, int e)
int low = 0;
int high = a.length - 1;
int mid = 0;
// 数组下标 如果返回-1，表示查找失败
int pos = -1;
// 如果 low < high，说明循环查找结束，直接返回-1; 否则循环查找
while (low <= high)
// mid 为中间值索引
mid = (low + high) / 2;
// 如果中间值刚好是 e，则查找成功，终止查找，e 的索引为 mid
if (a[mid] == e)
pos = mid;
break;
// 如果 a[low] <= a[mid]，说明原数组的前半部分是严格递增的，后半部分是一个更小的循环递增数组
if (a[low] <= a[mid])
// 如果要查找的元素 e 小于 a[mid]并且不小于 a[low]时， 则说明 e 落在数组前半部分
if (a[low] <= e && e < a[mid])
high = mid - 1;
else
low = mid + 1;
else // 否则，后半部分是严格递增的，前半部分是一个更 小的循环递增数组
// 如果要查找的元素 e 大于 a[mid]并且不大于 a[high]时， 则说明 e 落在数组后半部分
if (a[mid] < e && e <= a[high])
low = mid + 1;
else // 否则的话，需要在数组的前半部分继续查找
high = mid - 1;
return pos;
请编写一个完整的程序，实现如下功能：从键盘输入数字 n，程序自动计算 n!并输出。（注 1：n！=1*2*3…*n, 注 2：请使用递归实现）
代码如下：
package com.yyl.algorithm.questions;
import java.util.Scanner;
public class FactorialDemo
public static void main(String[] args)
System.out.print("请输入一个整数：");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println(n + "的阶乘是：" + factorial(n));
private static int factorial(int n)
if(n==1)
return 1;
return factorial(n-1)*n;
递归实现二分查询
**思路说明：**假设在一个已经排好序的有序序列(N 个元素，升序排列)，首先让序列中的中间的元素与需要查找的关键字进行比较，如果相等，则查找成功，否则利用中间位置将序列分成两个子序列，如果待查找的关键字小于中间的元素，则在前一个子序列中同样的方法进一步查找，如果待查找的关键字大于中间的元素，则在后一个子序列中同样的方法进一步查找，重复以上过程一直到查找结束！
代码如下：
package com.yyl.algorithm.questions;
import java.util.Scanner;
public class BinarySearchRecursionDemo
public static void main(String[] args)
int[] a = 1, 3, 5, 7, 9, 11, 13;
System.out.print("请输入要查找的元素：");
int e = new Scanner(System.in).nextInt();
int index = binarySearch(a, 0, a.length - 1, e);
System.out.println(index != -1 ? "元素索引为" + index : " 没有该元素");
private static int binarySearch(int[] a, int low, int high, int e)
int mid = 0;
if (low <= high)
mid = (low + high) / 2;
if (a[mid] == e)
return mid;
else if (a[mid] > e)
return binarySearch(a, low, mid - 1, e);
else
return binarySearch(a, mid + 1, high, e);
// 如果大于就相当于判定递归的终止条件了
return 以上是关于个人算法重刷记录的主要内容，如果未能解决你的问题，请参考以下文章