怎么删除一个数组中重复的元素

Question

现在有一个整型数组，其中有些元素是重复出现的，设计一个算法去掉这些重复的元素，所有的操作都必须在这个数组本上上实现，不能创建另外一个数组。

Answer 1

看这个帖子吧  正在讨论呢http://topic.csdn.net/u/20081109/14/eb2f41bf-52c3-4f9a-a7ad-f590a83887cc.html

Answer 2

说说思路吧，先找到有哪些相同的元素，然后把它们一个一个删除，当检查到还剩一个时，就break检查其他的元素。

Answer 3

我不知道我说的对不对，只是想法，记得以前那么干过，不过也记不清楚了
查找相同的肯定要做比对，这是一个循环
假设位置0和位置7重复，肯定是循环7次后发现重复，然后把8位提到7位 9位提到8位……
然后数组长度缩短
（我说记不住的是这个长度缩短我忘记是操作本来的那个数组还是创建了一个新的长度-1的数组
楼主回头查下api吧）

Answer 4

public class Sort1 {//排序
public static void sort(int[] arr){
for(int i = 0;i < arr.length;i++){
int k =i;
for(int j=k;j < arr.length;j++){
if(arr[j] < arr[k]){
k = j;
}
}
if(k != i){
int temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
}
}
public static int[] deleteMulti(int[] arr){//删除
int m = 0;
int n = 0;
while(m < arr.length){
arr[n] = arr[m];
while(arr[n] == arr[m]){
m++;
if(m == arr.length){
break;
}
}
n++;
}
int[] newNum = new int[n];
for(int i = 0;i < n; i++)
newNum[i] = arr[i];
return newNum;
}

public static void main(String[] args) {
int[] arr = {7,8,5,4,2,6,4,8,7,6,2,6,9};
sort(arr);
int[] newarr = deleteMulti(arr);//用一个数组存排序好的,算不算?
for(int i:newarr){
System.out.print(" " + i);
} }}

Answer 5

楼上有点麻烦吧。 int[] arr = {7,8,5,4,2,6,4,8,7,6,2,6,9};
 ArrayList<Integer> arrayList = new ArrayList<Integer>();  
 for (int i = 0; i < arr.length; i++) {
if (!arrayList.contains(arr[i])) {
arrayList.add(arr[i]);
}
}

Object[] aa =arrayList.toArray() ;
Arrays.sort(aa) ; 
for (int i = 0; i < aa.length; i++) {
System.out.println(aa[i]);
}

Answer 6

可以将数组中的元素全部放到一个set中 set就会自动去掉相同的元素了 呵呵 

Answer 7

public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
int[] arr = {7,8,5,4,2,6,4,8,7,6,2,6,9};
Arrays.sort(arr);//排序（从小到大）
for(int i=0;i<arr.length-1;i++){
    if(arr[i]<arr[i+1]){
continue;
    }else{
arr[i] = Integer.MIN_VALUE;//如果不比后一位小，设为最小值
    }     
}
int k = 0;
        //把有效数插到数组中
for(int i=0;i<arr.length;i++){
    if(arr[i]>Integer.MIN_VALUE){
arr[k] = arr[i];
k++;
    }
}
        多余的设为最小值
while(k<arr.length){
    arr[k] = Integer.MIN_VALUE;
    k++;
}
for(int i:arr){
    System.out.print(i+" ");
}
    }
输出：2 4 5 6 7 8 9 -2147483648 -2147483648 -2147483648 -2147483648 -2147483648 -2147483648

Answer 8

那一篇是已经排过序了的。
如果没排过序的话，我觉得，应该先排序再比较，可能会快点。排序之后的比较，最普遍的方法就是用相邻的比较。
不过特殊情况用特殊方法。另一朋友提出用二分法。我觉得提议非常不错。
二分法适用于，重复比较多的情况下（不完全是最大值与最小值的差比较小的情况）。
例如，长度1000的数组。数值范围为0~19
其中可能有3、4个数不会出现。
这时，大概15个数字，出现在长度1000的数组里，重复的数就比较多了。
这时用二分法，效率就会高很多。public class Main {    public static void main(String[] args) {
        int[] src = new int[1000];
        Set<Integer> set = new HashSet<Integer>();
        Random r = new Random();
        for (int i = 0; i < 5; i++) {
            set.add(r.nextInt(20));
        }
        for (int i = 0; i < src.length; i++) {
            int j = r.nextInt(20);
            if (!set.contains(j)) {
                src[i] = j;
            }
        }
        Arrays.sort(src);
        src = g(src);
        for (int i : src) {
            System.out.print(i + " ");
        }
        System.out.println("\n" + src.length);
    }    public static int[] g(int[] src) {
        int k = 0;
        while (src[k] < src[src.length - 1]) {
            int x = Arrays.binarySearch(src, k + 1, src.length, src[k] + 1);
            src[++k] = x > 0 ? src[x] : src[-x - 1];
        }
        return Arrays.copyOf(src, k + 1);
    }
}

Answer 9

public class ArraysTest
{
public static void main(String []args)
{
int []arrays=new int[20];

int temp=1;
for(int i=0;i<arrays.length;i++)
{
arrays[i]=new Random().nextInt(25);
}
Arrays.sort(arrays);
for(int i:arrays)
{
System.out.print(i+"  ");
}
System.out.println();
for(int i=1;i<arrays.length;i++)
{
if(arrays[i-1]!=arrays[i])
     temp++;
}
int []TempArrays=new int[temp];
temp=0;
TempArrays[0]=arrays[0];
for(int i=1;i<arrays.length;i++)
{
if(arrays[i-1]!=arrays[i])
     TempArrays[++temp]=arrays[i];
}
for(int i:TempArrays)
{
System.out.print(i+"  ");
}
System.out.println();
}
}