数组去重

数组去重

方法

借助额外数组

方法一：

1.创建额外数组 arr2，其元素个数 count = 0
2.将arr1[0] 赋值给 arr2[0]，arr2 数组元素个数 count++
3.外层 for 循环遍历 arr1，置 flag为 TRUE ，arr1 与 arr2 中的每个元素比较，
  若相等，则置标志位为 FALSE，然后跳出内层循环，
  跳出内层循环之后，若 flag 为 TRUE，则将 arr1[i] 放入 arr2[count++]
4.进入下一次外层循环

缺点：比较次数多，效率低

方法二：

1.创建额外数组 arr2，其元素个数 count = 0，
2.对原数组 arr1进行排序，将arr1[0] 赋值给 arr2[0]，arr2 数组元素个数 count++，
3.for循环中 比较 arr1[i] 和arr2的最后一个元素 arr2[count-1]，
  若不相等，则将 arr1[i] 赋值给 arr2[count++]，
  for 循环结束之后，count 就是 arr2 中元素个数，即 arr1 中不重复的元素。

缺点：排序会破坏原数组中元素的顺序；额外的数组会增加空间占用。

---

不借助额外数组

方法一：

1.对原数组 arr1 排序
2.通过 slow、fast 指针来比较元素，若不相等则将 arr[fast] 赋值给 arr[slow]，
  当 fast 到数组结尾时，比较结束，arr[slow] 以及之前的元素就是不重复的元素。

优点：不额外占用空间。

缺点：排序会破坏原数组中元素的顺序。

代码如下

---

借助额外数组，两层循环比较元素，去重

#define FALSE 0
#define TRUE 1

void show_arr(int *arr, int arr_len)
{
    int i = 0;
    for (i = 0; i < arr_len; i++)
    {
        printf("arr[%d] : %d\n", i, arr[i]);
    }
}

int *remove_duplicates(int *arr, int *arr_len)
{
    int i = 0;
    int j = 0;
    int count = 0;
    int *arr_new = NULL;
    int flag = TRUE;

    arr_new = (int *)malloc(sizeof(int)*(*arr_len));
    if (NULL == arr_new)
    {
        printf("malloc() failed!\n");
        return NULL;
    }
    arr_new[0] = arr[0];
    count++;

    for (i = 1; i < *arr_len; i++)
    {
        flag = TRUE;
        for (j = 0; j < count; j++)
        {
            if (arr_new[j] == arr[i])
            {
                flag = FALSE;
                break;
            }
        }
        if (TRUE == flag)
        {
            arr_new[count++] = arr[i];
        }
    }

    *arr_len = count; /* 不重复元素的个数 */

    return arr_new;
}

int main(void)
{
    int arr[] = {10, 8, 10, 5, 7, 15, 5};
    int len = 0;
    int *arr_new = NULL;

    len = sizeof(arr)/sizeof(int);

    arr_new = remove_duplicates(arr, &len);
    show_arr(arr_new, len);

    free(arr_new);

    return 0;
}

---

借助额外数组，排序，去重

/* 打印数组 */
void show_arr(int *arr, int arr_len)          
{
    int i = 0;
    for (i = 0; i < arr_len; i++)
    {
        printf("arr[%d] : %d\n", i, arr[i]);
    }
}       

/* 元素大小比较 */
int cmp(const void *a, const void *b)
{
    return *(int *)a - *(int *)b; 
}

int *remove_duplicates(int *arr, int *arr_len)
{
    int *arr_new = NULL;
    int i = 0;
    int count = 0;

    arr_new = (int *)malloc(sizeof(int)*(*arr_len));
    if (NULL == arr_new)
    {
        printf("malloc() failed!\n");
        return NULL;
    }

    qsort(arr, *arr_len, sizeof(int), cmp);
    arr_new[0] = arr[0];
    count++;

    i = 1;
    while (i < *arr_len)
    {
        if (arr_new[count-1] != arr[i])
        {
            arr_new[count++] = arr[i];
        }
        i++;
    }
    *arr_len = count;
    return arr_new;
}

int main(void)
{
    int arr[] = {10, 8, 10, 5, 7, 15, 5};
    int len = 0;
    int *arr_new = NULL;

    len = sizeof(arr)/sizeof(int);

    arr_new = remove_duplicates(arr, &len);
    show_arr(arr_new, len);

    free(arr_new);

    return 0;
}

---

不借助额外数组，排序 & slow-fast指针去重

/* 打印数组 */
void show_arr(int *arr, int arr_len)          
{
    int i = 0;
    for (i = 0; i < arr_len; i++)
    {
        printf("arr[%d] : %d\n", i, arr[i]);
    }
}       

/* 元素大小比较 */
int cmp(const void *a, const void *b)
{
    return *(int *)a - *(int *)b; 
}

int remove_duplicates(int *arr, int arr_len)
{
    int slow = 0;
    int fast = 1;
    
    qsort(arr, arr_len, sizeof(int), cmp);

    while (fast < arr_len)
    {
        if (arr[slow] != arr[fast])
        {
            slow++;
            arr[slow] = arr[fast];
        }   
            
        fast++;
    }
    return slow+1;/* 不重复元素的个数 */
}

int main(void)
{
    int arr[] = {10, 8, 10, 5, 7, 15, 5};
    int len = 0;
    
    len = sizeof(arr)/sizeof(int);
    show_arr(arr, len);

    return 0;
}

---