数组

一.

题目描述

合并两个有序数组

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));
		}