请教一个简单的算法问题

Question

有这样一个算法,1-10十个数存放在数组中，每次都删除奇数位的数字，循环删除到最后只剩下一个值例如:1,2,3,4,5,6,7,8,9,10第一次删除奇数位后就剩下2,4,6,8,10第二次删除就剩下4,8第三次删除就剩下8
请问这个算法用java的list怎么实现，list的操作不会，刚接触java，望高人指点，非常感谢！！

Answer 1

遍历，用从0到size（）判断是奇数就把索引值放到一个int数组中，在循环此数组，用remove()这个方法删除不要的数据，以上2步循环几次就能实现了吧

Answer 2

import java.util.*;public class Test {
public static void main(String[] args) {
List<Integer> nums = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
nums.add(i + 1);
}
System.out.print("初始数组：");
for (int i = 0; i < nums.size(); i++) {
System.out.print(" " + nums.get(i));
}
for (int t = 0; t < 3; t++) {
for (int i = nums.size() - 1; i >= 0; i--) {
if ((i - 1) % 2 != 0) {
nums.remove(i);
}
}
System.out.print("\n第"+(t+1)+"次删除后的数组：");
for (int i = 0; i < nums.size(); i++) {
System.out.print(" " + nums.get(i));
}
}
}
}这是我验证过的，关键是List要从后往前删，因为下标是动态变化的，不然会出问题。然后就是i=0对应的值是1不是0，所以别搞混了。PS：上面的帖居然不能修改，郁闷

Answer 3

import java.util.ArrayList;
public class Problem2 { /**
 * @param args
 */
private Byte[] num={1,2,3,4,5,6,7,8,9,10};
ArrayList<Byte> alist=new ArrayList<Byte>();
private boolean isDelete;
public Problem2(){
isDelete=true;
}
public void delete(){
for(int i=0;i<num.length;i++){
alist.add(num[i]);
}
while(isDelete){
for(int i=0;i<alist.size();i++){
if((i+1)%2==1)
{
// alist.remove(i);
alist.set((byte)i,(byte)0);
}
}
for(int i=0;i<alist.size();i++){
if(alist.get(i)==0){
alist.remove(i);
}
}

if(alist.size()==1)
isDelete=false;

for(int i=0;i<alist.size();i++){
System.out.println("num["+i+"]="+alist.get(i));
}
System.out.println("");
}

}
public static void main(String[] args) {
// TODO Auto-generated method stub
Problem2 pl=new Problem2();
pl.delete(); }}
我这样可以达到目的

Answer 4

public static void main(String[] args)
{
List<Integer> l = new ArrayList<Integer>();
for(int i = 0; i < 10; i++)
l.add(i + 1);
System.out.println(Arrays.toString(l.toArray()));
remove(l);
System.out.println(Arrays.toString(l.toArray()));
}

public static int c(int n)
{
if( n < 2)
return 1;
int r = 0;
for(; n > 0 && (n % 2) == 0;r++)
n -= (2 << r);
return (r == 0 ? c(n -1) : r);
}

public static int locate(int n)
{
return n < 2 ? 1 : 2 << (c(n) - 1);
}

public static void remove(List<Integer> l)
{
int loc = locate(l.size());
Integer o = l.get(loc - 1);
l.clear();
l.add(o);
}

Answer 5

import java.util.ArrayList;
import java.util.List;public class DeleteWhenOdd { public static void main(String[] args) {

List<Integer> list = new ArrayList<Integer>();
for(int i = 1; i <= 10; i++) {
list.add(i);
}

for(int i = 0; list.size() > 1;) {
if( i >= list.size()) {
i = 0;
continue;
}
list.remove(i++);
}

System.out.println(list);
}
}

Answer 6

经典的围圈。用array也可以的啦！

Answer 7

package shi.list;
import java.awt.List;
import java.util.*;
public class TestList
{
public static void main(String args[])
{
ArrayList array=new ArrayList();
List list=new List();
for(int i=0;i<10;i++)
{
list.add(String.valueOf(i+1));//初始化list

}
while(list.getItemCount()>1)
{
for(int i=0;i<list.getItemCount();i++)
{
if((i+1)%2!=0)
{
array.add(list.getItem(i));
}
}

for(int i=0;i<list.getItemCount();i++)
{
for(int j=0;j<array.size();j++)
{
if(list.getItem(i).equals(array.get(j)))
list.remove(i);
}

}
for(int i=0;i<array.size();i++)
{
array.remove(i);
}
}
//最后输出结果
for(int i=0;i<list.getItemCount();i++)
{

System.out.println(list.getItem(i));
}
}
}
这样可以达到目的!
不过效力高低没有考虑太多!

Answer 8

感谢6楼的Tassdars ，7楼gaocaiying ，9楼的dreamhunter_lan，12楼的shixitong 看来list的用法还是很灵活的，以后要多用list了我的想法是用数组做位移操作的，但朋友告诉我list效率更高，list做读写操作效率比数组会很多吗？import java.util.*;
public class TestList
{
     public static void main(String[] args) { 
           int m = 10;//记录数组元素的个数，初始化为10           //以数组的元素个数为判断条件，如果为1则判断结束
            do{
                m = sort(m);        
        }while(m != 1);
     }
   //当数组个数不为1时，将偶数位的值赋给基数位
    private int sort(int m)
    {
          int a[] = {1,2,3,4,5,6,7,8,9,10};
        
        if(m == 1){
            return 1;
        }   
        else{
                int k = 1;          
                int n = 0;       //记录当前写入位置   
            while( k < m ){
                
                a[n] = a [k];   //将需要保留的值存到新的数组地址中
                        n++;            //每次n都递加1
                        k += 2;         //每次k都要自加2;
            } 
                return n ;
        }
    }
} 

Answer 9

/**
 * @Project <CL-Allocation tool>
 * @version <1.0>
 * @Author  <llddy>
 * @Date    <2008-11-18>
 * @description <这题不是绕圈问题吧，是跟位数有关系，如果数组下标是奇数就删除该数组>
 */
public class Test84 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
        for (int i = 1; i < 11; i++) {
list.add(i);
}
        System.out.println(list);
int n = getInt(list);
System.out.println(n);
}

public static Integer getInt(List<Integer> lists){
if(lists.size()==1){
return lists.get(0);
}else{
for (int i = 0; i < lists.size(); i++) {
if((i+1)%2==1){
lists.remove(i);
}

}
            return getInt(lists);
}
}
}

Answer 10

TO:llddy   你list赋值的时候是从1开始，取的时候又从0开始，list的第一个元素下标也是从0开始的吗？

Answer 11

一个是数组的值 一个是数组下标。 从数组取值 不都是根据数组下标取吗？
 数组的值--->      [1,2,3,4,5,6,7,8,9,10] 
 数组下标--->      0,1,2,3,4,5,6,7,8,9