数组常见问题大汇总

【go-libp2p学习笔记】使用go-libp2p搭建中转服务器(circuit relay server) libp2p算是一个蛮新的库,提供了非常强大的p2p节点发现/连接/通信能力。IPFS的基石。 中文网上的**技术教程**比较少,所以抛砖引玉开一点坑来体验一下! 阅读详情
/**
 * @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,}", " "));

	}

自动驾驶仿真(六)—— SIL软件在环仿真测试 自动驾驶仿真六—— SIL软件在环仿真测试1. 在环仿真测试2. SIL软件在环仿真测试2.1 模型配置参数2.2 S function生成实现2.3 结果对比3. 参考学习的书目教材 博主前面的博文已经简要介绍了Carsim、Prescan 与 Simulink 在 “V”型开发流程的一些应用,现今成熟的汽车控制系统软件都是以(Model Based Design,MBD)来开发,它以图形化的方式表达复杂的逻辑、代码可读性、可移植性、开发调试便利程度都大大增强,同时利用成熟的代码生成工具链,也避免了手工代 阅读详情

相关推荐

Cadence 17.2配置CIS数据库报错?手把手解决ODBC驱动位数不匹配问题

本文详细解析了Cadence 17.2配置CIS数据库时常见的ODBC驱动位数不匹配问题,提供了从系统环境检查到分步解决方案的完整指南。重点解决32位应用程序与64位ODBC驱动之间的架构冲突,包含驱动安装、DSN配置及高级排查技巧,帮助电子工程师快速恢复设计环境。

play7的博客 972

数组学习易错点(仅针对自己)

记录自己上课及写代码过程中遇到的数组与字符串问题

m0_73737005的博客 1955

UDS(三)网络层时间参数

网络层定义了N_Ar、N_As、N_Br、N_Bs、N_Cr、N_Cs六个时间参数。 网络层在检测到错误的时间传递至上层使用者 1.当N_As 超时时,即发送方没有及时发送出N_PDU,系统将放弃信息的接收并传递<N_Result> = <N_TIMEOUT_A>的N_USData.comfirm指示 2.当N_Ar超时时,即接收方没有及时发送出N_PDU,系统将放弃信息的接收并传递<N_Result> = <N_TIMEOUT_A>的N_USData.co

weixin_44522306的博客 1万+

数组的常见问题

1·数组的索引编号都是从0开始的,一直到“数组的长度—1”为止。 如果我们访问数组元素的时候,索引编号不存在,那么将会发生数组索引越界异常(ArrayIndexOutOfBoundsException) 原因:访问了不存在的角标。 解决办法:修改正确的索引编号。 2·所有的引用类型变量,都可以赋值为一个null值,代表数组里什么都没有。 数组必须进行new(创建对象)才能使用其中的元素。栈中的数组变量没有指向堆内存中的数组实体,那么将会发生空指针异常(NullPointerException) 原因:没有进

weixin_53026450的博客 693

[Unity Demo]从零开始制作空洞骑士Hollow Knight第四集:制作更多的敌人

大家好久不见,终于放完中秋假期可以回自己家里打代码了,上一期我介绍了为什么和如何导入2D toolkit以及制作一个完整的敌人(就是那只蚊子包括了精灵,动画,状态机行为以及脚本)现在不妨趁热打铁制作更多的敌人。

dangoxiba的博客 1976

SpringBoot+Flowable 6.8.0实战:5分钟搞定免登录流程图设计器

本文详细介绍了如何通过SpringBoot与Flowable 6.8.0深度整合,快速实现免登录流程图设计器的集成方案。通过排除默认安全配置、自定义安全策略和用户模拟服务,开发者可在5分钟内完成设计器的部署,适用于快速原型开发和企业内部工具搭建。

weixin_29204205的博客 280

Day_04

day_04 数组 1.数组 数组是引用类型,用来保存多个数据 1.1 数据结构 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下,精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关 数据操作 : 增删改查 1.2 数组特性 数组特性 : 内存中连续存储,并且下标从0开始(内存地址偏移) 数组长度一旦确定 长度不能更改,也就意...

grp_grp_grp的博客 268

Altium Designer应用技巧1: 功能模块的复用方法

Altium Designer应用技巧1: 功能模块的复用方法      我们在使用Altium Designer进行电路图设计时,常会遇到功能模块的复用问题,例如我们经常需要将12V以DC-DC的方式转换成5V,这在很多线路板上都会应用到。现在我们普通的做法是,每个板子都重新绘制一遍,像这样DC-DC的电路,很浪费时间。那么如何采用提高工作效率呢?我们可以采取Altium Desi

snmplink的博客 1万+

【C语言】--关于数组的一系列问题,看这篇就够了

在C语言中,数组是一种极为重要的数据结构,它为储存和处理多个相同类型的数据元素提供了便携而高效的方式。无论是处理简单的数值序列还是复杂的数据集合,数组都扮演着不可或缺的角色。下面,就跟博主一起来看看数组的一系列问题吧!

user340的博客 2319

AgentScope 2.0 源码解析-工具系统解读:从内置工具到权限管控的完整实践

本文深入解析AgentScope 2.0工具系统的完整架构,覆盖内置工具集(文件读写、命令执行、搜索匹配)、MCP协议集成(STDIO/HTTP双传输、客户端封装、工作空间网关)、工具包管理与动态分组、权限引擎的多级决策机制(危险路径保护、只读识别、模式控制),以及自定义工具开发流程。通过分层架构图和时序图直观展示组件协作关系,结合安全最佳实践与故障排除指南,为开发者提供从工具使用到安全管控的全链路参考。

program哲学 578

《YOLO系列模型的多模态项目》配置使用教程(必看内容)

在根目录的文件夹中用于存放的是我已经配置好的一些多模态融合模型,可结合专栏中相应的文章介绍,进一步了解测试其中内容。

Limiiiing的博客 4668

数组及常见问题

但是有两种情况下数组名取全部元素的地址:第一种为操作符sizeof,在计算空间的时候,取全部元素的地址。如果大括号中的字符个数小于字符数组的长度,则把大括号中的字符赋给数组中前面的元素,其余元素自动赋值为空字符(即‘\0’)。即:char str[6] = {'h','e','l','l','o', '\0'};第一种: char str[10] = {'h','e','l','l','o'};第二种:char str[5] = {'h','e','l','l','o'};相同,系统不会自动添加'\0'。

ztt910的博客 426

【雷达】一维和二维自适应波束形成(DBF))DBF附matlab代码

1 简介 数字波束形成技术是天线波束形成原理与数字信号处理技术相结合的产物,其广泛应用于阵列信号处理领域.由于电磁工作环境的恶化和大量射频干扰的存在,在极低的信干噪比(SINR)条件下进行目标检测和信息提取十分困难.对于阵列系统,往往采用自适应数字波束形成(ADBF)技术,来抑制强干扰和方向性干扰对有用信号的影响.介绍了数字波束形成器的基本原理及其DSP的实现结构.​ 2 完整代码 clc;clear all;close all;%%%%%%%%%%%%%%%%%一维DBF%%%%%%%%%%%%%

qq_59747472的博客 7269

Python 找出一个整数数组中,第二大的数。

问题的要求: 给你一个整形数组,找出这个数组中第二个大的数。 比如说:num_list = [98,12,45,1,2,32,90,45,23,121,11] 第二大的数是98 解决方法: 方法1: 直接排序,输出倒数第二个数即可 num_list = [98,12,45,1,2,32,90,45,23,121,11] tmp_list = sorted(num_list) print('第二...

菜鸡小白的成长记录 1万+

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

vba 定义数组_利用数组与字典,实现单个条件汇总求和

大家好,我们今天继续讲解VBA数组与字典解决方案,今日的内容是第38讲,利用数组与字典,实现单个条件的数据汇总求和。在VBA解决方案的丛书中,这套VBA数组与字典解决方案是专门讲解数组和字典的。这套书的开始先讲了EXCEL数组的利用,然后又讲了VBA数组,从上一讲开始,我们开始讲字典。讲了什么是字典,及其简单的应用,从这讲开始,我们开始讲数组和字典的各种实际利用方法,这些方案是我将多年的经验加以整...

weixin_39768917的博客 1593

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

js常见问题汇总

在JavaScript开发中,常见问题主要集中在变量与作用域、类型与比较、函数与闭包、异步与Promise、数组与对象、DOM操作等方面。例如,变量提升和块级作用域问题可以通过使用let和const解决;隐式类型转换和NaN的奇怪行为可以通过严格相等和Number.isNaN处理;this指向错误和闭包内存泄漏可以通过箭头函数和手动释放引用解决。异步编程中的回调地狱和未捕获的Promise错误可以通过Promise和async/await优化。数组和对象操作中的问题可以通过从后向前遍历和深拷贝解决。DOM操

得塔云的博客 1228

C语言——数组知识大汇总

1、 定义 数组: 相同类型数据项的集合。 下标变量: 后面跟一个方括号内的下标的变量,指示一个数组元素。 数组下标: 在数组名后的方括号内的数值或表达式,用于指示访问哪个数组元素。 数组是由 ”类型名“ ”标识符“ ”维数“ 组成的复合型数据类型。 ”维数“ 表示数组中包含的元素个数,必须大于等于 1 的常量表达式。此表达式只能包含 ”整型字面常量“ ”枚举常量“ ”用常量表达

Cawen的技术博客 853

前端数组方法汇总

前端数组方法汇总 下面是我们在前端开发中经常使用到的一些关于数组的方法,包括数组的创建等等,你可以通过点击下面的锚点链接来查看,希望对你有帮助。 目录 前端数组方法汇总 创建数组 new Array() 检测数组 object instanceof constructor Array.isArray(value) 转换方法 toString() join() 栈方法 push() pop() 队列方法 shi.

sqLeiQ的博客 1406

PHP 数组排序 从大到小,PHP常见数组排序方法小汇总

1.简单数组排序 sort() 函数和rsort() 函数:语法规则:bool sort(array &array [,int sort_flags]bool rsort(array &array [.int_sort_flags]参数:第一个参数是排序数组对象第二个参数是可以选的 可选值:SORT_REGULAR:是默认值,将自动识别数组的元素类型进行排序SORT_NUMERIC...

weixin_28759829的博客 3337

python输出数组中第二大的数_Python实现找出数组中第2大数字的方法示例

本文实例讲述了Python实现找出数组中第2大数字的方法。分享给大家供大家参考,具体如下:题目比较简单直接看实现即可,具体的注释在代码中都有:#!usr/bin/env python#encoding:utf-8'''''__Author__:沂水寒城功能:找出数组中第2大的数字'''def find_Second_large_num(num_list):'''''找出数组中第2大的数字'''#直...

weixin_39875760的博客 1263

Python中找出数组中第二大的数

已知numpy函数库中max和argmax函数可以得出一个数组中最大的成员以及所在位置: import numpy as np arr = [2, 3, 4, 1, 7, 6, 5] print("# arr中最大的数为{},位于第{}位".format(np.max(arr), np.argmax(arr)+1)) 那么如何得到一个数组中第二大的成员呢? 我的思想是:将原数组中最大...

henusyb的博客 1万+

Java找出数组中第K大的数

题目描述 有一个整数数组,请你根据快速排序的思路,找出数组中第K大的数。 给定一个整数数组a,同时给定它的大小n和要找的K(K在1到n之间),请返回第K大的数,保证答案存在。 测试样例: [1,3,5,2,2],5,3 返回:2 import java.util.*; public class Finder { public int findKth(int[] a, int n, int K) { quickSort(a,0,a.length-1); ..

luzhensmart的专栏 2258

leetcode数组汇总_20200831汇总

Kevin的算法之路|20200831汇总大家好,我是Kevin,从7月1号开始制定并执行这个计划。两个月过去了,截至目前一共输出了40篇整算法题解。下面是对我的题解文章做的一个分类汇总,大致按题目的考查类型和相关顺序做了整理,方便大家查看~数组 介绍:数组作为基础且常用的数据结构,其重要性不言而喻!两数之和 leetcode|经典力扣第一题三数之和 leetcode|面试常客双指针算法...

weixin_39608988的博客 106

从数组中找出第n大的数

基本思路就是随便找一个数,遍历数组,比这个数大的那么放到这个数的左边,比这个数小的放在这个数的右边。如果左边的数+1 == 这个n 那么当前这个数就是我们需要返回的,否则遍历左侧或者右侧的数组,条件是 如果左边的数很少,比如只有1个 ,你需要得到第3大的数,明显需要遍历右侧,否则就遍历左侧 。如此递归进行 public static class Util { public static int INVALID_INT_VALUE = 1 << 31; ...

yangjie6898862的专栏 1194

有M个整数数组,都已经从大到小排好序。请写出程序把这M个数组合成一个数组,也从大到小排序。

笔试题: 有M个整数数组,都已经从大到小排好序。请写出程序把这M个数组合成一个数组,也从大到小排序。 public class MMArrays { public static void main(String[] args) { //给定数组 int[] arr1 = new int[]{500, 400, 300, 200, 100}; ...

JinKin_OldWang的博客 1245

寻找数组中第k大的元素

这算是一道相当经典的算法题了: 在长度为N的乱序数组中寻找第k(n>=k)大的元素。 (1)最简单直接的方法:先排序再找 最简单直接的想法是首先进行排序。假设元素的数量不大,比如才几千个,那就可以先进行排序,比如用快排或堆排,平均时间复杂度为O(N*logN),然后取出前k个,于是总时间复杂度为O(NlogN)+O(k)=O(NlogN)。当然这种做法是浪费了不少的时间的,因为题目只要...

gcs的博客 3647

数组方法汇总

数组方法解析汇总 ES6数组的扩展方法、返回指定类型的数组方法

shuncheng_hu的博客 373
上一篇: 数组
下一篇: 数组的拷贝与排序
mingxulli
博客等级 码龄8年 18粉丝 42原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值