牛客网刷题 第一轮
文章目录
- 1.1
- 1.2 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
- 1.3 复杂链表遍历
- 1.4 二叉排序树转变为双向排序链表
- 1.5 全排列
- 1.6 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
- 1.9 求数组的最大连续子序列的和
- 1.10 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
- 1.11 把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
1.1
public class Solution {
public boolean Find(int target, int [][] array) {
int a = array.length - 1;
int b = array[1].length - 1;
int i = 0;
while(a >= 0 && i <= b){
if(array[a][i] == target){
return true;
}
else if(array[a][i] < target){
i ++;
}
else if(array[a][i] > target){
a --;
}
}
return false;
}
}
- 结果：
不通过
您的代码已保存
答案错误:您提交的程序没有通过所有的测试用例
case通过率为41.18%
用例:
16,[[]]
对应输出应该为:
false
你的输出为:
java.lang.ArrayIndexOutOfBoundsException: 1
1.2 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
public class Solution {
public boolean VerifySquenceOfBST(int [] sequence) {
if(sequence.length == 0){
return false;
}else if(sequence.length == 1){
return true;
}
else{
return isLastOrder(sequence,0,sequence.length-1);
}
}
public boolean isLastOrder(int[] sequence, int start, int end){
if (start == end) {
return true;
}
int i = start;
while (i <= end && sequence[i] < sequence[end]) {
i++;
}
i -- ;
int j = end;
while (j >= start && sequence[j] >= sequence[end]) {
j--;
}
j ++;
if (i >= j) {
return false;
}
if(i + 1 != j){
return false;
}
if(i == -1 || i == end - 1){
return isLastOrder(sequence,start,end - 1);
}
return isLastOrder(sequence, start, i) && isLastOrder(sequence, j, end - 1);
}
}
1.3 复杂链表遍历
- 思路：
- １．在原来链表的基础上，加入新的节点，新的节点在插入旧的节点后面
- ２．将原来节点的随机指针复制给新节点的随机指针
- ３．将两个链表分离，返回新链表的头结点
1.4 二叉排序树转变为双向排序链表
- 思路：使用中序遍历树的方法即可
1.5 全排列
引用牛客网一个老哥的图:
注意点：需要将刚开始的数组保留一份，不然下次就是在上一次变化的基础上变化，就会出错。
1.6 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
- 思路：将数组的前k个数进行排序，然后从第k+1个数开始与前k个数进行比较，使用插入排序的思路，保证前k个数始终是遍历过得数中最小的。
import java.util.ArrayList;
public class Solution {
public ArrayList GetLeastNumbers_Solution(int [] input, int k) {
ArrayList objects = new ArrayList();
if(k>input.length || k == 0){
return objects;
}
sort(input,k);
if(k + 1 < input.length) {
for (int j = k; j < input.length; j++) {
insert(input, k - 1, j);
}
}
for (int i = 0; i < k; i++) {
objects.add(input[i]);
}
return objects;
}
public static void sort(int[] arrray, int length){
for (int i =0;i < length; i ++){
for(int j = 0; j array[end]){
return;
}
int flag = end;
while (array[index] < array[flag] && flag > 0){
flag--;
}
int mid = array[index];
for(int j=end;j>=flag;j--){
array[j + 1] = array[j];
}
array[flag] = mid;
}
}
1.9 求数组的最大连续子序列的和
* 从第一个数开始计算，找最大值的规律
* 找以当前值为结尾的最大值。
此处引用牛客上大佬的思路:
使用动态规划
F（i）：以array[i]为末尾元素的子数组的和的最大值，子数组的元素的相对位置不变
F（i）=max（F（i-1）+array[i] ， array[i]）
res：所有子数组的和的最大值
res=max（res，F（i））
如数组[6, -3, -2, 7, -15, 1, 2, 2]
初始状态：
F（0）=6
res=6
i=1：
F（1）=max（F（0）-3，-3）=max（6-3，3）=3
res=max（F（1），res）=max（3，6）=6
i=2：
F（2）=max（F（1）-2，-2）=max（3-2，-2）=1
res=max（F（2），res）=max（1，6）=6
i=3：
F（3）=max（F（2）+7，7）=max（1+7，7）=8
res=max（F（2），res）=max（8，6）=8
i=4：
F（4）=max（F（3）-15，-15）=max（8-15，-15）=-7
res=max（F（4），res）=max（-7，8）=8
以此类推
最终res的值为8
public class Max {
public static void main(String[] args) {
int array[] = new int[]{1,-3,2,-4,-3,-2,-4};
System.out.println(findmax(array));
}
public static int findmax(int[] array){
int res = array[0];
int max = array[0];
for (int i = 1; i < array.length; i++) {
max = Math.max(max + array[i], array[i]);
res = Math.max(max,res);
}
return res;
}
}
1.10 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
* 解题思路：
* 先将整型数组转换成String数组，然后将String数组排序，最后将排好序的字符串数组拼接出来。关键就是制定排序规则。
* 排序规则如下：
* 若ab > ba 则 a > b，
* 若ab < ba 则 a < b，
* 若ab = ba 则 a = b；
* 解释说明：
* 比如 "3" < "31"但是 "331" > "313"，所以要将二者拼接起来进行比较
public String PrintMinNumber(int [] numbers) {
if(numbers == null || numbers.length == 0) return "";
int len = numbers.length;
String[] str = new String[len];
StringBuilder sb = new StringBuilder();
for(int i = 0; i < len; i++){
str[i] = String.valueOf(numbers[i]);
}
Arrays.sort(str,new Comparator(){
@Override
public int compare(String s1, String s2) {
String c1 = s1 + s2;
String c2 = s2 + s1;
return c1.compareTo(c2);
}
});
for(int i = 0; i < len; i++){
sb.append(str[i]);
}
return sb.toString();
}
1.11 把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
解题思路来源：牛客网上的大佬
首先从丑数的定义我们知道，一个丑数的因子只有2,3,5，那么丑数p = 2 ^ x * 3 ^ y * 5 ^ z，换句话说一个丑数一定由另一个丑数乘以2或者乘以3或者乘以5得到，那么我们从1开始乘以2,3,5，就得到2,3,5三个丑数，在从这三个丑数出发乘以2,3,5就得到4，6,10,6，9,15,10,15,25九个丑数，我们发现这种方***得到重复的丑数，而且我们题目要求第N个丑数，这样的方法得到的丑数也是无序的。那么我们可以维护三个队列：
（1）丑数数组： 1
乘以2的队列：2
乘以3的队列：3
乘以5的队列：5
选择三个队列头最小的数2加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（2）丑数数组：1,2
乘以2的队列：4
乘以3的队列：3，6
乘以5的队列：5，10
选择三个队列头最小的数3加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（3）丑数数组：1,2,3
乘以2的队列：4,6
乘以3的队列：6,9
乘以5的队列：5,10,15
选择三个队列头里最小的数4加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（4）丑数数组：1,2,3,4
乘以2的队列：6，8
乘以3的队列：6,9,12
乘以5的队列：5,10,15,20
选择三个队列头里最小的数5加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（5）丑数数组：1,2,3,4,5
乘以2的队列：6,8,10，
乘以3的队列：6,9,12,15
乘以5的队列：10,15,20,25
选择三个队列头里最小的数6加入丑数数组，但我们发现，有两个队列头都为6，所以我们弹出两个队列头，同时将12,18,30放入三个队列；
……………………