一.
题目描述
合并两个有序数组
package kuaishou;
import java.util.*;
//两个有序数组的合并排序(归并思想),Java代码实现,并去重复,考虑空间利用率问题
public class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] nums = null;
nums = sc.nextLine().split(" ");
int A[]=new int[nums.length];
for(int i=0;i<A.length;i++){
A[i]=Integer.parseInt(nums[i]);
}
nums = sc.nextLine().split(" ");
int B[]=new int[nums.length];
for(int i=0;i<B.length;i++){
B[i]=Integer.valueOf(nums[i]);
}
//int[] A = {-1,1,2,3,4,5};
//int[] B = {1,2,2,3,4,5,5,6,7,7};
int[] result = Solution.multiply(A, B);
System.out.println(Arrays.toString(result));
}
public static int[] multiply(int[] A,int[] B) {
if (A == null && B == null || A.length < 1 && B.length < 1) {
return null;
}
// 创建辅助集合,其实数组创建新的数组也行,new int[A.length+B.length]
List<Integer> list = new ArrayList<>();
int index = 0, p1 = 0, p2 = 0;
// 先将A或者B中的首个元素添加到list
// 这里其实得判断是否为null。
list.add(A[p1++]);
// 当没有遍历完A和B中任意一个数组时执行
while ( p1 < A.length && p2 < B.length ) {
// 拿到当前指针的最小值
int tmp = A[p1] < B[p2] ? A[p1++] : B[p2++];
// 判断list中是否已经添加了此元素,!=也行
if (tmp > list.get(index)) {
list.add(tmp);
// 每次添加元素后指针后移
index++;
}
}
// 当B中元素添加完,只剩A中元素时
while ( p1 < A.length ) {
int tmp = A[p1++];
if (tmp > list.get(index)) {
list.add(tmp);
index++;
}
}
// 当A中元素添加完,只剩B中元素时
while ( p2 < B.length ) {
int tmp = B[p2++];
if (tmp > list.get(index)) {
list.add(tmp);
index++;
}
}
// 将list中元素重新移回到数组,如果刚开始创建的是数组,那么就不用这一步了
int[] result = new int[list.size()];
for (int i = 0; i < list.size(); i++) {
result[i] = list.get(i);
}
return result;
}
}
二.
题目描述
连续子数组的最大和
//动态规划
public class Solution {
public int FindGreatestSumOfSubArray(int[] array) {
int local=array[0];//局部最优
int global=array[0];//全局最优
for(int i=1;i<array.length;i++){
local=Math.max(array[i]+local,array[i]);
global=Math.max(local,global);
}
return global;
}
}
三.
题目描述
统计一个数字在排序数组中出现的次数
/*简单粗暴法
public class Solution {
public int GetNumberOfK(int [] array , int k) {
int count=0;
for(int i=0;i<array.length;i++){
if(array[i]==k)
count++;
}
return count;
}
}
*/
public class Solution {
//思想一样
//计算k在数组中出现的次数
public int GetNumberOfK(int [] array , int k) {
int length = array.length;
if(length == 0){
return 0;
}
int firstK = getFirstK(array, k, 0, length-1);
int lastK = getLastK(array, k, 0, length-1);
if(firstK != -1 && lastK != -1){
return lastK - firstK + 1;
}
return 0;
}
//递归写法
private int getFirstK(int [] array , int k, int start, int end){
if(start > end){
return -1;
}
int mid = (start + end) >> 1;
if(array[mid] > k){
return getFirstK(array, k, start, mid-1);
}else if (array[mid] < k){
return getFirstK(array, k, mid+1, end);
}else if(mid-1 >=0 && array[mid-1] == k){//如果前一个数字也是k,则说明第一个k在前面,继续在前半段查找k
return getFirstK(array, k, start, mid-1);
}else{
return mid;
}
}
//循环写法
private int getLastK(int [] array , int k, int start, int end){
int length = array.length;
int mid = (start + end) >> 1;
while(start <= end){
if(array[mid] > k){
end = mid-1;
}else if(array[mid] < k){
start = mid+1;
}else if(mid+1 < length && array[mid+1] == k){//如果后一个数字也是k,则说明最后一个k在后面,继续在后半段查找k
start = mid+1;
}else{
return mid;
}
mid = (start + end) >> 1;
}
return -1;
/*递归方法
if(start > end){
return -1;
}
int length = array.length;
int mid = (start + end) >> 1;
if(array[mid]<k){
return getLastK(array,k,mid+1,end);
}else if(array[mid]>k){
return getLastK(array,k,start,mid-1);
}else if(mid+1<length&&array[mid+1]==k){
return getLastK(array,k,mid+1,end);
}else{
return mid;
}*/
}
}
四.
五.
找到数组中第一个重复的数字
/**
*
*/
/**
* @author zsy
*
*/
package study;
public class Solution {
public static int duplicate(int numbers[],int length,int [] duplication) {
if(numbers==null||length<=1)
return -1;
for(int i=0;i<length;i++){
while(numbers[i]!=i){
if(numbers[i]==numbers[numbers[i]]){
duplication[0]=numbers[i];
return duplication[0];
}else{
int temp=numbers[i];
numbers[i]=numbers[temp];
numbers[temp]=temp;
}
}
}
return -1;
}
public static void main(String[] args) {
int[] a= {2,3,1,0,2,5,3};
int length=7;
int[] arr=new int[length];
System.out.println(duplicate(a,length,arr));
}
}
六.两数之和
给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是,你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
public static int[] twoSum(int[] nums, int target) {
int[] index=new int[2];
HashMap<Integer,Integer> map=new HashMap<Integer,Integer>();
for(int i=0;i<nums.length;i++){
if(map.containsKey(nums[i])){
index[0]=map.get(nums[i]);
index[1]=i;
return index;
}else{
map.put(target-nums[i],i);
}
}
return index;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a= {2, 7, 11, 15};
int target=9;
int[] index=twoSum(a,target);
System.out.println(Arrays.toString(index));
}