算法分析（含答案）笔试题

linanana
  1. 判断身份证：要么是 15 位，要么是 18 位，最后一位可以为字母，并写
    出程序提出其中年月日。要求：
    写出合格的身份证的正则表达式，
    ^(\d{15}|\d{17}[\dx])$
    写程序提取身份证中的年月日
    public class IdCard
    {
    private String idCard;//私有变量
    public IdCard(){}//构造方法
    //构造方法
    public IdCard(String idCard){
    this.idCard=idCard;
    }

public void setIdCard(String idCard)
{
this.idCard=idCard;
}

public String getIdCard()
{
return idCard;
}

//从身份证号码中截取生日
public String getBirthday()
{
return this.getIdCard().substring(6, 14);
}

public static void main(String args[])
{
ShenFenZheng sfz = new
ShenFenZheng("420154199908157841");
//调用 getBirthday()方法获取生日
System.out.println("生日：" + sfz.getBirthday());
} }
627. 对于一个字符串，请设计一个高效算法，找到第一次重复出现的字符保
证字符串中有重复的字符，字符串的长度小于等于 500.
package com.bjsxt;
import java.util.ArrayList;
import java.util.List;
public class FirstRepeat {
public static void main(String[] args) {
System.out.println(findFirstRepeat("pmedmitjtckhxwhvpwemznh
mhzhpueainchqrftkmbjlradhmjekcqzansyzkvqhwnrdgzdbzewdmxkzrscik
daugbvygntrifnolehdtrqjlasofuvzeijbmzehkxknmjekcxswqldknysfsxr
qaqzp",152));
}
//返回:y
public static char findFirstRepeat(String A, int n) {
String[] str=A.split("");
for(int x=0;x<n;x++){
int index=0;
int num=0;
//对于每一个值，都需要从前开始遍历
while(index<=x){
if(str[index].equals(str[x])){
num++;
}
index++;
}
//该值出现了两次，说明重复了
if(num>1){
char flag=\'x\';
flag=str[x].toCharArray()[0];
return flag;
}
}
//返回该值说明已经没有重复的
return \'p\';
}
}
628. 写一个完整函数，实现拷贝数组
public class test {
public static void main(String[] args) {
int [] arr1 = {10,20,30,40,50};
int [] arr2 = CopyArray(arr1);
System.out.println(Arrays.toString(arr2));
}
private static int[] CopyArray(int[] arr) {
int [] arr2 = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
arr2[i] = arr[i];
}
return null; } }
629. 写一排序算法，输入 10 个数字，以逗号分开，可根据参数选择升序或者
降序排序，须注明是何种排序算法。
package cn.bjsxt.demo;
import java.util.Scanner;
public class SortDemo {
/**

  • 给定的字符串使用，号分隔
  • @param strNumber
  • @return
    /
    public static String [] split(String strNumber){
    String [] strSplit=strNumber.split(",");
    return strSplit;
    }
    /    *
  • 将String类型的数组转换成int类型的数组
  • @param strSplit
  • @return
    /
    public static int [] getInt(String [] strSplit){
    int arr[]=new int[strSplit.length];
    for (int i = 0; i < strSplit.length; i++) {
    arr[i]=Integer.parseInt(strSplit[i]);
    }
    return arr;
    }
    /    *
  • 冒泡排序
  • @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]) {
    change(arr,j,j+1);
    } } } }
    /    *
  • 两数交换的方法
  • @param arr 数组
  • @param x 数组中元素的下标
  • @param y 数组中元素的下标
    /
    public static void change(int [] arr,int x,int y){
    int temp=arr[x];
    arr[x]=arr[y];
    arr[y]=temp;
    }
    /    *
  • 测试类
  • @param args
    */
    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);//调用排序的方法
    for (int i : arr) {
    System.out.print(i+"\t");
    } } }
  1. 判断字符串是否是这样的组成的，第一个字母，后面可以是字母、数字、
    下划线、总长度为 5-20。
    package cn.bjsxt.demo;
    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; } } } } } }
  2. 已排好序的数组 A，一般来说可用二分查找可以很快找到，现有一特殊
    数组 A，它是循环递增的，如 a[]={17, 19 ,20, 25, 1, 4, 7, 9}，在这样的
    数组中找一元素，看看是否存在。请写出你的算法，必要时可写伪代码，并
    分析其空间，时间复杂度。
    思路说明：循环递增数组有这么一个性质：以数组中间元素将循环递增数组划分为两部
    分，则一部分为一个严格递增数组，而另一部分为一个更小的循环递增数组。当中间元
    素大于首元素时，前半部分为严格递增数组，后半部分为循环递增数组；当中间元素小
    于首元素时，前半部分为循环递增数组；后半部分为严格递增数组。
    记要检索的元素为 e，数组的首元素为 a[low]，中间元素为 a[mid]，末尾元素为 a[high]。
    则当 e 等于 a[mid] 时，直接返回 mid 的值即可；当 e 不等于 a[mid] 时:
  1. a[mid] > a[low]，即数组前半部分为严格递增数组，后半部分为循环递增数组时，若
    key 小于 a[mid]并且不小于 a[low]时，则 key 落在数组前半部分；否则，key 落在数组
    后半部分。
  2. a[mid] < a[high]，即数组前半部分为循环递增数组，后半部分为严格递增数组时，
    若 key 大于 a[mid]并且不大于 a[high]时，则 key 落在数组后半部分；否则，key 落在
    数组前半部分。
    这种方式的时间复杂度为：O(log(n))，空间复杂度为 O(1)。
    public class TestBinarySearch {
    public static void main(String[] args) {
    // 定义数组
    int[] a = { 17, 19, 20, 21, 25, 1, 4, 7 };
    // 调用改进后的二分查找法求索引
    int pos = search(a, 7);
    System.out.println("要查找的元素的索引为：" + pos);
    }
    /** 改进后的二分查找法：e 为要查找的元素 */
    public static int search(int[] a, int e) {
    int low = 0;
    int high = a.length - 1;
    int mid = 0;
    int pos = -1; // 返回-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; } }
  1. 请编写一个完整的程序，实现如下功能：从键盘输入数字 n，程序自动
    计算 n!并输出。（注 1：n！=123...n, 注 2：请使用递归实现）
    思路说明：因为 n! = (n-1)! * n，所以要求 n!首先要求出(n-1)!，而(n-1)! = (n-1-1)! *
    (n-1)，以此类推，直到 n = 1 为止。
    import java.util.Scanner;
    public class TestFactorial {
    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));
    }
    /**求阶乘的方法    /
    public static int factorial(int n) {
    if(n == 1){
    return 1;
    }
    return factorial(n - 1) * n; } }
  2. 请用递归的方法计算斐波那契数列的同项 F（n），已知
    F0=0,F1=1,F(n)=F(n-1)+F(n-2)(n>=2,n∈N*).
    思路说明：斐波那契数列的排列是：0，1，1，2，3，5，8，13，21，34，55，89，
    144……，特别指出的是 0 不是第一项而是第 0 项；因为 F(n)=F(n-1)+F(n-2)，所以要
    求 F(n)首先要求出 F(n-1)和 F(n-2)，而 F(n-1)=F(n-1-1)+F(n-1-2)，以此类推，直
    到,F(2)=F(1)+F(0)为止，已知 F(1) = 1，F(0) = 0。
    import java.util.Scanner;
    public class TestFibo {
    public static void main(String[] args) {
    System.out.print("请输要求斐波那契数列的第几项：");
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    System.out.println("斐波那契数列的第"+ n + "是：" +
    fibo(n));
    }
    public static int fibo(int n) {
    if(n == 0){
    return 0;
    } else if(n == 1){
    return 1;
    }
    return fibo(n -1) + fibo(n - 2);
    } }
  3. 现在有整数数组{11,66,22,0,55,32}，请任意选择一种排序算法，用
    Java 程序实现
    冒泡思路说明：
    (1) 最开始将数组看做一个无序数列(个数是数组的长度)与一个有序数列(0 个)的组合；
    (2) 每一趟比较完后, 找到了无序数列的最大值, 将其放到有序数列中(有序数列个数+1)；
    (3) N 个数, 比较 N-1 趟；
    (4) 每一趟挨个进行比较：从数组的第一个元素开始, 到无序数列的最后一个为止；
    (5) 如果前边一个大于后边一个, 那么交换位置；
    (6) 每趟比较的次数与趟数有关；
    (7) 根据每趟比较是否发生了交换判断数据是否已经有序，从而进行优化。
    public class TestSort {
    public static void main(String[] args) {
    int[] arr = {11, 66, 22, 0, 55, 32};
    // 调用排序方法
    sort(arr);
    // 输出排除后的数组
    for (int num : arr) {
    System.out.print(num + "\t");
    } }
    public static void sort(int[] arr) {
    // 定义标记
    boolean flag = false;
    int temp;
    // 排序
    // 外层循环控制的是比较的趟数
    for (int i = 0; i < arr.length - 1; i++) {
    // 每一趟比较之前初始化, 否则会保留上一堂比较的结果
    flag = false;
    // 内层循环控制的是每趟比较的次数
    for (int j = 0; j < arr.length - 1 - i; j++) {
    // 挨个进行比较: 从数组的第一个元素开始, 到无序数列的
    最后一个
    if (arr[j] > arr[j + 1]) {
    // 交换
    temp = arr[j];
    arr[j] = arr[j + 1];
    arr[j + 1] = temp;
    //如果发生交换，改变 flag 的值
    flag = true; } }
    if (!flag) {
    break; } } } }
  4. 请根据注释，编码实现下面类的方法
    // 这个类用于存取一组权限，每个权限用非负整数表示的.这组枳限存储在
    // righiString 属性中。如果权限 N 权限存在，rightString 第 N 个字符为“1”,
    否则， 为空格。
    class RightStore {
    public String righString = "";
    // 如果传入的权限 right 存在，该方法返回 true.否期，为 false.,
    // right 为传入的权限的整数值.
    public boolean getRight(int right) {
    return true; }
    // 该方法存储或消除传入的权限.如果 value 为 true,存储传入的权限,
    // 否则淸除该权限.
    // right 为传入的权限的整数值.
    public void setRight(int right, boolean value) {
    } }
    思路说明：我们首先要读懂这道题的意思：righString 这个字符串是用来存储一系列权
    限的，并且权限的取值只有两种：有和没有；在 righString 中使用字符‘1’表示有权
    限，字符空格‘ ’表示没有权限。举个例子：如果 righString 的长度为 3，第一位表示
    对订单系统是否有权限，第二位表示对人员管理系统是否有权限，第三位表示对库存系
    统是否有权限。而方法中的 int right 参数则表示的是字符串的第几位。
    上边这些搞明白之后，方法的编写就简单多了。
    public class RightStore {
    public String righString = "";
    public boolean getRight(int right) {
    //先求得第 right 个字符
    char ch = righString.charAt(right - 1);
    //如果 ch 为\'1\'，返回 true，否则返回 false
    return ch == \'1\'; }
    public void setRight(int right, boolean value) {
    //如果 value 为 true,存储传入的权限，否则消除权限（改为空格）
    righString.replace(righString.charAt(right - 1), value ?
    \'1\' : \' \');
    } }
  5. 二分法查询（递归实现）
    思路说明：假设在一个已经排好序的有序序列(N 个元素，升序排列)，首先让序列中的中
    间的元素与需要查找的关键字进行比较，如果相等，则查找成功，否则利用中间位置将
    序列分成两个子序列，如果待查找的关键字小于中间的元素，则在前一个子序列中同样
    的方法进一步查找，如果待查找的关键字大于中间的元素，则在后一个子序列中同样的
    方法进一步查找，重复以上过程一直到查找结束！
    import java.util.Scanner;
    public class TestBinarySearchRecursion {
    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 -1;
    } }
  6. 编写一段 Java 程序，把一句英语中的每个单词中的字母次序倒转，单词
    次序保持不变，例入输入为“There is a dog.”,输出结果应该是“erehT si
    a god.”要求不使用 Java 的库函数，例如 String 类的 split，reverse 方
    法。
    函数形如：
    public static String reverseWords(String input) {
    String str = "";
    return str; }
    思路说明：将字符串转化成字符数组，然后根据数组中空格的位置判断每个单词所占的
    索引范围，根据得到的索引将数组中的每个单词逆序后拼接到新的字符串中。
    public class TestStringReverse{
    public static void main(String[] args) {
    String input = "There is a dog";
    System.out.println("逆转后的字符串为：" +
    reverseWords(input));
    }
    public static String reverseWords(String input) {
    String str = "";
    //将字符串转化成字符数组
    char[] arr = input.toCharArray();
    //index 用来记录每个单词的起始索引
    int index = 0;
    //遍历字符数组，将空格前边的单词挨个拼接到 str 中
    for (int i = 0; i < arr.length; i++) {
    if(arr[i] == \' \'){
    //根据空格的位置将空格前边一个单词密续追加到 str 中
    for(int j = i - 1; j >= index; j--){
    str += arr[j];
    }
    //单词拼接完成后，拼接一个空格
    str += \' \';
    //让 index 指向下一个单词的起始位置
    index = i + 1;
    } }
    //将最后一个单词拼接上
    for(int i = arr.length - 1; i >= index; i--){
    str += arr[i];
    }
    return str; } }
  7. 手写 9x9 乘法表，冒泡排序
    9x9 乘法表: class Demo {
    public static void main(String[] args) {
    for(int x = 0;x <= 9; x++) {
    for(int y = 1;y <= x; y++) {
    System.out.print(y+""+x+"="+xy+"\t");
    }
    System.out.println();
    }
    }
    }
    冒泡排序: public class BubbleSort{
    public static void main(String[] args){
    int score[] = {67, 69, 75, 87, 89, 90, 99, 100};
    for (int i = 0; i < score.length -1; i++){//最多做 n-1 趟
    排序
    for(int j = 0 ;j < score.length - i - 1; j++){//对当
    前无序区间 score[0......length-i-1]进行排序(j 的范围很关键，这个范围
    是在逐步缩小的)
    if(score[j] < score[j + 1]){ //把小的值交换到后面
    int temp = score[j];
    score[j] = score[j + 1];
    score[j + 1] = temp;
    }
    }
    System.out.print("第" + (i + 1) + "次排序结果：");
    for(int a = 0; a < score.length; a++){
    System.out.print(score[a] + "\t");
    }
    System.out.println("");
    }
    System.out.print("最终排序结果：");
    for(int a = 0; a < score.length; a++){
    System.out.print(score[a] + "\t");
    } } }
  8. 题目： 给定一个整数数组，找到是否该数组包含任何重复数字。你的函
    数应该返回 true 只要有任何数字 在该数组中重复出现，否则返回 false。 public class Solution {
    public boolean containsDuplicate(int[] nums) {
    Set numSet = new HashSet();
    for(int i=0;i<nums.length;i++){·
    if(numSet.contains(nums[i]))
    return true;
    else
    numSet.add(nums[i]);
    }
    return false;
    } }
  9. 给定一个数组 nums， 写一个函数来移动所有 0 元素到数组末尾，同时
    维持数组中非 0 元素的相对顺序不变。要求不能申请额外的内存空间，并且
    最小化操作次数。
    public void moveZeroes(int[] nums) {
    int size = nums.length;
    int startIndex = 0;
    // 0 元素开始的位置
    int endIndex = 0;
    // 0 元素结束的位置
    int currentNum;
    int i= 0;
    // 第一步：找到第一个 0 元素开始的位置
    // 并将第一个 0 元素的游标赋值给 startIndex&endIndex
    while(i < size){
    currentNum = nums[i];
    if (currentNum == 0) {
    startIndex = i;
    endIndex = i;
    break;
    }
    ++i;
    }
    // 如果当前数组中没有找到 0 元素，则推出
    if (nums[endIndex] != 0)
    return;
    // 将当前 i 的值加 1；直接从刚才 0 元素位置的后一位置开始循环
    ++i;
    while (i < size) {
    currentNum = nums[i];
    if (currentNum == 0){//如果当前元素等于 0，则将 i 值赋值
    给 endIndex
    endIndex = i;
    } else {
    // 如果不为 0
    //则将当前元素赋值给 nums[startIndex]
    // 并将当前位置的元素赋值为 0
    // startIndex 和 endIndex 都加 1；
    nums[startIndex] = currentNum;
    nums[i] = 0;
    ++startIndex;
    ++endIndex;
    }
    ++i;
    }
    }
  10. 给定一颗二叉树，返回节点值得先序遍历，请使用迭代（非递归）方式
    实现。
    public class Solution {
    public List preorderTraversal(TreeNode root) {
    List result = new ArrayList();
    if(root == null)
    return result;
    Stack stack = new Stack();
    stack.push(root);
    while(!stack.isEmpty()) {
    TreeNode node = stack.pop();
    result.add(node.val);
    if(node.right != null)
    stack.push(node.right);
    if(node.left != null)
    stack.push(node.left);
    }
    return result;
    }
    }
  11. 验证一棵树是否为有效的二叉搜索树 BST
    public class Solution {
    private static int lastVisit = Integer.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
    if(root == null) return true;
    boolean judgeLeft = isValidBST(root.left); // 先判断左子
    树

if(root.data >= lastVisit && judgeLeft) { // 当前节点比上
次访问的数值要大
lastVisit = root.data;
} else {
return false;
}
boolean judgeRight = isValidBST(root.right); // 后判断右
子树
return judgeRight; } }
643. 从一个链表中删除节点
题目： 写一个函数用于在一个单向链表中删除一个节点（⾮非尾节点），前提是仅仅能够访
问要删除的那个节点。
比如给定链表 1 -> 3 -> 5 -> 7 -> 9 -> 16，给定你值为 3 的那个节点， 调⽤用你的函数
后，链表变为
1 -> 5 -> 7 -> 9 -> 16。
/**
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }

  • }
    */
    public class Solution {
    public void deleteNode(ListNode node) {
    if(nodenull||node.nextnull) {
    System.out.println("节点不存在或者是尾节点");
    }else{
    node.val=node.next.val;
    node.next=node.next.next; } }
    }
  1. 二叉搜索树 BST 中第 Kth 小的元素 题目：给定⼀个 BST，写一个函数
    kthSmallest 来找到第 kth 小的元素
    /**
    Definition for a binary tree node.
    public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
  • }
    */
    public class Solution2 {
    public int kthSmallest(TreeNode root, int k) {
    Stack store = new Stack();
    if (root == null) {
    return -1;
    }
    store.push(root);
    while (root.left != null) {
    store.push(root.left);
    root = root.left;
    }
    while (!store.empty()) {
    TreeNode cur = store.pop();
    k--;
    if (k == 0) {
    return cur.val;
    }
    if (cur.right != null) {
    root = cur.right;// let cur.right be the current node
    store.push(root);
    while (root.left != null) {
    store.push(root.left);
    root = root.left;
    }
    }
    }
    return -1;
    }
    }
  1. 题目：给定含有 n 个整数的数组 S，S 中是否存在三个元素 a,b,c 使得 a
  • b + c = 0? 找到所有这样的三元 组，并且结果集中不包含重复的三元组。
    比如，
    S = [-1, 0, 1, 2, -1, -4],,
    结果集为: [
    [-1, 0, 1],
    [-1, -1, 2]
    ]
    /**
  • 给定一个 n 个元素的数组，是否存在 a，b，c 三个元素，使用得 a+b+c=0，找
    出所有符合这个条件的三元组
  • 注意： - 三元组中的元素必须是非递减的 - 结果不能包含重复元素
    */
    public class Solution {

public static void main(String[] args) {
int[] S = {-1, 0, 1, 2, -1, -4,-3,-4,4,3};
new Solution().get3Sum(S);
}

public Set get3Sum(int[] S){

if(S.length<3 || S==null){
return null;
}

//接收拼接的字符串
StringBuffer sb = new StringBuffer();
for(int i=0; i<S.length; i++){
for(int j=0; j<S.length; j++){
for(int z=0; z<S.length; z++){
//筛选出不是递减的一组元素
if(S[i]<=S[j] && S[j]<=S[z]){
int sum = S[i] + S[j] + S[z];
if(sum==0){
String str =
"("+S[i]+","+S[j]+","+S[z]+")";
sb.append(str+";");
}
}
}
}
}

String s = sb.toString();
s = s.substring(0, sb.length()-1);
String[] arr = s.split(";");

Set set = new HashSet();
//将所筛选出来的元素放入 Set 集合中，去重
for (int k = 0; k < arr.length; k++) {
set.add(arr[k]);
}
System.out.println(set);
return set;
}

public List<List> threeSum(int[] nums) {
List<List> result = new LinkedList<>();

if (nums != null && nums.length > 2) {
// 先对数组进行排序
Arrays.sort(nums);
// i 表示假设取第 i 个数作为结果
for (int i = 0; i < nums.length - 2; ) {
// 第二个数可能的起始位置
int j = i + 1;
// 第三个数可能是结束位置
int k = nums.length - 1;
while (j < k) {
// 如果找到满足条件的解
if (nums[j] + nums[k] == -nums[i]) {
// 将结果添加到结果含集中
List list = new ArrayList<>(3);
list.add(nums[i]);
list.add(nums[j]);
list.add(nums[k]);
result.add(list);
// 移动到下一个位置，找下一组解
k--;
j++;

// 从左向右找第一个与之前处理的数不同的数的下标
while (j < k && nums[j] == nums[j - 1]) {
j++;
}
// 从右向左找第一个与之前处理的数不同的数的下标
while (j < k && nums[k] == nums[k + 1]) {
k--;
}
}
// 和大于 0
else if (nums[j] + nums[k] > -nums[i]) {
k--;
// 从右向左找第一个与之前处理的数不同的数的下标
while (j < k && nums[k] == nums[k + 1]) {
k--;
}
}
// 和小于 0
else {
j++;
// 从左向右找第一个与之前处理的数不同的数的下标
while (j < k && nums[j] == nums[j - 1]) {
j++;
}
}
}
// 指向下一个要处理的数
i++;
// 从左向右找第一个与之前处理的数不同的数的下标
while (i < nums.length - 2 && nums[i] == nums[i - 1])
{
i++;
}
}
}
return result;
}
}
646. 子集问题
题目： 给定一个不包含相同元素的整数集合，nums，返回所有可能的子集集合。解答
中集合不能包含重 复的子集。
比如，
nums = [1, 2, 3], ⼀一种解答为：
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2], []
]
/**

  • 不重复集合求子集
    解答采用的是深度优先遍历，先取原数组一个元素，再构造包括这个元素的两个，
    三个……n 个元素的集合。dfs 中的 start 就指向这个元素的，它在不断地后移
    （i+1)。
  • @param S: A set of numbers.
  • @return: A list of lists. All valid subsets.
    */
    public class Solution1 {
    public static void main(String[] args) {
    int[] first = new int[]{1, 2, 3};
    ArrayList<ArrayList> res = subsets(first);
    for(int i = 0; i < res.size(); i ++){
    System.out.println(res.get(i));
    }
    }
    public static ArrayList<ArrayList> subsets(int[]
    nums) {
    ArrayList<ArrayList> res = new
    ArrayList<ArrayList>();
    ArrayList item = new ArrayList();
    if(nums.length == 0 || nums == null)
    return res;
    Arrays.sort(nums); //排序
    dfs(nums, 0, item, res); //递归调用
    res.add(new ArrayList()); //最后加上一个空集
    return res;
    }
    public static void dfs(int[] nums, int start,
    ArrayListitem, ArrayList<ArrayList>res){
    for(int i = start; i < nums.length; i ++){
    item.add(nums[i]);
    //item 是以整数为元素的动态数组，而 res 是以数组为元素的数
    组，在这一步，当 item 增加完元素后，item 所有元素构成一个完整的子串，
    再由 res 纳入
    res.add(new ArrayList(item));
    dfs(nums, i + 1, item, res);
    item.remove(item.size() - 1);
    }
    } }
  1. 迭代方法实现二叉树的先序遍历：题目： 给定一颗⼆叉树，返回节点值
    得先序遍历，请使用迭代（非递归）方式实现。
    比如， 给定二叉树{1,#,2,3}, 返回 [1,2,3]
    /**
    Definition for a binary tree node.
    public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
  • }
    */
    public class Solution {

List result = new ArrayList();

/**

  • 迭代实现，维护一个栈，因为入栈顺序按照根右左进行入栈，因此首先
    将根出栈，然后出栈左子节点，
  • 最后出栈右子节点。
  • @param root
  • @return
    */
    public List preorderTraversal(TreeNode root) {
    if(root == null)
    return result;
    Stack stack = new Stack();
    stack.push(root);
    while(!stack.isEmpty()) {
    TreeNode node = stack.pop();
    result.add(node.val);
    if(node.right != null)
    stack.push(node.right);
    if(node.left != null)
    stack.push(node.left);
    }
    return result;
    }
    }
  1. 验证二叉搜索树 BST：题目： 验证一棵树是否为有效的二叉搜索树 BST
    比如，二叉树[2, 1, 3]，返回 true 二叉树[1, 2, 3], 返回 false
    class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
    }
    public class BSTChecker {
    private static int lastVisit = Integer.MIN_VALUE;

public static boolean isBST(TreeNode root) {
if(root == null) return true;

boolean judgeLeft = isBST(root.left); // 先判断左子树

if(root.val >= lastVisit && judgeLeft) { // 当前节点比上
次访问的数值要大
lastVisit = root.val;
} else {
return false;
}

boolean judgeRight = isBST(root.right); // 后判断右子树

return judgeRight;
}
}
649. 编辑距离题目： 给定两个单词 word1 和 word2，找到最小的操作步骤
使得 word1 转换成 word2，每次操作算作一 步。你可以对单词进行以下
三种操作：1）插入一个字符 2）删除一个字符 3）替换一个字符
参考地址：http://www.cnblogs.com/masterlibin/p/5785092.html
650. 买卖股票问题：题目： 你有一个数组，第 i 个元素表示第 i 天某个股票
的价格，设计一个算法找到最大的利润，并且你只能最多完成两次交易。
参考地址：没有完全理解的
http://www.mamicode.com/info-detail-1087177.html
http://blog.csdn.net/cumt_cx/article/details/48015735
/**

  • 解题思路：
  • 比如给定一组数组，[1，2，3，6，9，3，10]
  • 最多可以 2 次去获取最大的利益，可以用 2 分的思想，分成 2 部分，
  • 从 0 元素开始遍历分别求出左右 2 边的最大利益，求出的左右 2 边最大的利
    益即为解
    */
    class Solution {
    public static int maxProfit(int[] prices) {
    // write your code here
    if(nullprices||0prices.length) return 0;
    int sumProfit = 0;
    for(int i=1;i<prices.length;i++){
    int tmpsum = maxProfit(prices, 0, i)
  • maxProfit(prices, i+1, prices.length-1);
    sumProfit = Math.max(sumProfit, tmpsum);
    }
    return sumProfit;
    }
    public static int maxProfit(int[] prices,int s,int e){
    if(e<=s) return 0;
    int min = prices[s];
    int maxProfit = 0;
    for(int i=s+1;i<=e;i++){
    maxProfit = Math.max(maxProfit, prices[i]-min);
    min = Math.min(min, prices[i]);
    }
    return maxProfit;
    }
    public static void main(String[] args) {
    int arr [] = {4,4,6,1,1,4,2,5};
    System.out.println(maxProfit(arr));
    } }
  1. [编程]任给 n 个整数和一个整数 x。请计算 n 个整数中有多少对整数之
    和等于 x。 public class Test8 {
    public static void main(String[] args) {
    //输入 n 个整数和一个整数
    Scanner input = new Scanner(System.in);
    System.out.println("请输入 n 个整数，数量任意,以逗号分隔
    ");
    String str = input.next();
    System.out.println("请输入一个整数：");
    int x = input.nextInt();
    //将 n 个整数的字符串转换为数组
    String arr1[] = str.split(",");
    int [] arr2 = new int[arr1.length];
    for(int i=0;i<arr1.length;i++){
    arr2[i] = Integer.parseInt(arr1[i]);
    }
    System.out.println(Arrays.toString(arr2));
    //判断并输出 n 个整数中有几对的和等于 x
    int count = 0;
    for(int i=0;i<arr2.length-1;i++){
    for(int j = i+1;j<arr2.length;j++){
    if(arr2[i]+arr2[j]==x){
    count++;
    } } }
    System.out.println(count);
    } }
  2. [编程]请说明快速排序算法的设计思想和时间复杂度，并用高级语言写出
    对整数数组进行一趟快排的函数实现。
    快速排序由 C. A. R. Hoare 在 1962 年提出。它的基本思想是：通过一趟排序将要排序
    的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
    然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此
    达到整个数据变成有序序列。
    设要排序的数组是 A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）
    作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，
    这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就
    是说，多个相同的值的相对位置也许会在算法结束时产生变动。
    一趟快速排序的算法是：
    1、设置两个变量 i、j，排序开始的时候：i=0，j=N-1； 2、以第一个数组元素作为关键数据，赋值给 key，即 key=A[0]； 3、从 j 开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于 key 的值 A[j]，将 A[j]和 A[i]互
    换；
    4、从 i 开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于 key 的 A[i]，将 A[i]和 A[j]互换；
    5、重复第 3、4 步，直到 i=j； (3,4 步中，没找到符合条件的值，即 3 中 A[j]不小于 key,4 中 A[i]
    不大于 key 的时候改变 j、i 的值，使得 j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交
    换的时候 i，j 指针位置不变。另外，i==j 这一过程一定正好是 i+或 j-完成的时候，此时令循环结束）。
    public class Quick {
    public static void main(String[] args) {
    int arr [] = {90,60,70,50,40,80,20,100,10};
    sort(arr,0,arr.length-1);
    System.out.println(Arrays.toString(arr));
    }
    public static void sort(int arr[], int low, int high) {
    //设置两个变量 l、h，排序开始的时候：l=0，h=N-1
    int l = low;
    int h = high;
    //以第一个数组元素作为关键数据，赋值给 key，即 key=A[0]
    int key = arr[low];
    //重复操作，直到 i=j
    while (l < h) {
    //从 h 开始向前搜索，即由后开始向前搜索(h--)，找到第一个
    小于 key 的值 arr[h]，将 arr[h]和 arr[l]互换
    while (l < h && arr[h] >= key) h--;
    if (l < h) {
    int temp = arr[h];
    arr[h] = arr[l];
    arr[l] = temp; l++;
    }
    //从 l 开始向后搜索，即由前开始向后搜索(l++)，找到第一个
    大于 key 的 arr[l]，将 arr[l]和 arr[h]互换；
    while (l < h && arr[l] <= key) l++;
    if (l < h) {
    int temp = arr[h];
    arr[h] = arr[l];
    arr[l] = temp; h--; } }
    //对前一部分进行快速排序
    if (l > low)
    sort(arr, low, l - 1);
    //对前一部分进行快速排序
    if (h < high)
    sort(arr, l + 1, high);
    } }
  3. 对于一段形如：1，-13,115×3 的输入
    输入会依照以下规则：
    1、所有输入为整数、
    2、“,”为分隔符
    3、“”表示一个区间，比如“-13”表示-1 到 3 总共 5 个整数，同时“~”前的数小
    于“~”后的数：
    4、“x”表示步长，“x3”指每 3 个整数一个，比如“1~15×3”表示 1，4,7,10,13；
    根据以上得到的结果进行打印，打印的规则为：
    1、所有得到的整数按从小到大排列，以“，”分隔，不计重复；
    2、每行最多显示 3 个整数；
    3、如果两个整数是连续的，可以放在同一行，否则自动换行。
    例如对于输入“1，-13,115×3”的输出结果为：
    -1,0,1，
    2,3,4，
    7,
    10，
    13
    public class Test {
    public static void main(String[] args) {
    Map<Integer, Integer> map = new TreeMap<Integer,
    Integer>();
    String str = "520x3,1,-13,1~15x3";
    String[] s = str.split(",");
    for (int i = 0; i < s.length; i++) {
    if (s[i].contains("~")) {
    String ss[] = s[i].split("~");
    int first = Integer.parseInt(ss[0]);
    if (s[i].contains("x")) {
    String sss[] = ss[1].split("x");
    int end = Integer.parseInt(sss[0]);
    int l = Integer.parseInt(sss[1]);
    for (int j = first; j < end;) {
    map.put(j, j);
    j += l; }
    } else {
    int end = Integer.parseInt(ss[ss.length
  • 1]);
    for (int j = first; j <= end; j++) {
    map.put(j, j);
    } }
    } else {
    int j = Integer.parseInt(s[i]);
    map.put(j, j);
    } }
    List list = new ArrayList();
    Set set = map.keySet();
    Iterator ite = set.iterator();
    while (ite.hasNext()) {
    int key = ite.next();
    int value = map.get(key);
    list.add(value);
    System.out.println("v :" + value);
    }
    System.out.println("=================");
    for (int i = 0; i < list.size()

分类：

技术点：

相关文章：

  • 2021-12-15
  • 2021-10-25
  • 2021-06-26
  • 2021-11-16
  • 2021-09-28
  • 2021-10-01
  • 2021-11-16
  • 2021-12-03
猜你喜欢
  • 2021-11-11
  • 2021-11-21
  • 2021-11-04
  • 2021-08-31
  • 2021-12-01
  • 2021-10-20
  • 2021-12-12
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode