java算法

Java常用算法

https://www.cnblogs.com/Ming8006/p/7059965.html  网站

目录

1 去重
  1.1 去重
  1.2 去不重
2 随机分配
3 递归
4 内部排序变形
  4.1 取数组中未出现的最小整数
5 字符串
  5.1 全排序
  5.2 找最大回文
  5.3 字符串转换为数字
  5.4 和为指定值的两个数

 

1 去重

1.1 去重

    //去重复，需要额外定义一个List
    public static void RemoveRepeat(List<Integer> arrs) {
        List<Integer> tmp = new ArrayList<Integer>();
        Iterator<Integer> it = arrs.iterator();
        while (it.hasNext()) {
            int a = it.next();
            if (tmp.contains(a))
                it.remove();
            else
                tmp.add(a);
        }
    }

1.2 去不重

    // 去不重复的数，用的是选择排序算法变化版
    public static void RemoveNoRepeat(List<Integer> arrs) {
        Boolean isRepeate = false;
        for (int i = 0; i < arrs.size(); i++) {
            isRepeate = false;
            for (int j = 0; j < arrs.size(); j++) {
                if (arrs.get(i) == arrs.get(j) && i != j) {
                    isRepeate = true;
                    break;
                }
            }
            if (!isRepeate) {
                arrs.remove(i);
                i--;
            }
        }
    }

    public static void RemoveNoRepeatImprove(List<Integer> arrs) {
        Boolean isRepeate = false;
        for (int i = arrs.size() - 1; i >= 0; i--) {
            isRepeate = false;
            for (int j = arrs.size() - 1; j >= 0; j--) {
                if (arrs.get(i) == arrs.get(j) && i != j) {
                    isRepeate = true;
                    break;
                }
            }
            if (!isRepeate) {
                arrs.remove(i);
            }
        }
    }

    public static void RemoveNoRepeatWithExtraMap(List<Integer> arrs) {
        Map<Integer, Integer> repeat = CountRepeat(arrs);

        for (int i = arrs.size() - 1; i >= 0; i--) {
            if (repeat.get(arrs.get(i)) == 1) {
                arrs.remove(i);
            }
        }
    }

    // 统计重复数
    public static Map<Integer, Integer> CountRepeat(List<Integer> arrs) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        Integer value = 0;
        for (Integer arr : arrs) {
            if (map.containsKey(arr)) {
                value = map.get(arr);
                map.put(arr, value + 1);
            } else {
                map.put(arr, 1);
            }
        }
        return map;
    }

2 随机分配

    public static Map<String, String> TicketDispatch(List<String> customers, List<String> tickets) {
        Map<String, String> result = new HashMap<String, String>();

        Random r = new Random();
        int iCustomer;
        int iTicket;
        for (int i = customers.size(); i > 0; i--) {
            // 取值范围[0,i)
            iCustomer = r.nextInt(i);
            iTicket = r.nextInt(tickets.size());

            result.put(customers.get(iCustomer), tickets.get(iTicket));
            customers.remove(iCustomer);
            tickets.remove(iTicket);
        }

        return result;
    }

3 递归

    //Java递归删除一个目录下文件和文件夹
    private static void deleteDir(File dir) {
        if (dir.isDirectory()) {
            String[] children = dir.list();
            // 递归删除目录中的子目录下
            for (int i=0; i<children.length; i++) {
               deleteDir(new File(dir, children[i]));               
            }
        }
        dir.delete();
    }

4 内部排序变形

4.1 取数组中未出现的最小整数

    public static Integer GetNotExitMinInteger(Integer[] arr)
    {
        Integer minIndex;
        Integer tmp;
        Integer first=0;
        for(int i=0;i<arr.length;i++)
        {        
            minIndex=i;
            for(int j=i+1;j<arr.length;j++)
            {
                if(arr[minIndex]>arr[j])
                    minIndex=j;
            }
            
            if(arr[minIndex]-first>1)
                return arr[minIndex]-1;
            else
            {
                first=arr[minIndex];
            }
            
            if(minIndex!=i)
            {
                tmp=arr[i];
                arr[i]=arr[minIndex];
                arr[minIndex]=tmp;
            }
        }
        return arr[arr.length-1]+1;
    }

上面问题其他解决方案：

也可先排序（快速排序，若范围可确定，且不到，可用桶排序），在先后比较arr[next]-arr[one]>1

 

5 字符串

5.1 全排序

思路：

n个字符

• 前n-1个固定，第n个，不能再互换，打印排列
• 前n-2个固定，第n-1个和n位置互换，得到排列
• 前n-3个固定，第n-2个分别和最后两个位置互换
• ...

View Code

5.2 找最大回文

回文：正读，倒读一样

样例：abcdedcba，abcddcba

思路：中心点，看两边是否对应

View Code

5.3 字符串转换为数字

View Code

5.4 和为指定值的两个数

思路

1 先排序，后加

2 用哈希表，key为数的值，value为位置。这样，hashMap.get(sum-arr[i])，O(1)定位

View Code