去除重复数

既然是排序的，应该是二分查找比较快吧
简单的写了一个，边界条件什么的也没仔细考虑
递归调用不知道对性能影响大不大？

#include <stdio.h>

int data[]={1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5};

int bin_comp(int * pdata,int len)
{
	int mid,midindex;

	midindex = len/2;
    mid = pdata[midindex];

    if(pdata[0] == pdata[len])
	{
		return 0;
	}

	if (mid == pdata[len])
	{
        bin_comp(pdata,midindex);
		return 0;
	}

	if (mid == pdata[0])
	{        
        bin_comp(pdata+midindex,midindex);
		return 0;
	}
	
    //if ((mid != pdata[0]) && (mid != pdata[len]))
	{
		bin_comp(pdata,midindex);
		printf("%d    ",mid);
        bin_comp(pdata+midindex,midindex);
	}

	return 0;    
}

main()
{
	int count = sizeof(data)/sizeof(data[0]);

	printf("%d    ",data[0]);
	bin_comp(data,count-1);
	printf("%d    ",data[count-1]);
}

我想问一下，如果数组是这样的呢：

int[] oNums = { 1, 2, 4, 4, 3, 3,5, 2, 4, 4, 5, 2, 3, 5, 5 };

也就是说不规律的应该怎么解决？

10楼的朋友的忽略了1,1,1的情况吧，用递归是没有错了，我自己写了一个java版本的，贴上（注释没有写，抱歉了）
public static void main(String[] args) {
  int[] ints = { 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 4, 5, 6, 7, 7, 7 };
distinct(ints, 0, ints.length - 1);
}
//递归、折半查找排除
public static void distinct(int[] ints, int sIndex, int eIndex) {
  int midIndex = (eIndex + sIndex) / 2;
  if (ints[sIndex] == ints[eIndex]) {
    System.out.println(ints[sIndex]);
  } else if (ints[midIndex] == ints[sIndex] && ints[midIndex] != ints[midIndex + 1]) {
    System.out.println(ints[midIndex]);
    distinct(ints, midIndex + 1, eIndex);
//不断的向右缩减成员，把2,2,2,2,3变成2,3
} else if (ints[sIndex] == ints[sIndex + 1]) {
    distinct(ints, sIndex + 1, eIndex);
} else {
    System.out.println(ints[sIndex]);
distinct(ints, sIndex + 1, eIndex);
    }
}

 def sort(list):
    sortList=[]
    for i in list:
        if sortList.count(i)==0:
            sortList.append(i)

    print(sortList)

这题和binary search有什么关系呢
这个数组是排好序的　直接相邻位比较就好了

   int[] removeDuplicates(int[] values)
   {
int current = 0;
int prev = current-1;
int count = 0;
int[] temp = new int[values.length];
for (int i = 0; i < values.length; i++) {
prev = current;
current = values[i];
if (current != prev) {
temp[count++] = current;
}
}
int[] result = new int[count];
System.arraycopy(temp, 0, result, 0, count);
temp = null;
return result;
   }

我觉得这道题目O（n）肯定不是最好的算法。
用二分搜索来者可以效率更高

	private static int[] num = { 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 4, 5,
		6, 7, 7, 7 };	

	public static void main(String args[]) {
		bSearch(0, num.length - 1);
	}

	public static void bSearch(int left, int right) {
		if (left > right)
			return;
		if (num[left] == num[right]) {
			System.out.print(num[right]);
			return;
		}
		int mid = (left + right) / 2;
		if (num[left] == num[mid]) {
			bSearch(mid, right);
		} else if (num[mid] == num[right]) {
			bSearch(left,mid);
		} else {
			int lower = lowerBound(left,mid);
			int upper = upperBound(mid,right);
			bSearch(left, lower-1);
			System.out.print(num[mid]);
			bSearch(upper+1, right);
		}

	}

	private static int upperBound(int left, int right) {
		if(num[left]== num[right])return right;
		int mid = (left + right) / 2;
		if(left == mid){ //即right= left+1
			return left;
		}
		if(num[left]==num[mid])
			return upperBound(mid,right);
		else
			return upperBound(left,mid);
	}

	private static int lowerBound(int left, int right) {
		if(num[left]== num[right])return left;
		int mid = (left + right) / 2;
		if(left == mid){ //即right= left+1
			return right;
		}
		if(num[mid]==num[right])
			return lowerBound(left,mid);
		else
			return lowerBound(mid,right);
	}

 

我的做法，参考合并排序递归把数组分成两半，然后再合并数组，效率nlgn。
合并数组的规则
1. 找出前一个数组中最后一个不为-1的数(这里用-1标志重复位)
2. 如果找不到，则直接合并
3. 如果找到这个数，则从下一个数组的开始位置开始，找出重复的数,置为-1。

	public static void main(String[] args) {
		int[]x = new int[]{1,1,2,3,3,3,4,4,4,4,4,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6};
		distinct(x, 0, x.length);
		System.out.println(Arrays.toString(x));
	}
	
	public static void distinct(int[] x,int p,int q){
		if(p==q-1){
			return;
		}
		int r = (p+q)>>>1;
		distinct(x, p, r);
		distinct(x, r, q);
		merge(x, p, r, q);
	}
	
	private static void merge(int[] x,int p,int r,int q){
		int key = -1;
		int k = r-1;
		while(k>=p){
			if(x[k]!=-1){
				key = x[k];
				break;
			}
			k--;
		}
		if(key!=-1){
			while(r<q&&(x[r]==key||x[r]==-1)){
				x[r] = -1;
				r++;
			}
		}
	}
         没有直接遍历快。。不过也是一个思路

有一个取巧的方法，楼主参考下

	public static void main(String[] args) {
		//质数数组
		int[] prime = new int[] { 2, 3, 5, 7, 11, 13, 17 };
		//目标数据
		int[] data = { 6, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5 };
		long tmp = 1;
		for (int i = 0; i < data.length; i++) {
			if (tmp % prime[data[i]] != 0) {
				System.out.println(data[i]);
				tmp *= prime[data[i]];
			}
		}
	}

求模呗....hash算法