删除任意数组中相同的元素 , 删除排序后的数组中相同的元素

A是一个长度为N的整形数组,其中可能包含重复的元素,例如A={1,2,2,3,2,1,3,2},删除数组中相同的元素后得到{1,2,3},
a) 如果数组没有排序,写一个C语言函数,输入参数为数组首地址和长度,删除其中重复的元素,返回删除后的数组的长度。
b) 上述函数的时间复杂度为多少,以删除前的数组长度N表示。
c) 如果数组A已经排好序,设计并写出一个C语言函数完成a)中的工作,要求时间复杂度是O(N) 。

#include<iostream>
using namespace std;

// a) 删除任意数组中相同的元素
int delete_same_all(int a[], int n)
{
    int i, j, len=n;
    for(i=0; i<len; ++i)
        for(j=i+1; j<len; )
            if(a[i] == a[j])
                a[j]=a[--len];
            else
                ++j;
    return len;
}

// c)删除排序后的数组中相同的元素
int delete_sort_same_all(int a[], int n)
{
    int i, k=1;
    for(i=1; i<n; ++i)
    {
        if(a[i-1] != a[i])
        {
            if(i != k)
                a[k] = a[i];
            ++k;
        }
    }
    return k;
}


//打印数组
void show(int *arr, int n)
{
    int i=0;
    for(;i<n;i++)
        cout<<arr[i]<<" ";
    cout<<endl;
}

int main()
{
    int A[] = {1,2,2,3,2,1,3,2};
    int n, len;
    n = sizeof(A)/sizeof(A[0]);
    len = delete_same_all(A, n);
    show(A, len);

    int B[] = {1,2,2,2,3,3,3,10,12,77,77,77};
    n = sizeof(B)/sizeof(B[0]);
    len = delete_sort_same_all(B, n);
    show(B, len);
    return 0;
}
  • 2
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
常见的数组排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等等。下面我分别介绍一下这几种排序算法的实现。 1. 冒泡排序 冒泡排序是一种比较简单的排序算法,它的基本思想是通过相邻元素之间的比较和交换来实现排序。 具体实现步骤如下: 1. 从数组的第一个元素开始,依次比较相邻的两个元素,如果个元素比后一个元素大,则交换两个元素的位置,这样一轮下来,最大的元素就会被移动到数组的最后。 2. 对剩余的元素重复上述步骤,直到所有元素都被排序。 下面是冒泡排序的代码实现: ```python def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] ``` 2. 插入排序 插入排序的基本思想是将一个元素插入到已经排好序的数组中,使得插入后的数组仍然有序。 具体实现步骤如下: 1. 将数组的第一个元素视为已经排好序的数组。 2. 遍历剩余的元素,将每个元素插入到已经排好序的数组中的合适位置。 3. 重复上述步骤,直到所有元素都被排序。 下面是插入排序的代码实现: ```python def insertion_sort(arr): for i in range(1, len(arr)): key = arr[i] j = i - 1 while j >= 0 and key < arr[j]: arr[j+1] = arr[j] j -= 1 arr[j+1] = key ``` 3. 选择排序 选择排序的基本思想是每次从未排序的部分选出最小(或最大)的元素,将其与未排序部分的第一个元素交换位置,从而得到一个新的已排序部分。 具体实现步骤如下: 1. 遍历数组,依次找出最小的元素。 2. 将最小的元素与未排序部分的第一个元素交换位置。 3. 重复上述步骤,直到所有元素都被排序。 下面是选择排序的代码实现: ```python def selection_sort(arr): for i in range(len(arr)): min_index = i for j in range(i+1, len(arr)): if arr[j] < arr[min_index]: min_index = j arr[i], arr[min_index] = arr[min_index], arr[i] ``` 4. 快速排序 快速排序是一种基于分治思想的排序算法,它的基本思想是通过一趟排序将待排记录分割成独立的两部分,其一部分记录的关键字均比另一部分记录的关键字小,然后再按照此方法对这两部分记录分别进行快速排序,直到整个序列有序。 具体实现步骤如下: 1. 选择一个基准元素,通常选择第一个元素。 2. 将所有小于基准元素元素放到基准元素的左边,将所有大于基准元素元素放到基准元素的右边,同时基准元素所在的位置也就确定了。 3. 递归地对基准元素左边和右边的子序列进行快速排序。 下面是快速排序的代码实现: ```python def quick_sort(arr, left, right): if left < right: pivot = partition(arr, left, right) quick_sort(arr, left, pivot-1) quick_sort(arr, pivot+1, right) def partition(arr, left, right): pivot = arr[left] while left < right: while left < right and arr[right] >= pivot: right -= 1 arr[left] = arr[right] while left < right and arr[left] <= pivot: left += 1 arr[right] = arr[left] arr[left] = pivot return left ``` 5. 归并排序 归并排序是一种基于分治思想的排序算法,它的基本思想是将待排记录分割成若干个子序列,每个子序列都是有序的,然后再将这些有序的子序列合并成一个有序的序列。 具体实现步骤如下: 1. 将待排记录分成两个子序列,每个子序列继续递归地进行归并排序。 2. 将两个子序列合并成一个有序的序列。 3. 重复上述步骤,直到所有元素都被排序。 下面是归并排序的代码实现: ```python def merge_sort(arr): if len(arr) > 1: mid = len(arr) // 2 left_arr = arr[:mid] right_arr = arr[mid:] merge_sort(left_arr) merge_sort(right_arr) i = j = k = 0 while i < len(left_arr) and j < len(right_arr): if left_arr[i] < right_arr[j]: arr[k] = left_arr[i] i += 1 else: arr[k] = right_arr[j] j += 1 k += 1 while i < len(left_arr): arr[k] = left_arr[i] i += 1 k += 1 while j < len(right_arr): arr[k] = right_arr[j] j += 1 k += 1 ``` 以上就是几种常见的数组排序算法的实现。需要注意的是,不同的排序算法在不同的场景下可能会有不同的表现,因此在实际应用需要根据具体情况选择合适的排序算法。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值