java算法-Array

1、给定一个数组nums和值val,删除数组中等于val的数组，返回剩余元素个数

    public static int run02(int[] arrayData, int val) {
        int endSit = arrayData.length - 1;
        for (int i = 0; i < arrayData.length; i++) {
            if (i >= endSit) {
                //删除多余元素
                arrayData = Arrays.copyOfRange(arrayData, 0, endSit);
                return endSit;
            }
            if (arrayData[i] == val) {
                for (int j = endSit; j > i; j--) {
                    if (arrayData[j] != val) {
                        endSit = j;
                        break;
                    }
                }
                if (arrayData[endSit] == val) {
                    //删除多余元素
                    arrayData = Arrays.copyOfRange(arrayData, 0, endSit);
                    return endSit;
                }
                int zero = arrayData[i];
                arrayData[i] = arrayData[endSit];
                arrayData[endSit] = zero;
            }
        }
        //删除多余元素
        arrayData = Arrays.copyOfRange(arrayData, 0, endSit);
        return endSit;
    }

2、给定一个数组，给素组中元素去重，每个元素最多保留val个，返回去重后的数组长度

指针：指定不需要元素最小位置，找到一个需要元素就与其交换

    public static int run03(int[] arrayData, int val) {
        //由小到大排序
        Arrays.sort(arrayData);
        int repeat = 0;
        int valueNum = 0;
        int value = arrayData[0];
        for(int i = 0;i < arrayData.length -1;i++){

            if(arrayData[i] == value){
                if(valueNum < val){
                    valueNum ++;
                    arrayDataHuan(arrayData,repeat,i);
                    repeat ++;
                }
            }else {
                valueNum = 1;
                value = arrayData[i];
                arrayDataHuan(arrayData,repeat,i);
                repeat ++;
            }
        }
        arrayData = Arrays.copyOfRange(arrayData, 0, repeat);
        return repeat;
    }

3、给一个数组，长度不限，元素在0-2之间，排序（三路快排）

    public static void run04(int[] arrayData) {
        int sit1 = -1;
        int sit2 = -1;
        if(arrayData.length <= 1){
            return;
        }else if(arrayData.length <= 2){
            if(arrayData[1] < arrayData[0]){
                arrayDataHuan(arrayData,0,1);
            }
            return;
        }

        for (int i = 0; i < arrayData.length; i++) {
            int num = arrayData[i];
            if(num == 0){
                if(sit2 < i && sit2 >= 0 && arrayData[i] != arrayData[sit2]){
                    arrayDataHuan(arrayData,i,sit2);
                    if(sit1 < i && sit1 >= 0 && arrayData[i] != arrayData[sit1]){
                        arrayDataHuan(arrayData,sit2,sit1);
                        sit1 ++;
                    }
                    sit2 ++;
                }else if(sit1 < i && sit1 >= 0 && arrayData[i] != arrayData[sit1]){
                    arrayDataHuan(arrayData,i,sit1);
                    sit1 ++;
                }
            }else if(num == 1){
                if(sit1 < 0){
                    sit1 = i;
                }
                if(sit2 < i && sit2 > 0 && arrayData[i] != arrayData[sit2]){
                    arrayDataHuan(arrayData,i,sit2);
                    sit2 ++;
                }
            }else if(sit2 < 0){
                sit2 = i;
            }
        }
    }

4、2个有序整型数组nums1,nums2 把nums2内容合并到nums1中去

    public static int[] run05(int[] nums1,int[] nums2){
        int[] resultArr = new int[nums1.length + nums2.length];
        int sit1 = 0;
        int sit2 = 0;
        for(int i = 0;i < resultArr.length; i++){
            if(sit1 < nums1.length && (sit2 >= nums2.length || nums1[sit1] < nums2[sit2])){
                resultArr[i] = nums1[sit1];
                sit1 ++;
            }else if(sit2 < nums2.length){
                resultArr[i] = nums2[sit2];
                sit2 ++;
            }
        }
        return resultArr;
    }

5、给定一个整型有序数组，和一个target，在集合中找到2个数子，使得他们的和是target（对撞指针）

    public static List<String> run07(int[] nums1,int target){
        List<String> returnMsg = new LinkedList<>();
        int sitStart = 0;
        int sitend = nums1.length -1;
        for(int i = 0;i < nums1.length ;i ++){
            if(sitStart >= sitend){
                return returnMsg;
            }
            int value = nums1[sitStart] + nums1[sitend];
            if(value > target){
                sitend --;
            }else if(value < target){
                sitStart ++;
            }else {
                returnMsg.add(nums1[sitStart] + "," + nums1[sitend]);
                sitStart ++;
            }
        }
        return returnMsg;
    }

6、给定一个整型数组，和一个数字k。找到，连续数字加起来>= k的最短长度的数字集合（滑动窗口）

    public static int[] run08(int[] nums1,int k){
        int sitStart = 0;
        int sitEnd = 0;
        int value = nums1[sitStart];
        int haveLength = nums1.length;
        int haveSitStart = 0;
        int haveSitEnd = 0;
        for(int i = 0;i < nums1.length * 2;i ++){
            if(sitEnd >= nums1.length){
                break;
            }
            if(value == k){
                if(sitEnd - sitStart < haveLength){
                    haveLength = sitEnd +1 - sitStart;
                    haveSitStart = sitStart;
                    haveSitEnd = sitEnd;
                }
                value -= nums1[sitStart];
                sitStart ++;
            }else if(value < k){
                sitEnd ++;
                if(sitEnd >= nums1.length){
                    break;
                }
                value += nums1[sitEnd];
            }else {
                value -= nums1[sitStart];
                sitStart ++;
            }
        }
        return Arrays.copyOfRange(nums1,haveSitStart,haveSitEnd + 1);
    }