数组常见问题大汇总

/**
 * @ClassName TestDemo
 * @Description TODO
 * @Author lmx
 * @Date 2018/10/5 15:44
 * @Version 1.0
 **/
public class TestDemo {
   /**
     * 求阶乘
     * @param n
     * @return
     */
    public static int fac(int n) {
        int sum = 1;
        for(int i = 1;i <= n;i++) {
            sum = sum*i;
        }
        return sum;
    }



    /**
     * 求1-100以内所有数的和，奇数和，偶数和
     * @param n
     */
    public static void and(int n) {
        int sum = 0,pwd = 0,der = 0;
        for(int i = 1;i <= n;i++) {
            sum = sum+i;
            if(i%2 == 0) {
                pwd = pwd+i;
            }else {
                der = der+i;
            }
        }
        System.out.println("所有数的和"+sum);
        System.out.println("偶数的和"+pwd);
        System.out.println("奇数的和"+der);
    }



    /**
     * 求前n个数的和
     * @param n
     */
    public static int sum(int n) {
        int top = 0;
        for(int i = 1;i <= n;i++) {
            top = top+i;
        }
        return top;
    }

    /**
     * 打印九九乘法表
     * @param n
     */
    public static void chart(int n) {
        Scanner scanner = new Scanner((System.in));
        for (int i = 1; i <= n; i++) { //纵
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + i * j + "  ");
            }
            System.out.println();
        }
    }

    /**
     * 求三个数的最大值
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static int maxThree(int a,int b,int c) {
        return max(max(a,b),c);
    }
    
    /**
     * 求两个数的最大值
     * @param a
     * @param b
     * @return
     */
    public static int max(int a, int b) {
        return a > b ? a : b;
    }

    /**
     * 判断一个数是否是素数
     * @param n
     * @return
     */
    public static boolean isPrime(int n) {
        if(n == 1) {
            return false;
        }
            for (int j = 2; j < n; j++) {
                if (n%j == 0) {    //只能被1和本身整除，不能被这之间的其他任何数整除
                    return false;
                }
            }
            return true;
    }

    /**
     * 判断闰年
     * @param year
     * @return
     */
    public static boolean loopYear(int year) {
        if(year%4 == 0 && year%100 == 0 || year%400 == 0) {
            return true;
        }
        return false;
    }

    /**
     * 查询成绩
     * @param ch
     */
    public static void grade(char ch) {
        switch (ch) {
            case 'A':
                System.out.println("成绩在80-100");
                break;
            case 'B':
                System.out.println("成绩在70-80");
                break;
            case 'C':
                System.out.println("成绩在60-70");
                break;
            case 'D':
                System.out.println("成绩在60-70");
                break;
                default:
                    System.out.println("不及格");
        }
    }


    /**
     * 递归求斐波那契
     * @param n
     * @return
     */
    public static int fibonacci(int n) {
        if(n == 1 || n == 2) {
            return 1;
        }
        return fibonacci(n-1)+fibonacci(n-2);
    }

    /**
     * 求斐波那契数的前n项和
     * @param n
     * @return
     */
    public static int summation(int n) {
        int num = 0;
        for(int i = 1;i < n+1;i++) {
            num = num+fibonacci(i);
        }
        return num;
    }

    /**
     * 产生20个随机数（大小10~20）
     */
    public static void random() {
        for(int i = 0;i < 20;i++) {
            Random ran = new Random();
            int x = ran.nextInt(20)+10;
            System.out.print(x+" ");
        }
    }

    /**
     * 输入一个数字求他是几位数，顺序输出，逆序输出
     */
    public static void judge() {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        String str = Integer.toString(n);
        System.out.println("它是一个"+str.length()+" 位数");
        System.out.println("顺序输出"+str);
        System.out.println("逆序输出"+reverseOutput(str));
    }

    /**
     * 逆置一个字符串
     * @param str
     * @return
     */
    public static String reverseOutput(String str) {
        char[] ch = str.toCharArray();
            char sum = 'a';
            int n = str.length()-1;
            for(int i = 0;i < n/2;i++) {
                sum = ch[n-i];
                ch[n-i] = ch[i];
            ch[i] = sum;
        }
        return String.valueOf(ch);
    }

    /**
     * 判断一个数的二进制数有几个1
     * @param n
     * @return
     */
    public static int count(int n){
        int res = 0;
        while(n != 0){
            n &= (n-1);
            res++;
        }
        return res;
    }

   /**
     * 找出数组中的第二大数
     * @param array
     * @return
     */
    public static int twomax(int[] array) {
        int max = array[0];
        int maxtwo = Integer.MIN_VALUE;
        for(int i = 1;i <  array.length;i++) {
            if(array[i] > max) {
                maxtwo = max;
                max = array[i];
            }else {
                if(array[i] > maxtwo) {
                    maxtwo = array[i];
                }
            }
        }
        return maxtwo;
    }

    /**
     * 求1~n内偶数和奇数和
     * @param n
     */
    public static void sum(int n) {
        int sum = 0;
        int i = 0;
        int cur = 0;
        int j = 1;
        do {
            sum = sum+i;
            i = i+2;
        }while(i <= n);
        do {
            cur = cur+j;
            j = j+2;
        }while(j <= n);
        System.out.println("偶数和"+sum);
        System.out.println("奇数和"+cur);
    }

    /**
     * break
     */
    public static void show() {
        int tmp = 0;
        for(int i = 1;;i++) {
            tmp = tmp+i;
            if(tmp >= 1000) {
                System.out.println(i);
                break;
            }
        }
    }

    /**
     * 求1~n内既能被3整除又能被5整除
     * @param n
     */
    public static void fun(int n) {
        for(int i = 1;i <= n;i++) {
            if(i%3 == 0 && i%5 == 0) {
                System.out.print(i+" ");
            }else {
                continue;
            }
        }
        System.out.println();
    }

    /**
     * 输出斐波那契数组
     * @param array
     */
    public static int[] fabonacio(int[] array) {
        array[0] = 1;
        if(array.length <= 1) {
            return array;
        }
        array[1] = 1;
        if(array.length <= 2) {
            return array;
        }
        for(int i = 2;i < array.length;i++) {
            array[i] = array[i-1]+array[i-2];
        }
       return array;
    }

    /**
     * 输出斐波那契数组
     * @param array
     */
    public static void fabonacio1(int[] array) {
        for(int i = 0;i < array.length;i++) {
            array[i] = fibonacci(i+1);
        }
        System.out.println(Arrays.toString(array));
    }

    /**
     * 递归求斐波那契
     * @param n
     * @return
     */
    public static int fibonacci(int n) {
        if(n == 1 || n == 2) {
            return 1;
        }
        return fibonacci(n-1)+fibonacci(n-2);
    }

    /**
     * 实现二分查找算法：有序的数组
     * @param array
     * @param key
     * @return 找到返回下标，没有找到-1
     */
    public static int binary(int[] array,int key) {
        Arrays.sort(array);
        int length = array.length;
        int low = 0;
        int mid = 0;
        int high = length-1;
        for(int i = 0;low <= high;i++){
            mid = (low+high)/2;      //low+(high-low)/2;
            if(key < array[mid]) {
                high = mid-1;
            }else if(key > array[mid]) {
                low = mid+1;
            }else {
                return mid;
            }
        }
        return -1;
    }


    /**
     * 逆置数组
     * @param array
     * @return
     */
    public static int[] inversion(int[] array) {
        int length = array.length;
        int tmp = 0;
        for(int i = 0;i < length/2;i++) {
            tmp = array[i];
            array[i] = array[length-1-i];
            array[length-i-1] = tmp;
        }
        return array;
    }

    /**
     * 交换两个数的值
     * @param a
     * @param b
     */
    public static void swop(int a,int b) {
        int tmp = 0;
        tmp = a;
        a = b;
        b = tmp;
    }

    /**
     * 求连续子数组的最大和
     * @param array
     * @return
     */
    public static int maxArray(int[] array) {
        int length = array.length;
        int max = Integer.MIN_VALUE;  //0x80000000
        int i = 0,j = 0;
        int tim = 0,pwd = 0;
        for(i = 0;i < length;i++) {
            int sum = 0;
            for(j = i;j < length;j++) {
                sum += array[j];
                if(sum > max) {
                    tim = i;
                    pwd = j;
                    max = sum;
                }
            }
        }
        System.out.println("最大子数组： ");
        while(tim <= pwd) {
            System.out.print(array[tim]+" ");
            tim++;
        }
        System.out.println();
        return max;
    }

    /**
     * 求最大值
     * @param m
     * @param n
     * @return
     */
    public static int max(int m,int n) {
        return m > n ? m : n;
    }

    /**
     * 动态规划求最长公共子序列
     * @param array
     * @return
     */
    public static int new_maxArray(int[] array) {
        int length = array.length;
        int maxAll = array[0];
        int maxEnd = array[0];
        int start = 0;   //记录最大和子数组的起始下标
        int end = 0;    //记录最大和子数组的结束下标
        for(int i = 0;i < length;i++) {
            maxEnd = max(maxEnd+array[i],array[i]);
            if(maxEnd == array[i]) {  //如果maxEnd == array[i],那就意味着最大和子数组的起始位置换了
                start = i;
            }
            maxAll = max(maxEnd,maxAll);
            if(maxAll == maxEnd) {   //后面有图解析
                end = i;
            }
        }

        System.out.println("最大和子数组");
        while(start <= end) {
            System.out.print(array[start]+" ");
            start++;
        }
        System.out.println();
        return maxAll;
    }

 /**
     * 找出数组出现次数最多的元素
     * @param array
     * @return
     */
    public static int findArray(int[] array) {
        int[] count = new int[max(array)[0]+1];  //因为后面要用到count[max(array)]，不加1会数组越界
        Arrays.fill(count,0);    //数组全部填充为0
        for(int i = 0;i < array.length;i++) {
            count[array[i]] = count[array[i]]+1;  //下标代表相应的array数组元素，值代表array元素出现次数
        }
        return max(count)[1];
    }

    /**
     * 找出数组元素最大值，并返回最大值和下标
     * @param array
     * @return
     */
    public static int[] max(int[] array) {
        int[] cur = new int[2];
        int max = 0,x = 0;
        for (int i = 0;i < array.length;i++) {
            if(array[i] > max) {
                max = array[i];
                x = i;
            }
        }
        cur[0] = max;
        cur[1] = x;
        return cur;
    }

    /**
     * 找出数组中重复次数最多的那个数，以及它的重复次数
     * @param array
     * @return
     */
    public static int[] findMaxArray(int[] array) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0;i < array.length;i++) {
            if(map.containsKey(array[i])) {
                map.put(array[i],map.get(array[i])+1);
            }else {
                map.put(array[i],1);
            }
        }

        int max = 0,x = 0;
        int cur[] = new int[2];
        Iterator iterator = map.entrySet().iterator();
        while(iterator.hasNext()) {
            Map.Entry entry = (Map.Entry)iterator.next();
            int key = (Integer) entry.getKey();
            int value = (Integer)entry.getValue();
            if(value > max) {
                max = value;
                x = key;
            }
         }
         cur[1] = max;
         cur[0] = x;
         return cur;
    }

    /**
     * 找出数组中重复的数
     * @param array1
     * @param array2
     * @return
     */
    public static ArrayList<Integer> intersection(int[] array1,int[] array2) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        Map<Integer,Integer> hashmap = new HashMap<Integer,Integer>();
        for(int i = 0;i < array1.length;i++) {
            hashmap.put(array1[i],1);
        }
        for(int i = 0;i < array2.length;i++) {
            if(hashmap.containsKey(array2[i])) {
                arrayList.add(array2[i]);
            }
        }
        return arrayList;
    }

    /**
     * 打印ArrayList
     * @param arraylist
     */
    public static void show(ArrayList<Integer> arraylist) {
        Iterator<Integer> iterator = arraylist.iterator();
        while(iterator.hasNext()) {
            int x = iterator.next();
            System.out.print(x+" ");
        }
        System.out.println();
    }

    /**
     * 逆置数组
     * @param array
     * @param a
     * @param b
     */
    public  static void reverse(int[] array,int a,int b) {
        int tmp = 0;
        for(;a < b;a++,b--) {
            tmp = array[a];
            array[a] = array[b];
            array[b] = tmp;
        }
    }

    /**
     * 循环向右移数组k位
     * @param array
     * @param k
     */
    public static void shift_k(int[] array,int k) {
        int n = array.length;
        k = k % n;
        reverse(array,0,n-k-1);
        reverse(array,n-k,n-1);
        reverse(array,0,n-1);
    }

    /**
     * 找出数组中只出现一次的数
     * @param array
     * @return
     */
    public static ArrayList<Integer> one_number(int[] array) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        Map<Integer,Integer> hashmap = new HashMap<>();
        for(int i = 0;i < array.length;i++) {
            if(hashmap.containsKey(array[i])) {
                hashmap.put(array[i],hashmap.get(array[i])+1);
            }else {
                hashmap.put(array[i],1);
            }
        }
        Iterator<Map.Entry<Integer,Integer>> iterator = hashmap.entrySet().iterator();
        while(iterator.hasNext()) {
            Map.Entry<Integer,Integer> next = iterator.next();
            Integer key = next.getKey();
            Integer value = next.getValue();
            if(value == 1) {
                arrayList.add(key);
            }
        }

        return arrayList;
    }

    public static int max(int a,int b) {
        return a > b ? a : b;
    }

    /**
     * 递归求数组中的最大元素
     * @param array
     * @param begin
     * @return
     */
    public static int max_number(int[] array,int begin) {
        int length = array.length - begin;
        if(length == 1) {
            return array[begin];
        }else {
            return max(array[begin],max_number(array,begin+1));
        }
    }

/**
 * @ClassName TestDemo1
 * @Description 作业
 * @Author lzq
 * @Date 2018/4/20 13:00
 * @Version 1.0
 **/
public class TestDemo1 {
    /**
     * 交换数组两元素的位置
     * @param array
     * @param a
     * @param b
     */
    public static void swap(int[] array,int a,int b) {
        int tmp = array[a];
        array[a] = array[b];
        array[b] = tmp;
    }

    /**
     * 将数组奇数放在偶数前面 大小顺序不要求
     * @param array
     * @return
     */
    public static int[] oddInFront(int[] array) {
        if(array == null || array.length == 0) {
            return null;
        }
        int m = 0;
        int n = 0;
        for(int i = 0;i < array.length;i++) {
            if(array[i] % 2 == 0) {
                n++;
            }else {
                swap(array,m,n);
                m++;
                n++;
            }
        }
        return array;
    }


    /**
     * 一个数组是有序的，给定一个key，数字里面有两个数字的和等于这个key，
     * 找到这两个数字的下标时间复杂度最小
     * @param array
     * @param key
     * @return
     */
    public static int[] findSumKey(int[] array,int key) {
        if(array == null || array.length == 0) {
            return null;
        }
      Arrays.sort(array);
      int start = 0;
      int end = array.length-1;
      for(int i = 0;i < array.length;i++) {
          if(array[start] + array[end] < key) {
              start++;
          }else if(array[start] + array[end] > key) {
              end--;
          }else {
              return new int[] {array[start],array[end]};
          }
      }
      return new int[] {-1,-1};
    }

