List集合删除元素

Question

给你一个List集合,再指定一个整数n,第一次删除list集合第n个数,删完之后在第n个数在重新数到n,再接着删除,直至删除完整个list集合的元素?这怎么做,求解
public void delete(List<Interger> list,int n){}

Answer 1

n的值超出list范围怎么处理？

Answer 2

个人觉得这个题应该不是说的list,而是一个首尾相连的链表,这样就是一个很经典的问题的

Answer 3

比如list集合有5个元素,n为8,那么则删除的是第3个元素,

Answer 4

比如list集合有5个元素,n为8,那么则删除的是第3个元素,
面试叫我编这个,没编出来

Answer 5

 public static void delete(List<Integer> list, int n) {
        int temp = 0;
        int temp2 = 0;
        if (list.size() != 0) {
            if (n <= list.size()) {
                list.remove(n);
                temp2 = 2 * n ;
            } else {
                
                temp = n % list.size();
                list.remove(temp);
                temp2 = temp + n;
            }
            delete(list, temp2);
        } else {
            System.out.println("list.size() = " + list.size());
        }
    }不知道是不是满足你的要求？

Answer 6

你这样明显不行啊,这样写的没删几个就下标就越界了,题目的意思是如果n数到了list集合末尾,则从头开始数到n,删除

Answer 7

public void delete(List list,int n) {
while(list.size()!=0) {
int temp=list.size();
if((n%temp)!=0) {
list.remove(n-1);
}else {
list.remove(temp-1);
}
}
不知道这样可否？

Answer 8

如果是链表，那么就是模n同余关系，LinkedList可以直接通过remove（int index）删除，只需要进行一次同余转换就行，毕竟Java有写好的API

Answer 9

这里有一篇 关于 ArrayList 的源码
你可以学下
go javafor.com

Answer 10

public class ListTest {
private int i;
public static int num = 7;
public static void main(String[] args) {
List<Integer> list = new LinkedList<Integer>();
for (int index = 1; index <= 50; index++) {
list.add(index);
if (50 == index) {
delete(list, 7);
}
}
}
// List集合删除
public static void delete(List<Integer> list, int n) {
System.out.println("list集合长度==>" + list.size() + "\tn的值==>" + n);
if (list.size() != 0) {
if (n <= list.size()) {
//System.out.println("n的值==>" + n);
System.out.println(list.get(n - 1) + "被删除了");
list.remove(n - 1);
n = num + n - 1;
} else {
n = n % list.size();
if (n == 0) {
//System.out.println("n的值==>" + n);
System.out.println(list.get(list.size() - 1) + "被删除了");
list.remove(list.size() - 1);
} else {
//System.out.println("n的值==>" + n);
System.out.println(list.get(n - 1) + "被删除了");
list.remove(n - 1);
}
n = num + n - 1;
}
delete(list, n);
} else {
System.out.println("删除完毕:list.size() = " + list.size());
}
}
}看一下这个，亲测可用

Answer 11

public class ListTest {
    private int i;
    public static int num = 7;
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<Integer>();
        for (int index = 1; index <= 50; index++) {
            list.add(index);
            if (50 == index) {
                delete(list, 7);
            }
        }
    }
    // List集合删除
    public static void delete(List<Integer> list, int n) {
        System.out.println("list集合长度==>" + list.size() + "\tn的值==>" + n);
        if (list.size() != 0) {
            if (n <= list.size()) {
                //System.out.println("n的值==>" + n);
                System.out.println(list.get(n - 1) + "被删除了");
                list.remove(n - 1);
                n = num + n - 1;
            } else {
                n = n % list.size();
                if (n == 0) {
                    //System.out.println("n的值==>" + n);
                    System.out.println(list.get(list.size() - 1) + "被删除了");
                    list.remove(list.size() - 1);
                } else {
                    //System.out.println("n的值==>" + n);
                    System.out.println(list.get(n - 1) + "被删除了");
                    list.remove(n - 1);
                }
                n = num + n - 1;
            }
            delete(list, n);
        } else {
            System.out.println("删除完毕:list.size() = " + list.size());
        }
    }
}

Answer 12

 public static void main(String[] args) {
        List<Integer> list = new LinkedList<Integer>();
        for (int i = 0; i < 99; i++) {
            list.add(i);
        }
        deleteList(list, 3);
        for (int z : list) {
            System.out.println(z);
        }
        System.out.print(list.size() + "------");
    }    public static void deleteList(List<Integer> list, int n) {
        int temp;
        int x = list.size();
        for (int i = 0; i < x; i++) {
            if (n < list.size()) {
                list.remove(n);
            } else {
                temp = n % list.size();
                list.remove(temp);
            }
        }
    }这样行不行？

Answer 13

int index = 0;
while(list.size()>1) {
index = (index+n-1)%list.size(); //n自己确定
list.remove(index);
}

Answer 14

楼上的确定这个问题不是约瑟夫环？csdn没落了。。这么经典的问题没人说

Answer 15

import java.util.ArrayList;
import java.util.List;
//给你一个List集合,再指定一个整数n,
//第一次删除list集合第n个数,删完之后在第n个数在重新数到n,
//再接着删除,直至删除完整个list集合的元素?这怎么做,求解
public class T2 {
public static void main(String[] args) {
T2.remove(2, T2.getList(10));
}

public static List<Integer> getList(int n) {
List<Integer> list = new ArrayList<Integer>();

for (int i = 0; i < n; i++) {
list.add(i);
}
System.out.println(list);
return list;
}

public static void remove(int n,List<Integer> list) {

list.remove(n-1);
System.out.println(list);
while(n <= list.size()) {
T2.remove(n, list);
}
}
}

Answer 16

import java.util.ArrayList;
import java.util.List;
//给你一个List集合,再指定一个整数n,
//第一次删除list集合第n个数,删完之后在第n个数在重新数到n,
//再接着删除,直至删除完整个list集合的元素?这怎么做,求解
public class T2 {
public static void main(String[] args) {
T2.remove(1, T2.getList(10));
}

//输入集合长度来获取测试集合
public static List<Integer> getList(int n) {
List<Integer> list = new ArrayList<Integer>();

for (int i = 0; i < n; i++) {
list.add(i);
}
return list;
}

//解决方案
public static void remove(int n,List<Integer> list) {
System.out.println(list);
if(n <= list.size()) {//如果要对象的位数小于等于当前集合的长度，则执行移除操作
list.remove(n-1);//按角标移除集合元素

System.out.println(list.size());//查看移除结果
T2.remove(2*n, list);//每次移除当前角标的二倍
}
}
}
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
9
[1, 2, 3, 4, 5, 6, 7, 8, 9]
8
[1, 3, 4, 5, 6, 7, 8, 9]
7
[1, 3, 4, 6, 7, 8, 9]

Answer 17

import java.util.ArrayList;
import java.util.List;public class Test { public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 5; i++) {
list.add(i);
}
int n = 17; delete(list, n);
} public static void delete(List<Integer> list, int n) {
int temp = 0;
if (list.size() != 0) {
if (n > list.size()) {
temp = n % list.size();
System.out.println("多出:"+temp);
list.remove(temp);
System.out.println("删除下标:"+temp+"成功");
}else{
System.out.println("并没有多余数，直接删除");
list.remove(n);
}
}
}
}各位大神看看有没有什么问题，我是培训机构出来的所以做的简单一点，希望不要吐槽啦。