精华内容
下载资源
问答
  • C语言实现删除数组重复元素无序) #include<stdio.h> int main() { int a[10] = {1,2,7,7,3,9,4,4,11,3}; int k = 0; int i = 0; int j = 0; int n = 10; //元素个数 for( i = 0; i<n-k ; i+...

    C语言实现删除数组中重复元素(无序)

    #include<stdio.h>
    int main()
    {
    	int a[10] = {1,2,7,7,3,9,4,4,11,3};
    
    	int k = 0;
    	int i = 0;
    	int j = 0;
    	int n = 10; 		//元素个数 
    	for( i = 0; i<n-k ; i++)
    	{
    		for ( j = 1; j<n-k; j++)
    		{
    			if(i!=j && a[i] == a[j])
    			{
    				for(int l = j+1 ; l<n-k; l++)
    				{
    					a[l-1] = a[l]; 		//把数组从重复元素位置向前覆盖 
    				}
    				k++;		//记录重复元素个数
    			}
    		}
    	}
    	for(int t = 0; t<n-k ;t++)		//输出删除后的数组 
    	printf("%d ",a[t]);
    }
    
    展开全文
  • 数组重复的问题在任何编程中都会有碰到了,这里介绍C语言删除无序整型数组中的重复元素及时间复杂度,希望对各位有帮助。遇到一个题,大概要求是写一个函数处理来去掉一个无序的整型数组(例如int i_arr[] = { 1, 2, ...

    数组重复的问题在任何编程中都会有碰到了,这里介绍C语言删除无序整型数组中的重复元素及时间复杂度,希望对各位有帮助。

    遇到一个题,大概要求是写一个函数处理来去掉一个无序的整型数组(例如int i_arr[] = { 1, 2, 2, 3, 4, 2, 3, 5 };)中重复的元素,并返回最终的长度。

    1 思路

    看到这道题的时候,第一反应就是需要删除元素,然后联想到单链表。但是后面一想还是不划算,因为单链表还得先把数组中的元素遍历到链表节点中。

    换一下思路,可以先创建另一个整型数组(大小和原数组一样),然后正向遍历数组中的元素,比较当前元素和它前面所有的元素是否重复,如果这个整数之前没有出现过,那么就放到新的数组中,于是有了小节2中的Method1;另外一种就是不需要创建新的数组,在正向遍历数组中的元素时,比较当前元素和它后面所有的元素是否重复,如果重复就把后面的所有元素向前移动(即覆盖),于是有了小节2中的Method2。

    2 完整程序

    程序中第104行的--j语句非常重要,这是为了避免当前元素连续出现3次(或以上)而没有被删除。

    #include

    #include

    #include

    #include "print.h"

    int f_del1( int *i, int iLen );

    int f_del2( int *i_f_del2, int len );

    int main( int argc, char **argv )

    {

    //The test array.

    int i_arr1[26] = { 1, 3, 2, 1, 2, 3, 4, 5, 5, 6, 7, 8, 12, 11, 22, 3, 7, 5, 13, 4, 5, 8, 7, 6, 23, 12 };

    int i_arr2[26] = { 1, 3, 2, 1, 2, 3, 4, 5, 5, 6, 7, 8, 12, 11, 22, 3, 7, 5, 13, 4, 5, 8, 7, 6, 23, 12 };

    int i_ar2r[26] = { 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7, 8, 11, 11, 12, 13, 13, 13, 13, 14, 15, 15, 17, 18, 23, 24 };

    int i_ar3r[26] = { 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7, 8, 11, 11, 12, 13, 13, 13, 13, 14, 15, 15, 17, 18, 23, 24 };

    //The length of .

    int i_p_len = 0;

    #if 1

    i_p_len = f_del1( i_ar2r, 26 );

    PRINT( "len=[%d].", i_p_len );

    #endif

    PRINT( "------------------------------\n" );

    #if 1

    i_p_len = f_del2( i_ar3r, 26 );

    PRINT( "len=[%d].", i_p_len );

    #endif

    return 0;

    }

    //Method 1: Using malloc to init an array for storing the elements after deleting the repeated ones.

    int f_del1( int *array, int iLen )

    {

    int i = 1;

    int i_recycle = 0;

    //Flags to store an element into the array i_f_del1.

    int i_flag = 1;

    //Length of the sorted array, name as i_f_del1.

    int i_f_del1_len = 1;

    //Init an array for storing the elements after deleting the repeated ones.

    int *i_f_del1 = (int *)malloc( iLen*sizeof(int) );

    //Init the first interger element.

    *i_f_del1 = *array;

    while( i < iLen )

    {

    i_flag = 1;

    i_recycle = 0;

    while( i_recycle < i )

    {

    if( array[i] == array[i_recycle ] )

    {

    i_flag = 0;

    break;

    }

    }

    //If i_flag equals 1, we should put the current element to the array i_f_del1.

    if( i_flag )

    {

    i_f_del1[i_f_del1_len ] = array[i];

    }

    i;

    }

    #if 1

    for( i=0; i

    {

    PRINT( "i_f_del1[%d]=[%d].", i, i_f_del1[i] );

    }

    #endif

    return i_f_del1_len;

    }

    //Method 2: cover up the repeated elements.

    int f_del2( int *i_f_del2, int len )

    {

    int i = 0, j = 0, k = 0;

    for( i=0; i

    {

    for( j=i 1; j

    {

    if( i_f_del2[i] == i_f_del2[j] )

    {

    for( k=j 1; k < len; k )

    {

    i_f_del2[k-1] = i_f_del2[k];        //cover up

    }

    --len;

    //Key step to avoiding the continuous elements repeated more than 2 times.

    --j;

    }

    }

    }

    #if 1

    for( i=0; i

    {

    PRINT( "i_f_del2[%d]=[%d].", i, i_f_del2[i] );

    }

    #endif

    return len;

    }

    3 测试执行

    使用《Linux C/C 工程中可生成ELF、动/静态库文件的通用Makefile》一文中的Makefile文件进行程序编译,当然也可以使用命令进行编译gcc int_del_repeat.c -o int_del_repeat。

    4 时间复杂度

    Method 2中的时间复杂度为O(N^2),Method 2中的时间复杂度为O(N^3)。

    展开全文
  • 删除重复元素。返回新的数组长度。不要用占用空间的新的数组,在固定的内存中实现。举例A=[1,1,2,]返回值应当为2,且新的A=[1,2]思路这道题其实很简单。主要是因为数组已经是排好顺序的。如果不仔细看题目,把...

    题目

    给定一个已经排好序的数组。删除重复的元素。返回新的数组长度。不要用占用空间的新的数组,在固定的内存中实现。

    举例

    A=[1,1,2,]返回值应当为2,且新的A=[1,2]

    思路这道题其实很简单。主要是因为数组已经是排好顺序的。如果不仔细看题目,把数组当作无序数组进行操作,OJ时会显示超时。

    题目要求是不能申请二额外空间,如果提交时有申请额外空间,也是不通过的。

    还需要注意的一个地方是,数组中元素的位置不能改变。比如对于数组[1,1,1,4,5],移除重复元素后为[1,4,5],起始数字为1,而不能是其它数字。

    我们只需对对组遍历一次,并设置一个计数器,每当遍历前后元素不相同,计数器加1,并将计数器对应在数组中位置定位到当前遍历的元素。

    代码

    Java

    public class Solution {

    public int removeDuplicates(int[] A) {

    if (A == null || A.length == 0) {

    return 0;

    }

    int size = 0;

    for (int i = 0; i < A.length; i++) {

    if (A[i] != A[size]) {

    A[++size] = A[i];

    }

    }

    return size + 1;

    }

    }

    Python

    class Solution:

    # @param a list of integers

    # @return an integer

    def removeDuplicates(self, A):

    if len(A) == 0:

    return 0

    if len(A) == 1: # to make it clear

    return 1 # (without this also works well)

    index = 0

    for i in A[1:]:

    if i != A[index]:

    index += 1

    A[index] = i

    return index + 1

    话说这位妹子,好像我以前认识的。哎,不都说了,图给你们看到你就阳光灿烂,萌妹子卖萌记

    展开全文
  • 给你一个有序数组 nums ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后的数组。 不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 提示: 0 <...

    题目(详见leetcode)

    https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/

    给你一个有序数组 nums ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后的数组。

    不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

    提示:

    • 0 <= nums.length <= 3 * 104
    • -104 <= nums[i] <= 104
    • nums 已按升序排列

    这里利用快慢双指针解决这个问题

    附上官方代码:

    var removeDuplicates = function(nums) {
        const n = nums.length;
        if (n === 0) {
            return 0;
        }
        let fast = 1, slow = 1;
        while (fast < n) {
            if (nums[fast] !== nums[fast - 1]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    };
    
    作者:LeetCode-Solution
    链接:https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shan-chu-pai-xu-shu-zu-zhong-de-zhong-fu-tudo/
    来源:力扣(LeetCode)
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    1.看到后我作为数据结构小白想到一个问题,为什么slow不从0开始?我看图解也没有看出所以然,然后我自己画了一个图,就明白了:

    以上文中已经升序排列的数组为例子: 

    1>当slow=0,fast=1时,根据if判断,arr中索引为1和0的元素值相等,arr[0]依旧为1,fast指向下一个位置

    2>当slow=0,fast=2时,根据if判断,arr中索引为slow=0的元素被替换为arr[2]=2,这样这个数组索引为0的值就算没有重复也被删除了,不合理。

    2.关于return

    官方解题要求返回删除后的数组长度,遍历结束后,从arr[0]到arr[slow-1]的每个元素都不相同而且包含原数组中每个不同的元素,因此返回新的长度slow。

    这里贴上一个我自己指定数组,删除重复项的方法:

    1.首先数组没有升序排列,可以用数组排列对数组进行升序排列:

    arr.sort(function(a, b){return a - b});

    2.然后添加判断条件

    3.裁剪(slice)或删除数组(splice)多余部分

    代码实现:

    <body>
        <p id="demo"></p>
        <script>
            //新建一个数组
            var arr = [1,2,3,2,1,3,4,2,5];
            //数组升序排列
            arr.sort(function(a, b){return a - b});
    
            var fast = 1,slow = 1;
            while( fast<arr.length ){
                if(arr[fast] != arr[fast-1]){
                    arr[slow] = arr[fast] ;
                    ++slow;
                }
                ++fast;
            }
            //slice裁剪
            var newArr = arr.slice(0,slow);
            document.getElementById("demo").innerHTML = newArr;
            //splice删除
            arr.splice(slow,arr.length);
            document.getElementById("demo").innerHTML = arr;
           // return slow;
        </script>
    </body>

    还有一种在初级学习JS时网课里老师讲的方法

    不用先按顺序排列,冒泡排序

    贴上代码:

    <body>
        <p id="demo"></p>
        <script>
            //新建一个数组
            var arr = [1,2,3,2,2,1,3,4,2,5];
            //去除数组的重复数
            //获取数组中每一个元素
            for(var i=0 ; i<arr.length ; i++){
                //获取当前元素之后的所有数
                for(var j=i+1 ; j<arr.length ; j++){
                    //判断两个值是否相等
                    if(arr[i] == arr[j]){
                        //相等证明出现的重复的元素,则删除j对应的元素
                        arr.splice(j,1);
                        //当删除了当前j所在的元素以后,后面元素自动补位
                        //此时将不会再比较这个元素,需要再比较依次j所在位置的元素
                        //使j自减
                        j--;
                    }
                }
            }
            document.getElementById("demo").innerHTML = arr;
        </script>
    </body>

    注意j--; 如果数组中有连续两个相同的元素,如果不添加j--,会重复出现相同的元素。

    展开全文
  • 本文实例讲述了PHP删除二维数组中相同元素数组重复值的方法。分享给大家供大家参考,具体如下:function assoc_title($arr, $key){$tmp_arr = array();foreach ($arr as $k => $v) {if (in_array($v[$key], $...
  • * 原地删除重复出现的有序数组,使得每个元素只出现一次,返回删除重复元素后的数组长度 * 如:给定nums = {0,0,1,1,1,2,2,3,3,3} * 返回:{0,1,2,3} * 思路: * 根据题目数组是有序的,所以只需比较相邻两个元素...
  • import java.util.ArrayList;import java.util.HashSet;import java.util.Iterator;import java.util..../*去除重复数组:* 方法一:需要一个存储去重后元素数组,然后两层循环,外层遍历原数组,内容...
  • 去掉一个数组中的重复项,并按升序排序 方法1:indexOf() function removeRepeat(arr){ let result = [] for(var i=0;i<arr.length;i++){ if(result.indexOf(arr[i]) == -1){ result.push(arr[i]) } } ...
  • 分享给大家供大家参考,具体如下:前一段时间被面试问到:如果一个数组中有重复元素,用什么方法可以去重?一时间会想到用一种方法,但是后来查阅资料后发现,有好多方法可以实现,现在就总结一下,比较简单的几种。...
  • 无序数组找中位数

    2021-04-04 09:27:11
    无序数组排好序,取出中间的元素 时间复杂度 采用普通的比较排序法 O(N*logN) 如果采用非比较的计数排序等方法, 时间复杂度 O(N), 空间复杂度也是O(N). 思路二 (1)将前(n+1)/2个元素调整为一个小顶堆 (2)对...
  • 王道数据结构上有道题,删除无序的顺序表中重复元素,提示是用散列表,自己试着实现了一下 算法设计思想 关键之处在于利用散列表的冲突来判断元素是否存在重复。于是解决散列表冲突的方式只能用拉链法,不能用开放...
  • } } } 这段代码的问题(除了对大型数组来说非常慢,但这不是重点)是由于唯一数组的未声明元素将设置为0,因此第一个数组中的重复元素将被设置为0 unique [](如果有意义的话).我理解为什么会发生这种情况,但无法找到...
  • java中Set的用法Set集合的特点:不能存储相同的元素。同时因为其是一个抽象的接口:所以不能直接实例化一个set对象。(Set s = new Set() )错误该接口主要继承于Collections接口,所以具有Collection的一些常见的方法...
  • 存在重复元素题目描述示例一示例二示例三解题思路第一种方法运行结果源代码第二种方法运行结果源代码总结反思 题目描述 给定一个整数数组,判断是否存在重复元素。 如果存在一值在数组中出现至少两次,函数返回 true...
  • 单链表练习题-删除无序单链表中所有的重复元素(两种方法,C语言实现) 文章目录单链表练习题-删除无序单链表中所有的重复元素(两种方法,C语言实现)一、前言二、两种实现方式与优劣2.1 使用哈希存储2.2 使用两重循环...
  • 设计一个函数,返回值是一个长度为n的数组, 数组元素为1,…,n(次序是随机的,但不能出现重复)。写出关键代码的注释,不少于5处。 package test; import java.util.ArrayList; import java.util.Random; import...
  • 给你一个有序数组nums,请你原地删除重复出现的元素,使每个元素只出现一次,返回删除数组的新长度。 不要使用额外的数组空间,你必须在原地修改输入数组并在使用O(1)额外空间的条件下完成。 说明: 为什么返回数值...
  • 算法题一:无序数组的中位数 (快排思想O(N) 时间复杂度)算法的核心是使用最小堆(heap),你想到了吗?首先将数组的前(n+1)/2个元素建立一个最小堆。然后,对于下一个元素,和堆顶的...
  • 数组删除重复

    2021-01-06 13:49:01
    函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。 你不需要考虑数组中超出新长度后面的元素。 本题是leetcode的初级算法题,作为一个新手,看到题目首先的想法就是使用暴力法,暴力法...
  • 给你一个有序数组 nums ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除数组的新长度。 不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 示例 1: ...
  • 1.算法题一:无序数组的中位数 (快排思想O(N) 时间复杂度) package com.lightsword.leetcodeproblems import org.junit.jupiter.api.Test import java.util.* /** * 1.算法题一:无序数组的中位数 (快排思想O(N) ...
  • 在使用remove_if时发现此函数无法对容器内满足pred表达式的数据删除,remove_if将会使用列表内其他数据填充,而本身的大小不变,具体解释可以参考remove_if的用法,这种情况下需要搭配erase方法彻底删除. ...
  • 给定一个排序数组,你需要在 原地 删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。 不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 示例 1: 给...
  • 法一:直接使用stl的vector的unique去重,该去重函数不是直接删除重复元素,而是将相邻且重复的元素放入到vector的尾部,然后返回指向第一个重复元素的迭代器,所以要用erase删除尾巴的那些重复元素再统计size。...
  • 给定一个排序数组,你需要在 原地 删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。 不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 注:这里...
  • 给定一个增序排列数组 nums ,你需要在 原地 删除重复出现的元素,使得每个元素最多出现两次,返回移除后数组的新长度。 不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成...
  • 删除重复元素,就是将不重复的元素移至数组左侧 两个指针分别为p和q,比较两者位置元素是否相等 如果相等,q后移一位 如果不相等,将q位置的元素复制到p+1上,p后移一位,q后移一位 返回p+1,即为.
  • 数组中的第K大元素问题 问题: 在未排序的数组中找到第 k 个最大的元素。请注意,需要找的是数组排序后的第 k 个最大的元素,而不是第 k 个不同的元素。 约定: 假设这里数组的长度为 n。 方法一:基于快速排序的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,297
精华内容 21,718
关键字:

无序数组删除重复元素