    /**
     * 一个数组是有序的，给定一个key，数字里面有两个数字的和等于这个key，
     * 找到这两个数字的下标时间复杂度最小
     * @param array
     * @return
     */
    public static int[] findNumber1(int[] array) {
        if(array == null || array.length == 0) {
            return null;
        }
        int tmp = 0;
        for(int i = 0;i < array.length;i++) {
            tmp ^= array[i];
        }

        tmp &= -tmp;

        int a = 0,b = 0;

        for(int i = 0;i < array.length;i++) {
            if((array[i] & tmp) == 0) {
                a ^= array[i];
            }else {
                b ^= array[i];
            }
        }
        return new int[] {a,b};
    }

    /**
     * 一个整形数组，除了两个数字只出现一次以外，其他都出现了两次，找到这两个数字
     * @param array
     * @return
     */
    public static int[] findNumber(int[] array) {
        Map<Integer,Integer> hashMap = new HashMap<>();
        for(int i = 0;i < array.length;i++) {
            if(! hashMap.containsKey(array[i])) {
                hashMap.put(array[i],1);  //第一次添加，每个元素都只出现一次
            }else {
                hashMap.put(array[i],hashMap.get(array[i])+1); //后面添加再遇到这个元素，出现次数+1
            }
        }

        ArrayList<Integer> arrayList = new ArrayList<>();

        Iterator<Map.Entry<Integer,Integer>> iterator = hashMap.entrySet().iterator();
        while(iterator.hasNext()) {
            Map.Entry<Integer,Integer> next = iterator.next();
            Integer key = next.getKey();
            Integer value = next.getValue();
            if(value == 1) {  //元素只出现一次
               arrayList.add(key);
            }
        }

        Iterator<Integer> iterator1 = arrayList.iterator();
        int[] array1 = new int[2];
        int i = 0;
        while(iterator1.hasNext()) {
            Integer next = iterator1.next();
            array1[i] = next;
            i++;
        }

        return array1;
    }

