连续删除奇数索引后如何打印最后一个元素

如何解决连续删除奇数索引后如何打印最后一个元素

我试图连续删除从 1 开始的奇数位置并获取最后剩余的元素；

例如：
n=6;

1 2 3 4 5 6

首先：去除奇数索引将得到 (2 4 6);

第二：删除奇数索引将得到（4）这是答案...

这是我的代码：

import java.util.HashMap;

public class Odd_Deletions {

    public static void oddDeletions(HashMap<Integer,Integer> hm) {
        int j = 1;
        for (int i = 1; i < hm.size(); i++) {

            if (hm.get(i) % 2 != 0) {
                continue;
            } else {
                hm.put(j,i);
                j++;

            }

        }
        //System.out.println(hm);
        while (true) {
            if (hm.size() == 1) {
                System.out.println(hm);
                break;
            } else
                oddDeletions(hm);
        }
    }

    public static void main(String args[]) {
        int n = 6;
        HashMap<Integer,Integer> hm = new HashMap<>();

        for (int i = 1; i <= n; i++) {
            hm.put(i,i);
        }
        //System.out.println(hm);
        oddDeletions(hm);
    }
}

为什么我会收到 StackOverflow 错误以及这个逻辑有什么问题？

有人能解决吗？

谢谢和问候；

解决方法

也许 HashMap 不是在这里使用的正确类。无论如何，正如@Welbog 指出的那样，您永远不会从桌子上删除任何东西。另外，为什么要使用递归？

尝试这样的事情：

    while (hm.size() > 1) {
        int j = 1;
        int last = hm.size();
        for (int i = 1; i <= last; i++) {
            int value = hm.remove(i);
            if (i % 2 == 0) {
                hm.put(j,value);
                j++;
            }
        }
    }

,

有 3 种可能的解决方案。

(1) 我不知道为什么您需要使用该逻辑在 HashMap 上应用“删除过程”，无论如何可能的解决方案可能是以下解决方案。但是，仅当您需要应用到 Map 时才需要使用它，因为某些原因您需要通过在 Map 键上应用该逻辑来删除其条目。

public class RemovingOddIndexes {

    public static void main(String[] args) {

        // initialize
        int n = 6;
        HashMap<Integer,Integer> hm = new HashMap<>();
        for (int i = 1; i <= n; i++) {
            hm.put(i,i);
        }

        //
        oddDeletions(hm);

        // print result
        hm.forEach((k,v) -> System.out.println(String.format("%s:%s,",k,v)));
    }

    public static void oddDeletions(HashMap<Integer,Integer> hm) {

        while (hm.size() > 1) {
            hm.keySet()
              .stream()
              .sorted()
              .forEach(new Consumer<Integer>() {
                  int i = 1;

                  @Override
                  public void accept(Integer n) {

                      if (i % 2 == 1)
                          hm.remove(n);
                      ++i;
                  }
              });
        }
    }
}

(2) 否则，使用可以递归浏览的简单 LinkedList。我更喜欢使用 LinkedList 而不是 ArrayList 因为 alg 需要在每次迭代时删除元素，直到最后一次。对 LinkedList 的删除操作性能更好。

public class RemovingOddIndexes {

    public static void main(String[] args) {

        // initialize
        int n = 6;
        List<Integer> list = new LinkedList<>();
        for (int i = 1; i <= n; i++) {
            list.add(i);
        }

        //
        oddDeletions(list);

        // print result
        list.forEach(i -> System.out.println(String.format("%s,i)));
    }

    public static void oddDeletions(List<Integer> list) {

        while (list.size() > 1) {
            int i = 1;
            Iterator<Integer> it = list.iterator();
            while (it.hasNext()) {
                it.next();
                if (i++ % 2 == 1) {
                    it.remove();
                }
            }
        }
    }
}

(3) 最后一个选择，最快的方法

int lastOdd = 1 << (int)(Math.log(n) / Math.log(2))