数组去重-哈希-快慢指针

数组去重的方式有多种，下面介绍两种

• 待操作数组用 数组a 表示
• 处理好的数组用 数组res 表示

1. Hash 哈希去重

思路：

1. 利用Map不能存储相同数值的原理
2. 取得所有键值存入数组，即去重后的返回值

public static int[] delSame(int[] a){
	Map<Integer,Integer> map = new HashMap<>();
        for (int num:a) {
            map.put(num,1);
        }
        Set<Integer> set = map.keySet();
        int[] res=new int[map.size()];
        Iterator<Integer> iterator = set.iterator();
        int i=-1;
        while (iterator.hasNext()){
            res[++i]=iterator.next();
        }
        return res;
}

2. 快慢指针去重

思路：

1. 对数组进行排序
2. 借助快慢指针 i 和 j ，让 i 始终指向不重复的数据的下标作为慢指针，让 j 一直遍历数组，寻找重复的数值
3. 找到重复的数值就让 j++ 跳过

完整代码：

public static int[] delSame(int[] a){
        //1.排序
        Arrays.sort(a);
        //2.去重
        int n=a.length;
        int[] res=new int[n];   //存放返回值，即去重后的数组
        if(n==1){   //极端案例
            res[0]=a[0];
            return res;
        }
        int i=0;    //慢指针
        int j=0;    //快指针
        int temp=-1;
        int num1 = a[i];    //指针i指向的值
        int num2 = a[j];    //指针j指向的值
        while (j<n) {   //只要j不越界就一直执行，但由于循环体中有多个++j，所以循环体内也应该判断以防越界
            res[++temp]=num1;	//每循环一次num1更新一次且不是重复值
            //防止越界
            int t = j+1;
            if(t==n){
                break;
            }
            num2 = a[++j];  //更新 j
            while(num2 == num1){//如果重复就让j++
                if(j==n-1){     //防止越界
                    break;
                }
                num2=a[++j];
            }
            num1=a[j];
        }
        int size = temp+1;  //发现去重后的数组大小 size=temp+1
        int[] ans = new int[size];
        for (int k = 0; k < size; k++) {
            ans[k]=res[k];
        }
        return ans;
    }

看似复杂，主要是判断越界的地方影响思维
核心代码：

while(j<n){
	res(++temp)=num1;
	num2=a[++j];
	while(num1==num2){
		num2=a[++j];
	}
	num1=num2;
}