    /**
     * 排序数组并插入某个元素
     * @param array
     * @param key
     */
    public static int[] sotr1(int[] array,int key,int index) {
        if (array == null || array.length == 0 || index < 0 || index >= array.length) {
            return new int[] {-1,-1};
        }
        int[] brray = new int[array.length+1];
        System.arraycopy(array,0,brray,0,index);
        brray[index] = key;
        System.arraycopy(array,index,brray,index+1,array.length-index);
        return brray;
    }

    /**
     * 排序数组并插入某个元素
     * @param array
     * @param key
     */
    public static int[] sotr(int[] array,int key) {
        if(array == null || array.length == 0) {
            return null;
        }
        Arrays.sort(array);

        array = Arrays.copyOf(array,array.length+1);

        if(key <= array[0]) {
            shift(array,key,0);
            return array;
        }

        if(key >= array[array.length-2]) {
            shift(array,key,array.length-1);
            return array;
        }

        for (int i = 0; i < array.length; i++) {
            if (array[i] < key && key <= array[i + 1]) {
                shift(array, key, i + 1);
                return array;
            }
        }

        return array;
    }

    /**
     * 向前移动数组
     * @param array
     * @param key
     * @param start
     */
    public static void shift(int[] array,int key,int start) {
        for(int i = array.length-1;i > start;i--) {
            array[i] = array[i-1];
        }
        array[start] = key;
    }

