精华内容
下载资源
问答
  • 每日算法(十五)-java给定一个有序数组,删除其中重复元素,只保留一个,并返回新数组的长度 Example 2: Given nums = [0,0,1,1,1,2,2,3,3,4], Your function should return length = 5, with the first five ...

    每日算法(十五)-java给定一个有序数组,删除其中重复元素,只保留一个,并返回新数组的长度

    Example 2:

    Given nums = [0,0,1,1,1,2,2,3,3,4],

    Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.

    常规方法一:
    新建一个数组来放最后的结果,由于不知道大小,就先与原数组大小相同,然后直接遍历原数组,第一次遍历从第一个数开始,第二个遍历从第二个数开始依次往后,如果第一个数与第二个数相等,则将预先设定的boolean类型的值更改为false并跳出循环,判断boolean类型的值是否为ture,是则将该值放入结果数组中,最后数组里面放的就都是不重复的元素,但需要注意的是我们一开始设定的大小为和原数组相同,所以没有放入的则默认都会0;所以这里还需要再新建一个数组,将得到的结果数组复制到新数组,新数组的大小可以在判断那里初始一个值来计录次数,最后的次数则为新数组的大小,代码如下:

    public class ArrrayLength {
    	public static int[] returnLength(int arr[]){
    		int t=0;
    		int temparr[]=new int[arr.length];
    		for(int i=0;i<arr.length;i++){
    			boolean isture=true;
    		  for(int j=i+1;j<arr.length;j++){
    			if(arr[i]==arr[j]){      
    				 isture=false;
    				 break;
    			}
    		  }
    			if(isture){
    				temparr[t]=arr[i];
    				t++;
    			}
    		}
    		int newarr[]=new int[t];
    		System.arraycopy(temparr, 0, newarr, 0, t);
    		return newarr;
    	}
    

    第二种巧妙方式:
    很容易想到链表的方式,利用其contains方法进行比较,不同则add放入链表,最终结果则为无重复的链表,最后再toarray遍历即可,toarray之前先新建一个数组大小了链表的size;代码如下:

    public class ListLength {
    public static List<Integer> returnList(int arr[]){
    	List<Integer> list =new ArrayList<>();
    	for(int i=0;i<arr.length;i++){
    		if(!list.contains(arr[i])){
    			list.add(arr[i]);
    		}
    	}
    	return list;
    }
    public static void main(String[] args) {
    	int arr[]={0,0,1,1,1,2,2,3,3,4};
    	List<Integer> temp=returnList(arr);
    	Object[] a=new Object [temp.size()];
    	a=temp.toArray();
    	for(int i=0;i<a.length;i++){
    		System.out.println(a[i]);
    	}
    
    展开全文
  • 删除一个有序数组的一个元素,采用两个数组实现 代码实现: /* 2017年6月19日16:16:31 功能:删除数组中一个数据之后数组依然有序 */ #include"stdio.h" #define M 9 int main() { int a[M] = {1,2...

    删除有序数组中的元素,数组仍然有序

    方法一:

    删除一个有序数组的一个元素,采用两个数组实现
    代码实现:
    /*
    	2017年6月19日16:16:31
    	功能:删除数组中一个数据之后数组依然有序
    */
    #include"stdio.h"
    #define M 9
    
    int main()
    {
    	int a[M] = {1,2,3,4,5,6,7,8,9};
    	int b[M-1];
    	int i, j, num;
    	bool flag;
    	printf("请输入将要删除的数据的数值:");
    	scanf("%d",&num);
    
    	for( i = 0; i < M ; i++)
    	{
    		if(a[i]==num)
    		{
    			flag = true;
    			break;
    		}
    		
    	}
    
    	if(flag == true)
    	{
    		for( j = 0 ; j < i ;j++)
    		{									//该数的前面的数
    			b[j] = a[j];
    		}
    		for( j = i ; j < M-1 ;j++)
    		{									//该数的后面的数
    			b[j] = a[j+1];
    		}
    		printf("新的数组数据成员:");
    		printf("\n");
    		for(int n = 0; n < M-1; n++)
    		{
    			printf("%d\t",b[n]);
    		}
    		printf("\n");
    	}
    	else
    	{
    		printf("数组中不存在该数值!!!\n");
    	
    	}
    return 0;
    }
    /*
    	总结:
    	在VC++6.0中的显示结果为:
    	——————————————————————————————————————
    	请输入将要删除的数据的数值:10
    	数组中不存在该数值!!!
    
    	请输入将要删除的数据的数值:6
    	新的数组数据成员:
    	1       2       3       4       5       7       8       9
    	——————————————————————————————————————
    	在两个数组中完成的操作
    */
    

     

    方法二:

    删除一个有序数组的指定元素,采用一个数组实现
    代码实现:
    /*
    	2017年6月19日16:16:31
    	功能:删除数组中指定数据元素之后数组依然有序
    */
    #include"stdio.h"
    #define M 9
    
    int main()
    {
    	int a[M] = {1,2,3,6,6,6,7,8,9};
    	int i, j, num;
    	int count = 0;
    	printf("请输入将要删除的数据的数值:");
    	scanf("%d",&num);
    
    	for( i = 0, j = 0; i < M ; i++)
    	{
    		if(a[i]==num)
    		{
    			count++;
    			continue;
    		}
    		else
    		{
    			a[j++] = a[i];
    		}
    		
    	}
    	a[j] = '\0';
    	printf("指定元素的个数  %d",count);
    	printf("\n");
    	printf("新的数组数据元素的形式:");
    	for(i = 0; i < j; i++)
    	{
    		printf("%d\t",a[i]);
    	}
    	printf("\n");
    	  
    return 0;
    }
    /*
    	总结:
    	在VC++6.0中的显示结果为:
    	——————————————————————————————————————
    	请输入将要删除的数据的数值:6
    	指定元素的个数  3
    	新的数组数据元素的形式:1       2       3       7       8       9
    	——————————————————————————————————————
    	在一个数组中完成的操作
    */
    

    方法三:

    #include "stdio.h"
    
    int main()
    {
    	int a[16] = {1,9,9,4,0,5,0,8,0,8,9,9,5,6};
    	int *pa = a;
    	int i, j = 0;
    	for(i = 0; i < 16; i++)
    	{
    		if(a[i] != 5)
    		{
    			a[j++] = *pa;
    			pa++;	
    		}
    		else
    		{
    			pa++;
    			continue;
    		}
    
    	}
    	for(i = 0; i < j; i++)
    		printf("%d",a[i]);
    	return 0;
    }
    

    扩展:将删除的元素最后放在数组后面

    #include "stdio.h"
    
    int main()
    {
    	int a[15] = {1,9,9,4,0,5,0,8,0,8,9,9,5,6};
    	int *pa = a;
    	int i,j,k, count = 0;
    	for(i = 0; i < 15; i++)
    	{
    		if(a[i] == 5)
    		{	a[i] = a[i+1];
    			count++;
    			continue;
    		}
    	}
    	k = count;
    	for(j = 15 - k ; count--; j++)
    	{
    		a[j] = 5;
    	}
    	for(i = 0; i < 15; i++)
    		printf("%d",a[i]);
    	return 0;
    }
    

      

     

      

     

    转载于:https://www.cnblogs.com/wxt19941024/p/7054540.html

    展开全文
  • 思路分析:首先对序列进行排序,接着定义一个指向序列头的指针,逐次向后... * 去重规则:重复元素的第一个删除,第二个倍乘 * 说明:可以使用Arrays.asList(...)将数组转为List; * @param lists 无序序列 * @retu

    思路分析:首先对序列进行排序,接着定义一个指向序列头的指针,逐次向后搜索,直至指针指向序列尾部。指针比较当前元素与下一元素是否相等(重复),相等时移除第一个元素,第二个元素倍乘,再对更新的序列重排序;不相等时,指针右移。

       /**
         * 功能:将无序序列调整为无重复元素的有序序列
         * 去重规则:重复元素的第一个删除,第二个倍乘
         * 说明:可以使用Arrays.asList(...)将数组转为List;
         * @param lists 无序序列
         * @return 无重复元素的有序序列
         */
        public static List<Long> print(ArrayList<Long> lists) {
            Collections.sort(lists); // 让初始数据有序
            int i = 0;
            while (true) {
                if (i == lists.size() - 1) {
                    break;
                }
                int l = i + 1; // 相邻比较
                if (lists.get(i).equals(lists.get(l))) {
                    // 移除两个数,添加一个数
                    lists.remove(i);
                    lists.add(lists.remove(i) * 2);
                    Collections.sort(lists); // 数据更新之后需要重排序
                } else {
                    i = l; // 右移
                }
            }
            return lists;
        }
    
    展开全文
  • 一个无序顺序表中删除重复的元素,并使剩余元素间的相对次序保持不变 */ # include typedef int ElemType; typedef struct { ElemType data[100]; int length; }SqList; int removeSame1(SqList &B) { ...


    设计思想:

    1、对于顺序表B,设B.data[0...j](j的初值为0)无重复元素

    2、令i = 1,用参数k控制while循环来检测B.data[i]与B.data[0...j]的元素是否相同;若B.data[i]与B.data[0...j]的元素均不相同,则将B.data[i]存入B.data[0...j]中,即执行B.data[++j] = B.data[i];

    3、重复执行for循环,直至算法结束

    /* 
    	从一个无序顺序表中删除重复的元素,并使剩余元素间的相对次序保持不变
    */
    # include <stdio.h>
    
    typedef int ElemType;
    typedef struct {
    	ElemType data[100];
    	int length;
    }SqList;
    
    	
    int removeSame1(SqList &B) {				
    	int i, j = 0, k;
    
    	for (i = 1; i < B.length; ++i) {
    		k = 0;
    		while (k <= j && B.data[k] != B.data[i])
    			k++;
    		if (k > j)                       //表示B.data[i]与B.data[0...j]中元素都不相同
    			B.data[++j] = B.data[i];
    	}
    	B.length = j+1;
    
    	return B.length;
    }
    
    
    
    int main() {
    	SqList R;
    	int A[] = {1, 2, 2, 1, 3, 4, 5, 4, 2, 1};
    	int i;
    
    	for (i = 0; i < sizeof(A)/4; ++i)         //顺序表初始化
    		R.data[i] = A[i];
    	R.length = i;
    
    	R.length = removeSame1(R);				  //删除重复元素并返回删除后的表长
    
    
    	printf("删除前:\n");					
    	for (i = 0; i < sizeof(A)/4; ++i)
    		printf("%2d", A[i]);
    	printf("\n");
    
    	printf("删除后:\n");
    	for (i = 0; i < R.length; ++i)			  
    		printf("%2d", R.data[i]);
    	printf("\n");
    
    	return 0;
    }
    /*
    	在Vc++6.0中的输出是:
    				删除前:
    				 1 2 2 1 3 4 5 4 2 1
    				删除后:
    				 1 2 3 4 5
    */



    展开全文
  • 一个递增有序的线性表中,有数值相同的元素存在。若存储方式为单链表,设计算法,去掉数值相同的元素,使得表中不再有重复的元素。例如(7,10,10,21,30,42,42,42,51,70)将变为(7,10,21,30,42,51,...
  • 给定一个有序数组,删除其中部分元素,使得剩下的每个数最多出现2次。要求删除的数的数量尽可能少。 例如: 给出有序数组 A=[1,1,1,2,2,3], 你给出的函数应该返回length =5, A 变为[1,1,2,2,3]. 思路:如果跟...
  • 题目:在一个递增有序的线性表中,有数值相同的元素存在。若存储方式为单链表,设计算法去掉数值相同的元素,使表中不再有重复的元素,例如(7,10,10,21,30,42,42,42,51,70)将变为(7,10,21,30,42,51...
  • public static void main(String[] args) { int[] a={23,34,56,7,8,9}; int[] b = new int[a.length]; Scanner scan = new Scanner... System.out.println("请输入一个整数:"); int num = scan.nextInt(...
  • Codeup问题 F: 算法2-25 有序单链表删除重复元素 题目地址 ...根据一个递增的整数序列构造有序单链表,删除其中的重复元素 输入 输入包括多组测试数据,每组测试数据占一行,第一个为大于等...
  • 如果数组中元素最多允许重复两次呢? 例如: 给出有序数组 A =[1,1,1,2,2,3], 你给出的函数应该返回length =5, A 变为[1,1,2,2,3]. 2 解题思路 暴力法 3 代码实现 class Solution { public: int removeDuplicates...
  • 给出一个升序排序的链表,删除链表中的所有重复出现的元素,只保留原链表中只出现一次的元素。 例如: 给出的链表为1→2→3→3→4→4→5, 返回1→2→5. 给出的链表为1→1→1→2→3, 返回2→3. 2 解题思路 见代码 3 ...
  • 第二种思路,循环比较两个有序数组头位元素的大小,并把头元素放到新数组中,从老数组中删掉,直到其中一个数组长度为0。然后再把不为空的老数组中剩下的部分加到新数组的结尾。(好) 第二种思路的排序算法与测试...
  • 有序链表中删除重复的数字,并且返回删除后的头结点例如输入链表为1->1->2,返回1->2 这题和leetcode26相似,只是数据结构从数组变成了链表 /** * @author rale * * Given a sorted linked list, ...
  • 题目要求: 给定排好顺序的数组,在数组内删除重复项,使每个元素只出现一次并返回不含...对一个排好顺序的数组,我们只需要比较相邻的两个元素是否相同即可判断数组是否含有重复项。 在这里,为了方便,我们采用...
  • 给定一个排序链表,删除所有重复的元素,使得每个元素只出现一次。 示例 1: 输入: 1->1->2 输出: 1->2 示例 2: 输入: 1->1->2->3->3 输出: 1->2->3 /** * Definition for singly-...
  • 【数据结构】 合并两个非递减有序单链表为一个A-B的非递减有序单链表 题目 实现两个单链表La和Lb的相减链表LC,LC的元素为LA中有但LB中没有的元素。LA和LB都为非递减有序链表 分析 LC是LA和LA的相减链表,即LC= ...
  • 12,在一个递增有序的线性表中,有数值相同的元素存在。若存储方式为单链表,设计算法去掉数值相同的元素,使表中不再有重复的元素,例如(7, 10, 10, 21, 30, 42, 42, 42, 51,70)将变为(7, 10, 21, 30, 42, 51, 70) ...
  • 对于数组来说,在尾部插⼊、删除元素是⽐较⾼效的,时间复杂度是 O(1),但是如果在中间或者开头插⼊、删除元素,就会涉及数据的搬移,时间复杂度为 O(N),效率较低。 所以对于⼀般处理数组的算法问题,我们要尽可能...
  • 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 1->2->3->5. 说明: 给定的 n 保证是有效的。
  • 删除元素

    2017-12-27 20:05:04
    题目:输入一个递增有序的整型数组A有n个元素删除下标为i的元素,使其仍保持连续有序。注意,有效下标从0开始。 定义如下两个函数分别实现删除元素操作和数组输出操作。 void del(int a[], int n, int i); /*...
  • 给定一个排序链表,删除所有重复的元素,使得每个元素只出现一次。 示例 1:   输入: 1->1->2   输出: 1->2 示例 2:   输入: 1->1->2->3->3   输出: 1->2->3 #include<stdio...
  • 由于数组已经排序,所以重复的元素一定连在一起,找出它们并不难,但如果毎找到一个重复元素就立即删除它,就是在数组中间进行删除操作,整个时间复杂度是会达到 O(N^2)。而且题目要求我们原地修改,也就是说不能用...
  • 给你一个有序数组 nums ,请你 原地 删除重复出现的元素,使每个元素 最多出现两次 ,返回删除后数组的新长度。 不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下
  • #include<stdio.h> #include<math.h> main() { int a[10]={1,3,4,4,9,14},k,i,x; printf(“请输入新元素值:”);scanf("%d",&x); for(i=0;...printf(“数组变为:”); for(i=0;i<7;i+
  • 一个递增有序的线性表中,有数值相同的元素存在.若存储方式为单链表,设计算法去掉数值相同的元素,使表中不再有重复的元素,例如(7,10,10,21,30,42,42,42,51,70)将变为(7,10,21,30,42,51,70) #include<stdio.h>...
  • 显然,由于数组已经排序,所以重复的元素一定连在一起,找出它们并不难,但如果毎找到一个重复元素就立即删除它,就是在数组中间进行删除操作,整个时间复杂度是会达到O(N^2)。而且题目要求我们原地修改,也就是说...
  • 删除链表中重复的数字(保留一个) 即:2 2 3 3 4 4 5 6 7 8 8 会变为2 3 4 5 6 7 8 删除链表中重复元素(不保留) 即:2 2 3 4 5 6 6会变为3 4 5 #include <cstdio> #include <iostream> ...
  • 对于一个有序数组,如果要查找其中的一个数,我们可以使用二分查找(Binary Search)算法,将它的时间复杂度降低为O(logn).那查找一个有序链表,有没有办法将其时间复杂度也降低为O(logn)呢? 跳表(skip list),全称为...
  • 一个有序数组变成每个数字只能出现一次的数组,由于要求的空间复杂度是O(1)而且是原地修改,所以就很容易联想到用双指针。 一个指针负责遍历数组,另一个在指定位置填入数字。 初始:由于可以保证至少放入一个...

空空如也

空空如也

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

删除一个元素变成有序