Java 列表添加&；删除方法

我试图做一个从整数列表中删除中间元素的方法，但是使用递归，我对如何处理基本情况感到非常困惑。当我尝试此代码时，输入为[1,3,5] 产量变为[3,5]

public static void removeMid(ArrayList<Integer> o){
int i=0;
    int low=0;
    int high=o.size()-1;
    int mid=(high+low)/2;
    
    
    if(o.get(i)!=mid)
    return ;
        else if(o.get(i)==mid) {
            o.remove(i);
    System.out.println(o.get(i)); //return mid element
        
    System.out.println(o);
    removeMid(o);
        }}```
    
    

publicstaticvoidremovemid（arraylisto）{
int i=0；
int低=0；
int high=o.size（）-1；
int mid=（高+低）/2；
如果（o.get（i）！=mid）
返回；
如果（o.get（i）=mid）{
o、 删除（i）；
System.out.println（o.get（i））；//返回中间元素
系统输出打印ln（o）；
去甲酰胺（o）；
}}```

这取决于中间元素的定义

假设中间的元素是放置在中间索引中的元素，那么应该使用

List/ArrayList

的方法

您可能希望将删除限制在输入列表的大小为奇数的情况下

publicstaticvoidremovemid（arraylisto）{
如果（o.size（）>1&&o.size（）%2！=0）{
int removed=o.remove（o.size（）/2）；
System.out.println（“删除的元素：+删除的元素”）；
}否则{
System.out.println（“没有可移除的中间元素”）；
}
}

如果需要删除中间值，可以对输入列表进行排序，然后像前面一样删除中间索引处的元素：

公共静态void removeMidValue（ArrayList o）{
集合。排序（o）；
去甲酰胺（o）；
}

更新
递归解决方案包括查找

min

和

max

元素，删除它们，递归调用以从剩余列表中删除中间值，并在从递归调用返回时恢复

min

和

max

值。递归的退出条件是剩余的列表只包含一个要删除的元素

另一个需要解决的问题是如何恢复

min

和

max

元素-在删除/恢复元素时，可以选择使用它们的索引，或者只将

min

和

max

值添加回列表，从而更改初始顺序

也就是说，保持顺序的递归解可以如下所示：

publicstaticvoidremovemidrecursive（arraylisto）{
System.out.println（“递归：+o”）；
如果（o.size（）%2==0）{
System.out.println（“列表大小为偶数，没有要删除的中间元素”）；
}如果（o.size（）==1），则为else{
int mid=o.remove（0）；
System.out.println（“删除的中间元素：“+mid”）；
}否则{
//查找最小和最大元素的索引
int minId=0；
int maxId=0；
对于（int i=1；i=o.get（maxId））{
maxId=i；
}
}
//对索引进行排序
int tMin=Math.min（minId，maxId）；
int tMax=Math.max（minId，maxId）；
//开始从较大的索引中删除并存储该值
//使用'E remove（int索引）`
整数atMax=o.remove（tMax）；
//System.out.printf（“删除的o[%d]=%d%n”，tMax，atMax）；
整数atMin=o.remove（tMin）；
//System.out.printf（“删除的o[%d]=%d%n”，tMin，atMin）；
removeMidRecursive（o）；
//通过插入适当的索引并进行更正来恢复值
如果（tMin>0）o.add（tMin-1，atMin）；否则o.add（0，atMin）；
如果（tMax>0）o.add（tMax-1，atMax）；否则o.add（0，atMax）；
System.out.println（“还原：+o”）；
}
}

测试：

arraylistarr=newarraylist（Arrays.asList（3,5,1,1,7,6,7））；
系统输出打印项次（arr）；
removeMidRecursive（arr）；
系统输出打印项次（arr）；
System.out.println（“------------------------”；
arr=newarraylist（Arrays.asList（6,4,1,4,2,1,4））；
系统输出打印项次（arr）；
removeMidRecursive（arr）；
系统输出打印项次（arr）；

输出

[3, 5, 1, 1, 7, 6, 7]
recursive: [3, 5, 1, 1, 7, 6, 7]
recursive: [3, 5, 1, 7, 6]
recursive: [3, 5, 6]
recursive: [5]
removed mid element: 5
restored: [3, 6]
restored: [3, 1, 7, 6]
restored: [3, 1, 1, 7, 6, 7]
[3, 1, 1, 7, 6, 7]
------------------
[6, 4, 1, 4, 2, 1, 4]
recursive: [6, 4, 1, 4, 2, 1, 4]
recursive: [4, 4, 2, 1, 4]
recursive: [4, 4, 2]
recursive: [4]
removed mid element: 4
restored: [4, 2]
restored: [4, 2, 1, 4]
restored: [6, 1, 4, 2, 1, 4]
[6, 1, 4, 2, 1, 4]

---

在不保留原始顺序的情况下进行递归删除要简单得多，它使用的是另一种

List

方法：

publicstaticvoidremovemidandshuffle（arraylisto）{
如果（o.size（）%2==0）{
System.out.println（“列表大小为偶数，没有要删除的中间元素”）；
}如果（o.size（）==1），则为else{
int mid=o.remove（0）；
System.out.println（“删除的中间元素：“+mid”）；
}否则{
整数最小值=整数最大值；
整数最大值=整数最小值；
for（整数x:o）{
min=数学最小值（min，x）；
max=Math.max（max，x）；
}
o、 移除（分钟）；
o、 移除（最大值）；
移除middshuffle（o）；
o、 添加（分钟）；
o、 添加（最大值）；
}
}

其产出：

[3, 5, 1, 1, 7, 6, 7]
removed mid element: 5
[3, 6, 1, 7, 1, 7]
---------
[6, 4, 1, 4, 2, 1, 4]
removed mid element: 4
[2, 4, 1, 4, 1, 6]

---

下面是一个最简单的场景，通过递归对ArrayList中的值进行“迭代”。请注意，我们有一个额外的参数，

i

，我们要传递它来跟踪我们在列表中的位置。这简单地去除了中间位置的任何东西，基于索引。它不考虑列表中包含的值：

  public static void main(String[] args) {
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(1);
    numbers.add(3);
    numbers.add(5);

    System.out.println("Before: " + numbers.toString());
    removeMid(numbers, 0);
    System.out.println("After: " + numbers.toString());
  }

  public static void removeMid(ArrayList<Integer> o, int i){
    if (o!=null && o.size()>0) {
      // you didn't give a clear specification for "middle"
      int mid=o.size() / 2; // to the right of middle, for even sized lists 
      if (i == mid) {
        o.remove(i);
      }
      else {
        removeMid(o, i+1);
      }
    }
  }

---

o.get（i）=mid

这里您将索引与列表值进行比较。这没有任何意义。谢谢你的这个解决方案，但我必须使用递归来解决它。我试图根据你的解决方案使它递归。它成功地删除了中间的元素，但它最终删除了列表中的所有元素。知道如何终止它吗？我只需要删除一次`if（o.size（）==0&&o.size（）%2==0）{return；}else{o.remove（o.size（）/2）；System.out.println（o）；removeMide（o）；}}}`因此，您只需在数组中找到一个中间元素并仅删除此元素，而不使用库

排序
？@E00X，您可以检查updateThak u。。
Before: [1, 3, 5]
After: [1, 5]