    /**
     * 找出数组中的最大值和最小值
     * @param array
     * @return
     */
    public static String[] findMinMax(int[] array) {
        if(array == null || array.length == 0) {
            return null;
        }
        int min = array[0];
        int max = array[0];
        for(int i = 0;i < array.length;i++) {
            if(array[i] < min) {
                min = array[i];
            }
            if(array[i] > max) {
                max = array[i];
            }
        }
        return new String[] {"最小值："+min,"最大值："+max};
    }

    /**
     * 合并两个两个数组
     * @param array1
     * @param array2
     * @return
     */
    public static int[] merge(int[] array1,int[] array2) {
        if(array1 == null || array1.length == 0) {
            return array2;
        }
        if(array2 == null || array2.length == 0) {
            return array1;
        }

        int m = array2.length;
        int length = array1.length+array2.length;
        array2 = Arrays.copyOf(array2,length);
        System.arraycopy(array1,0,array2,m,array1.length);
        Arrays.sort(array2);
        return array2;
    }

    /**
     * 填充数组,全部填充
     * @param array
     * @param k
     * @return
     */
    public static int[] fillArray(int[] array,int k) {
        if(array == null || array.length == 0) {
            return null;
        }
        Arrays.fill(array,k);
        return array;
     }

    /**
     * 填充数组,部分填充
     * @param array
     * @param k
     * @return
     */
    public static int[] fillArray(int[] array,int start,int end,int k) {
        if(array == null || array.length == 0 || start < 0 || end < 0 || start < end) {
            return null;
        }
        Arrays.fill(array,start,end,k);
        return array;
    }

    /**
     * 删除数组中指定元素
     * @param array
     * @param key
     */
    public static int[] remove(int[] array,int key) {
        if(array == null || array.length == 0) {
            return null;
        }

        int m = findKey(array,key);

        if(m == -1) {
            return null;
        }

        for(int i = m;i < array.length;i++) {
            if(i == array.length-1) {
                break;
            }
            array[i] = array[i+1];
        }

        array = Arrays.copyOf(array,array.length-1);

        return array;

    }

    /**
     * 删除数组中指定位置的元素
     * @param array
     * @param index
     * @return
     */
    public static int[] delteKey(int[] array,int index) {
        if(array == null || array.length == 0 || index < 0 || index >= array.length) {
            return null;
        }
        for(int i = index;i < array.length;i++) {
            if(i == array.length-1) {
                break;
            }
            array[i] = array[i+1];
        }
        array[array.length-1] = -1;
        return array;
    }

    /**
     * 从数组中查找元素
     * @param array
     * @param key
     * @return
     */
    public static int findKey(int[] array,int key) {
        for(int i = 0;i < array.length;i++) {
            if(array[i] == key) {
                return i;
            }
        }
        return -1;
    }


    /**
     * 一个整形数组，除了两个数字只出现一次以外，其他都出现了两次，找到这两个数字
     * @param array
     * @return
     */
    public static int[] findNumApperOnce(int[] array) {
        int tmp = 0;
        for(int i = 0;i < array.length;i++) {
            tmp ^= array[i]; //得到的是数组中那两个不同元素异或的结果
        }

        int x = 0;
        //判断两个数异或结果的二进制数从右往左数第几位是1
        while((tmp & 1) == 0 && x <= 32) {
            tmp >>= 1;
            x++;
        }

        int a = 0,b = 0;
        for(int i = 0;i < array.length;i++) {
            if(isOne(array[i],x)) {
                a ^= array[i]; //将二进制数从右往左数的第x位为1的一组数异或，得到一个结果
            }else {
                b ^= array[i];  //将二进制数从右往左数的第x位为0的一组数异或，得到一个结果
            }
        }
        return new int[] {a,b}; //返回的这两个数，就是数组中两个只出现一次的元素

    }


    /**
     * 判断当前数组元素的第index位是否为0
     * @param number
     * @param index
     * @return
     */
    public static boolean isOne(int number,int index) {
        number = number >> index;
        if((number & 1) != 0) {
            return true;
        }else {
            return false;
        }
    }

   /**
     * 求数组中两个元素的最小距离
     * @param array
     * @param a
     * @param b
     * @return
     */
    public static int minDistance(int[] array,int a,int b) {
        if(array == null || array.length == 0) {
            return -1;
        }

        if (findKey(array, a) == -1 || findKey(array, b) == -1) {
            return  -1;
        }

        int a_index = -1;
        int b_index = -1;
        int min_dist = Integer.MAX_VALUE;

        for(int i = 0;i < array.length;i++) {
            if(array[i] == a) {
                a_index = i;
                if(b_index >= 0) {
                    min_dist = min(Math.abs(min_dist),Math.abs(b_index-a_index));
                }
            }
            if(array[i] == b) {
                b_index = i;
                if(a_index >= 0) {
                    min_dist = min(Math.abs(min_dist),Math.abs(b_index-a_index));
                }
            }
        }
        return min_dist;
    }

    public static int min(int a,int b) {
        return a < b ? a : b;
    }

    /**
     * 从数组中查找元素
     * @param array
     * @param key
     * @return
     */
    public static int findKey(int[] array,int key) {
        for(int i = 0;i < array.length;i++) {
            if(array[i] == key) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 消除嵌套的括号
     * @param s
     * @return
     */
    public static StringBuffer clear_bracket(String s) {
        if(s == null) {
            return null;
        }
        char[] ch = s.toCharArray();
        int num = 0,i = 0;
        StringBuffer str = new StringBuffer();
        str.append("(");

        while(i < s.length()) {
            if(ch[i] == '(') {
                num++;
                i++;
                continue;
            }else if(ch[i] == ')') {
                if(num > 0) {
                    num--;
                    i++;
                    continue;
                }else {
                    System.out.println("表达式错误");
                    return null;
                }
            }


            if(ch[i] == ',') {
                str.append(ch[i]);
                i++;
                continue;
            }else if(ch[i] >= '0' && ch[i] <= '9') {
                str.append(ch[i]);
                i++;
                continue;
            }else {
                System.out.println("字符不合法");
                return null;
            }
        }


       if(num != 0) {
           System.out.println("表达式错误");
           return null;
       }
       return str.append(')');
    }
}
/**
 * @ClassName TestDemo1
 * @Description 作业
 * @Author lmx
 * @Date 2018/10/08 13:00
 * @Version 1.0
 **/
public class TestDemo1 {
    /**
     * 交换数组两元素的位置
     * @param array
     * @param a
     * @param b
     */
    public static void swap(int[] array,int a,int b) {
        int tmp = array[a];
        array[a] = array[b];
        array[b] = tmp;
    }

    /**
     * 将数组奇数放在偶数前面 大小顺序不要求
     * @param array
     * @return
     */
    public static int[] oddInFront(int[] array) {
        if(array == null || array.length == 0) {
            return null;
        }
        int m = 0;
        int n = 0;
        for(int i = 0;i < array.length;i++) {
            if(array[i] % 2 == 0) {
                n++;
            }else {
                swap(array,m,n);
                m++;
                n++;
            }
        }
        return array;
    }


    /**
     * 一个数组是有序的，给定一个key，数字里面有两个数字的和等于这个key，
     * 找到这两个数字的下标时间复杂度最小
     * @param array
     * @param key
     * @return
     */
    public static int[] findSumKey(int[] array,int key) {
        if(array == null || array.length == 0) {
            return null;
        }
      Arrays.sort(array);
      int start = 0;
      int end = array.length-1;
      for(int i = 0;i < array.length;i++) {
          if(array[start] + array[end] < key) {
              start++;
          }else if(array[start] + array[end] > key) {
              end--;
          }else {
              return new int[] {array[start],array[end]};
          }
      }
      return new int[] {-1,-1};
    }

    /**
     * 一个数组是有序的，给定一个key，数字里面有两个数字的和等于这个key，
     * 找到这两个数字的下标时间复杂度最小
     * @param array
     * @return
     */
    public static int[] findNumber1(int[] array) {
        if(array == null || array.length == 0) {
            return null;
        }
        int tmp = 0;
        for(int i = 0;i < array.length;i++) {
            tmp ^= array[i];
        }

        tmp &= -tmp;

        int a = 0,b = 0;

        for(int i = 0;i < array.length;i++) {
            if((array[i] & tmp) == 0) {
                a ^= array[i];
            }else {
                b ^= array[i];
            }
        }
        return new int[] {a,b};
    }

    /**
     * 一个整形数组，除了两个数字只出现一次以外，其他都出现了两次，找到这两个数字
     * @param array
     * @return
     */
    public static int[] findNumber(int[] array) {
        Map<Integer,Integer> hashMap = new HashMap<>();
        for(int i = 0;i < array.length;i++) {
            if(! hashMap.containsKey(array[i])) {
                hashMap.put(array[i],1);  //第一次添加，每个元素都只出现一次
            }else {
                hashMap.put(array[i],hashMap.get(array[i])+1); //后面添加再遇到这个元素，出现次数+1
            }
        }

        ArrayList<Integer> arrayList = new ArrayList<>();

        Iterator<Map.Entry<Integer,Integer>> iterator = hashMap.entrySet().iterator();
        while(iterator.hasNext()) {
            Map.Entry<Integer,Integer> next = iterator.next();
            Integer key = next.getKey();
            Integer value = next.getValue();
            if(value == 1) {  //元素只出现一次
               arrayList.add(key);
            }
        }

        Iterator<Integer> iterator1 = arrayList.iterator();
        int[] array1 = new int[2];
        int i = 0;
        while(iterator1.hasNext()) {
            Integer next = iterator1.next();
            array1[i] = next;
            i++;
        }

        return array1;
    }

    /**
     * 排序数组并插入某个元素
     * @param array
     * @param key
     */
    public static int[] sotr1(int[] array,int key,int index) {
        if (array == null || array.length == 0 || index < 0 || index >= array.length) {
            return new int[] {-1,-1};
        }
        int[] brray = new int[array.length+1];
        System.arraycopy(array,0,brray,0,index);
        brray[index] = key;
        System.arraycopy(array,index,brray,index+1,array.length-index);
        return brray;
    }

    /**
     * 排序数组并插入某个元素
     * @param array
     * @param key
     */
    public static int[] sotr(int[] array,int key) {
        if(array == null || array.length == 0) {
            return null;
        }
        Arrays.sort(array);

        array = Arrays.copyOf(array,array.length+1);

        if(key <= array[0]) {
            shift(array,key,0);
            return array;
        }

        if(key >= array[array.length-2]) {
            shift(array,key,array.length-1);
            return array;
        }

        for (int i = 0; i < array.length; i++) {
            if (array[i] < key && key <= array[i + 1]) {
                shift(array, key, i + 1);
                return array;
            }
        }

        return array;
    }

    /**
     * 向前移动数组
     * @param array
     * @param key
     * @param start
     */
    public static void shift(int[] array,int key,int start) {
        for(int i = array.length-1;i > start;i--) {
            array[i] = array[i-1];
        }
        array[start] = key;
    }

    /**
     * 找出数组中的最大值和最小值
     * @param array
     * @return
     */
    public static String[] findMinMax(int[] array) {
        if(array == null || array.length == 0) {
            return null;
        }
        int min = array[0];
        int max = array[0];
        for(int i = 0;i < array.length;i++) {
            if(array[i] < min) {
                min = array[i];
            }
            if(array[i] > max) {
                max = array[i];
            }
        }
        return new String[] {"最小值："+min,"最大值："+max};
    }

    /**
     * 合并两个两个数组
     * @param array1
     * @param array2
     * @return
     */
    public static int[] merge(int[] array1,int[] array2) {
        if(array1 == null || array1.length == 0) {
            return array2;
        }
        if(array2 == null || array2.length == 0) {
            return array1;
        }

        int m = array2.length;
        int length = array1.length+array2.length;
        array2 = Arrays.copyOf(array2,length);
        System.arraycopy(array1,0,array2,m,array1.length);
        Arrays.sort(array2);
        return array2;
    }

    /**
     * 填充数组,全部填充
     * @param array
     * @param k
     * @return
     */
    public static int[] fillArray(int[] array,int k) {
        if(array == null || array.length == 0) {
            return null;
        }
        Arrays.fill(array,k);
        return array;
     }

    /**
     * 填充数组,部分填充
     * @param array
     * @param k
     * @return
     */
    public static int[] fillArray(int[] array,int start,int end,int k) {
        if(array == null || array.length == 0 || start < 0 || end < 0 || start < end) {
            return null;
        }
        Arrays.fill(array,start,end,k);
        return array;
    }

    /**
     * 删除数组中指定元素
     * @param array
     * @param key
     */
    public static int[] remove(int[] array,int key) {
        if(array == null || array.length == 0) {
            return null;
        }

        int m = findKey(array,key);

        if(m == -1) {
            return null;
        }

        for(int i = m;i < array.length;i++) {
            if(i == array.length-1) {
                break;
            }
            array[i] = array[i+1];
        }

        array = Arrays.copyOf(array,array.length-1);

        return array;

    }

    /**
     * 删除数组中指定位置的元素
     * @param array
     * @param index
     * @return
     */
    public static int[] delteKey(int[] array,int index) {
        if(array == null || array.length == 0 || index < 0 || index >= array.length) {
            return null;
        }
        for(int i = index;i < array.length;i++) {
            if(i == array.length-1) {
                break;
            }
            array[i] = array[i+1];
        }
        array[array.length-1] = -1;
        return array;
    }

    /**
     * 从数组中查找元素
     * @param array
     * @param key
     * @return
     */
    public static int findKey(int[] array,int key) {
        for(int i = 0;i < array.length;i++) {
            if(array[i] == key) {
                return i;
            }
        }
        return -1;
    }


    /**
     * 一个整形数组，除了两个数字只出现一次以外，其他都出现了两次，找到这两个数字
     * @param array
     * @return
     */
    public static int[] findNumApperOnce(int[] array) {
        int tmp = 0;
        for(int i = 0;i < array.length;i++) {
            tmp ^= array[i]; //得到的是数组中那两个不同元素异或的结果
        }

        int x = 0;
        //判断两个数异或结果的二进制数从右往左数第几位是1
        while((tmp & 1) == 0 && x <= 32) {
            tmp >>= 1;
            x++;
        }

        int a = 0,b = 0;
        for(int i = 0;i < array.length;i++) {
            if(isOne(array[i],x)) {
                a ^= array[i]; //将二进制数从右往左数的第x位为1的一组数异或，得到一个结果
            }else {
                b ^= array[i];  //将二进制数从右往左数的第x位为0的一组数异或，得到一个结果
            }
        }
        return new int[] {a,b}; //返回的这两个数，就是数组中两个只出现一次的元素

    }


    /**
     * 判断当前数组元素的第index位是否为0
     * @param number
     * @param index
     * @return
     */
    public static boolean isOne(int number,int index) {
        number = number >> index;
        if((number & 1) != 0) {
            return true;
        }else {
            return false;
        }
    }

   /**
     * 求数组中两个元素的最小距离
     * @param array
     * @param a
     * @param b
     * @return
     */
    public static int minDistance(int[] array,int a,int b) {
        if(array == null || array.length == 0) {
            return -1;
        }

        if (findKey(array, a) == -1 || findKey(array, b) == -1) {
            return  -1;
        }

        int a_index = -1;
        int b_index = -1;
        int min_dist = Integer.MAX_VALUE;

        for(int i = 0;i < array.length;i++) {
            if(array[i] == a) {
                a_index = i;
                if(b_index >= 0) {
                    min_dist = min(Math.abs(min_dist),Math.abs(b_index-a_index));
                }
            }
            if(array[i] == b) {
                b_index = i;
                if(a_index >= 0) {
                    min_dist = min(Math.abs(min_dist),Math.abs(b_index-a_index));
                }
            }
        }
        return min_dist;
    }

    public static int min(int a,int b) {
        return a < b ? a : b;
    }

    /**
     * 从数组中查找元素
     * @param array
     * @param key
     * @return
     */
    public static int findKey(int[] array,int key) {
        for(int i = 0;i < array.length;i++) {
            if(array[i] == key) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 消除嵌套的括号
     * @param s
     * @return
     */
    public static StringBuffer clear_bracket(String s) {
        if(s == null) {
            return null;
        }
        char[] ch = s.toCharArray();
        int num = 0,i = 0;
        StringBuffer str = new StringBuffer();
        str.append("(");

        while(i < s.length()) {
            if(ch[i] == '(') {
                num++;
                i++;
                continue;
            }else if(ch[i] == ')') {
                if(num > 0) {
                    num--;
                    i++;
                    continue;
                }else {
                    System.out.println("表达式错误");
                    return null;
                }
            }


            if(ch[i] == ',') {
                str.append(ch[i]);
                i++;
                continue;
            }else if(ch[i] >= '0' && ch[i] <= '9') {
                str.append(ch[i]);
                i++;
                continue;
            }else {
                System.out.println("字符不合法");
                return null;
            }
        }


       if(num != 0) {
           System.out.println("表达式错误");
           return null;
       }
       return str.append(')');
    }
}

public static void main(String[] args) {
        //把空格替换为“%20”  这个Java有自己的方法：
        //字符替换    replace();
        //字符串替换  replaceAll();  
        String str = "ad degrt jyh ";
		System.out.println(str.replaceAll(" ", "%20"));
		System.out.println(str.replace('d', 'f'));
        //把多余的空格进行省略
        String str = "ad      degrt    jyh ";
		System.out.println(str.replaceAll(" {2,}", " "));

	}