精华内容
下载资源
问答
  • js代码-有序数组在保持数组有序的情况下插入数字。 两种实现方式
  • 百度真题:操作最小使数组有序

    千次阅读 2018-08-22 00:27:11
    度度熊有一个N个数的数组,他想将数组从小到大 排好序,但是萌萌的度度熊只会下面这个操作: 任取数组中的一个数然后将它放置在数组的最后一个位置。 问最少操作多少次可以使得数组从小到大...

    题目连接:https://www.nowcoder.com/question/next?pid=4998655&qid=95824&tid=17782195

    时间限制:1秒

    空间限制:32768K

    度度熊有一个N个数的数组,他想将数组从小到大 排好序,但是萌萌的度度熊只会下面这个操作:
    任取数组中的一个数然后将它放置在数组的最后一个位置。
    问最少操作多少次可以使得数组从小到大有序? 

    输入描述:

    首先输入一个正整数N,接下来的一行输入N个整数。(N <= 50, 每个数的绝对值小于等于1000
    

    输出描述:

    输出一个整数表示最少的操作次数。
    

    输入例子1:

    4
    19 7 8 25
    

    输出例子1:

    2

    // 百度-最小移动次数.cpp : 定义控制台应用程序的入口点。
    /*
        思路:
        用到的数据可以为 vector<int> v 和 map
        1 把原数组排好序  原数组的输入可以为vector  排序的时候,直接用sort(v.begin(),v.end()) 原地排序 v

        2 原始数组用map<int ,int > m 进行维护:key为原始数据,value为元素的下表位置;

        3 以v为基础,看v的相邻两个在以其值为键值的map中的value(下标)是否是递增的,如果不是就需要把其值移动到数组最后,更新后继续遍历。

        为什么这样做是对的:
           跟着排好序的数组,在未排好序的数组中,放在最后面的值一定是还处于乱序中的数字中的最小值,有了这个思想,本题就顺理成章的理解了。

        之前有一些误解:
        找出原数组中有序的个数,无序的就是需要排列的。显然不对,举例:5 1 2 4 7 8 。 因为有只能放在最后的限制,所以这样显示是不对的。
        正确思路分析:
        所以,单纯的看原序列的顺序是没有意义的。只能通过原数组与排序好的数组进行对比,只要是相邻间的数发生了变化,就要把其放在最后的位置
        更新位置后再次进行比较。整体遍历一遍就可以了
    */

    #include "stdafx.h"
    #include<vector>
    #include<map>
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int Solution()
    {
        int N;
        cin >> N;
        vector<int> v;
        map<int, int> mapArr;  
        //因为需要既能够把输入的值放入到vector中,又希望能以输入的值为key,以下标作为value,所以选择for循环
        for (int i = 0; i <N; i++)
        {
            int temp;
            cin >> temp;  //遇到空格,代表语句执行完毕,但是后面还有没有数据,看输入
            v.push_back(temp);
            mapArr[temp] = i;
        }
        sort(v.begin(), v.end());
        int count = 0;
        int t = N;   //t的作用是把要调整的是放在数组的最后面
        for (int i = 0; i <N-1; i++)
        {
            if (mapArr[v[i]]>mapArr[v[i+1]])   
            {
                mapArr[v[i + 1]] = t++;   //1)为什么把原数组的元素放在了最后还不会越界:因为map中用的是元素的值为key,key是不变的,所以能找到
                                           // 同时也够进一步的迭代,遍历一遍就好了
                count++;
            }
        }
        cout << count << endl;
        return 0;
    }


    int main()
    {

    int a=Solution();

    return 0;

    }
     

    展开全文
  • 删除最短的子数组使剩余数组有序方法:双指针思路:代码:Python3:cpp:结果: leetcode1574. 删除最短的子数组使剩余数组有序 给你一个整数数组 arr ,请你删除一个子数组(可以为空),使得 arr 中剩下的元素是 ...

    leetcode1574. 删除最短的子数组使剩余数组有序

    给你一个整数数组 arr ,请你删除一个子数组(可以为空),使得 arr 中剩下的元素是 非递减 的。

    一个子数组指的是原数组中连续的一个子序列。

    请你返回满足题目要求的最短子数组的长度。

    示例 1:

    输入:arr = [1,2,3,10,4,2,3,5]
    输出:3
    解释:我们需要删除的最短子数组是 [10,4,2] ,长度为 3 。剩余元素形成非递减数组 [1,2,3,3,5] 。
    另一个正确的解为删除子数组 [3,10,4] 。
    

    示例 2:

    输入:arr = [5,4,3,2,1]
    输出:4
    解释:由于数组是严格递减的,我们只能保留一个元素。所以我们需要删除长度为 4 的子数组,要么删除 [5,4,3,2],要么删除 [4,3,2,1]。
    

    示例 3:

    输入:arr = [1,2,3]
    输出:0
    解释:数组已经是非递减的了,我们不需要删除任何元素。
    

    示例 4:

    输入:arr = [1]
    输出:0
    

    提示:

    • 1 <= arr.length <= 10^5
    • 0 <= arr[i] <= 10^9

    方法:双指针

    思路:

    本题可以使用栈的方法解决。

    本题删除的子数组只有三种情况,即从头开始的左边某子数组、中间的某子数组、从某点到最后的子数组。而这三种情况本质上可以当做是一种情况,即都当做是从中间删除的(从头删除可以当做左边数组为空,删除右边的数组可以当做右边数组为空)。

    因此我们需要找到左边的非递减数组和右边的非递减数组,此时中间的部分是无序的,因此需要删除。因为我们不能保证左边数组的最大值小于等于右边数组的最小值,因此,我们还需要调整两个边界(即需要删除的子数组的左右边界)。

    我们使用指针right来保存左边的非递减数组右边界下标,当遇到递减情况则停止。然后继续遍历,找到右边的非递减数组的左边界left。

    那么我们如何判断删除数组的左右边界呢?

    一个简单的方法是遍历左边数组的所有可能下标和右边数组的所有可能下标,两两配对当做删除数组的左右下标,看此时剩余数组是否满足为非递减数组,找到删除长度最小的情况。但是这样时间复杂度较高。

    因为左边数组和右边数组都是有序的,因此我们可以这样进行判断:

    • 指针i表示最后右边数组接入左边数组的起点,即i-1为删除数组的右边界。
    • 我们的i从n-1开始向前遍历到left,位于i点时,如果此时arr[i]>=arr[right],那么左边的数组和右边的数组正好可以凑成非递减数组,删除数组的左边界为right-1,那么删除的数组长度为i-right-1
    • 如果此时arr[i]<arr[right],那么此时,i点继续缩小的话同样有这个关系式,构不成非递减数组,那么此时就应该缩小左边数组的长度了,即调整删除数组的左边界,right–,直到arr[i]>=arr[right],再继续计算。
    • 维护一个变量,保存最小的删除长度。
    • 这种双指针的做法大大降低了时间复杂度,时间复杂度为O(n)。

    代码:

    Python3:

    class Solution:
        def findLengthOfShortestSubarray(self, arr: List[int]) -> int:
            # right表示左边数组的右边界
            right = 0
            n = len(arr)
            res = 0
            i = 1
            # 从头开始的递增序列
            while i < n and arr[i] >= arr[right]:
                right = i
                i += 1
            # res初始化为后面所有的长度(即只留下左边的有序数组,后边全删除,这是最大的res值)
            res = n-1-right
            left = i
            # 找到尾部的递增有序序列的起点left
            for i in range(left+1,n):
                if arr[i] >= arr[i-1]:
                    pass
                else:
                    left = i
            # print(left)
            #[left,n-1]是非递减有序的
            # 可以从右边的有序数组中找某个点i开始接入左边的有序数组中形成新的完整的有序数组
            # 这样只需要删除中间的子数组即可,找到删除最小的情况
            for i in range(n-1,left-1,-1):
                while right >= 0 and arr[i] < arr[right]:
                    right -= 1
                res = min(res,i-right-1)
            return res      
    

    cpp:

    class Solution {
    public:
        int findLengthOfShortestSubarray(vector<int>& arr) {
            // right表示左边数组的右边界
            int right = 0, n = arr.size(),res = 0,i = 1;
            // 从头开始的递增序列
            while (i < n && arr[i] >= arr[right]){
                right = i;
                i ++;
            }  
            // res初始化为后面所有的长度(即只留下左边的有序数组,后边全删除,这是最大的res值)
            res = n-1-right;
            int left = i;
            // 找到尾部的递增有序序列的起点left
            for (int i = left+1;i < n; i++){
                if (arr[i] >= arr[i-1])
                    continue;
                else
                    left = i;
            }    
            // [left,n-1]是非递减有序的
            // 可以从右边的有序数组中找某个点i开始接入左边的有序数组中形成新的完整的有序数组
            // 这样只需要删除中间的子数组即可,找到删除最小的情况
            for (int i = n-1; i >= left ;i--){
                while (right >= 0 && arr[i] < arr[right])
                    right --;
                res = min(res,i-right-1);
            }          
            return res;
    
        }
    };
    

    结果:

    展开全文
  • printf ("请输入第一组数组中的数:"); for (i=0; i; i++){ scanf ("%d", &num1[i]); num3[i]=num1[i]; } printf ("请输入第二组数组中的数:"); for (i=0; i; i++){ scanf ("%d", &num2[i]); ...
  • //查找数组中指定元素(二分查找–常见面试题:前提是数组有序) //以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. // 如果小, 就去左边找; 否则就去右边找. public class ...

    package cn.arry;

    //查找数组中指定元素(二分查找--常见面试题:前提是数组有序)
    //以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小.
    // 如果小, 就去左边找; 否则就去右边找.
    
    public class Test7_binarySearch {
        public static void main(String[] args){
            int[] arr={1,2,3,4,5,6};
            System.out.print(binarySearch(arr,4));
        }
        public static int binarySearch(int[] arr,int toFind){
            int left=0;
            int right=arr.length-1;
            while (left <= right){
                int mid=(left+right)/2;
                if (toFind < arr[mid]){
                    //在左侧找
                    right=mid-1;
                }else if (toFind > arr[mid]){
                    //在右侧找
                    left=mid+1;
                }else {
                    return mid;
                }
            }
            return -1;//没有找到
        }
    }
    
    展开全文
  • 给出n个元素,不一定有序,分别按...第一种情况:原数组逐个与有序序列比对,如果不在自己本该的在的位置上,就交换一次; 方法一: #include<bits/stdc++.h> using namespace std; int main() { int n; wh...

    给出n个元素,不一定有序,分别按以下要求进行排序:
    (1)每次只能交换两个元素;
    题目来源:CTU Open Contest 2017 H题
    (2)每次只能把元素移到第一个位置;
    题目链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=6006
    AC代码:
    分别求出在这两种情况下移动的最少次数
    第一种情况:原数组逐个与有序序列比对,如果不在自己本该的在的位置上,就交换一次;

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int n;
    	while(scanf("%d",&n)!=EOF)
    	{
    		int a[n];
    		for(int i=1;i<=n;i++)
    		{
    			scanf("%d",&a[i]);
    		}
    		
    		int sum=0,ans;
    		for(int i=1;i<=n;i++)
    		{
    			if(i!=a[i])
    			{
    				int temp=i;
    				ans=0;
    				while(i!=a[temp])//逐步交换
    				{
    					int t=temp;
    					temp=a[temp];
    					a[t]=t;
    					ans++;
    				}
    				a[temp]=temp;
    				sum+=ans;
    			}
    		}
    		printf("%d\n",sum);
    	}
    	return 0;
    }
    

    第二种情况:拿一个已经排好序的数组从后面开始比较,有序的直接跳过,记录无序的数量,即为要移动的;

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
       int t;
       scanf("%d",&t);
       while(t--)
       {
       	int n;
       	scanf("%d",&n);
       	int a[n],b[n];
       	for(int i=0;i<n;i++)
       	{
       		scanf("%d",&a[i]);
       		b[i]=a[i];
       	}
       	
       	sort(b,b+n);//b数组已经排好序,作为参照;
       	int pa,pb,ans=0;
       	for(pa=n-1,pb=n-1;pa>=0;)//从后面开始比对,已经有序的就不要管了
       	{
       		if(a[pa]==b[pb])
       		{
       			pa--;
       			pb--;
       		}
       		else if(a[pa]!=b[pb])
       		{
       			ans++;
       			pa--;
       		}
       		if(pa<0)
       		break;
       	}
       	printf("%d\n",ans);
       }
       return 0;
    } 
    

    因为见过几次这种类型的题,也走过弯路,所以小小总结一下,后面再又遇到,再加进来;

    展开全文
  • Java有序数组

    2021-03-06 00:06:27
    1:有序数组简介,以及优缺点2:构建有序数组在数组增删改查功能里,我们是如何让数组有序的呢?肯定是添加方法1:我们在添加的时候可以进行一个判断2:判断我们这个新添加的数据到底是添加在哪个地方在哪个位置//接...
  • 问最少操作多少次可以使得数组从小到大有序? 如:输入 4 19 7 8 25 输出:2 思路: 复杂度 nlogn 但是需要一个 n 的辅助数组 用一个辅助数组对所有元素进行排序,从小到大排序 从第一个排好序的元素开始,即...
  • 今天小编就为大家分享一篇java实现把两个有序数组合并到一个数组的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • java数组实现针对一个有序的数组插入一个数据并保持数组有序
  • JAVA判断数组是否有序

    2020-12-14 15:45:20
    判断数组是否有序1.问题2.分析3.代码实现 1.问题 给定一个数组,判断其是否有序,输出有序或无序; 2.分析 与数组排序类似,将数组从前往后进行比较,如果数组大下标中的元素比小下标中的元素小,则无序, 3.代码...
  • 将两个有序数组,合并成另一个有序数组,升序。将两个有序数组,合并成另一个有序数组,升序。将两个有序数组,合并成另一个有序数组,升序
  • 校验Java中的数组是否有序

    千次阅读 2019-09-11 09:12:37
    在本篇文章中,我们会学习用不同的方式来检查Java数组中的元素是否有序。 在开始学习之前,你需要了解一下在Java中如何对数组排序 2.使用循环 使用for循环可以来检查Java数组中的元素是否有序。我们可以通过迭代比较...
  • 数组数组存储具有相同数据结构的元素集合,一维数组占有一块内存空间,数组一旦占用存储空间(连续),其地址和容量就是确定的,不能改变。 下面是详细的代码和实现结果: package array; import java.util....
  • 无序数组有序数组

    千次阅读 2019-05-11 10:34:56
    有序数组的最大的好处在于查找的时间复杂度是O(log n),而无序数组的时间复杂度是O(n)。 有序数组的缺点是插入的世家复杂度是O(n),因为值大的元素需要往后移来给新元素腾位置,相反,无序数组的插入时间...
  • 无序数组 增 添加数据 ,首先先将数组转移到另一个空间遍历一遍时间复杂度为O(n),再添加 总计时间复杂度为O(n) 删 先查找数据复杂度为O(n)然后删除 添加的数后面索引减...有序数组 增 添加数据 ,首先先将数组转...
  • 删除最短的子数组使剩余数组有序 题意: 给你一个整数数组 arr,请你删除一个子数组(可以为空),使得 arr中剩下的元素是 非递减 的。 一个子数组指的是原数组中连续的一个子序列。 请你返回满足题目要求的...
  • 判断一个数组是否为有序数组 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<assert.h> bool Monoton(int* br, int n) { assert(br != nullptr && n > 1)...
  • Java中检查数组是否有序

    千次阅读 2019-09-20 20:08:58
    Java中检查数组是否有序
  • // 数组元素是否有序,升序 // @param arr 待检查数组 // @param length 数组长度 // @return true 为是升序 func isArraySort(arr []int, length int) bool { if length == 1 { return true }else{ if arr...
  • 问题:N个数的数组,x1,x2,……,xn,判定该数组是否有序。 定义ε远离:必须删除大于εn个元素才能保证剩下的元素有序。 亚线性算法: for k=1 to 2/ε do  选择数组中第i个元素xi  用xi在数组中做二分...
  • 题目:有两个有序数组a和b,将它们合并成数组c,需要c也是有序数组。 具体思路: 将新建一个长度为a和b长度之和的数组,将较长的数组复制到新数组,将较短的数组每个元素插入到指定位置(用到插入排序算法)。 ...
  • 一共5个步骤,完成有序插入: (1)用Arrays.copyOf新建长度+1的数组,作为即将插入元素的数组 (2)获取新元素值 (3)通过比较元素值大小,查找新元素将要插入的下标index (4)下标为chars1.length-2~index的元素...
  • 对于两个有序数组arr1和arr2,arr1的末尾有足够的空间可以容纳arr2。 把arr2的所有数组插入arr1中,使得插入后的数组仍然是个有序数组。 解决思路是从尾到头比较arr1和arr2中的数字的大小,然后将较大的数字插入到...
  • 判断一个数组是否有序

    万次阅读 2017-07-18 20:03:28
    一般来说,判断一个数组或序列是正序,倒序还是乱序,需要我们将这个数组完整的遍历一遍后才能得出答案,它不像折半查找那样只处理少量的数据便能得出结论,因为一段包含成千上万个元素的有序序列,哪怕将其中两个元素的...
  • 将两个整型数组有序合并成一个数组 //将两个整型数组合并成一个 public int[] merge(int[] a,int[] b){ int alen = a.length; int blen = b.length; a = Arrays.copyOf(a, alen+blen); Sy
  • /*练习:有一个有序数组,想要将一个元素插入到该数组中,还要保证该数组有序的如何获取该元素在数组中的位置。*/class ArrayTest4{ public static void main(String[] args)  { /*int[] arr={3,2,1,5,4,2,9};...
  • 数组-有序插入(c++)

    千次阅读 2020-07-16 17:18:14
    有序插入 题目描述 有一个已排好序的数组,要求输入一个数后,按原来排序的规律将它插入到数组中。 假设数组长度为10,数组中前9个数(这9个数要求从键盘上输入,输入时要满足自小到大的输入顺序)已经按从小到大...
  • Java实现有序数组和无序数组

    千次阅读 2018-09-05 20:03:38
    描述: 线性表是其组成元素之间具有线性关系的一种线性结构。...数组是实现顺序存储的基础。在程序设计语言中,数组是一种构造数据类型。          时间复杂度表:   增加 查找 删除 更改 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 381,706
精华内容 152,682
关键字:

数组有序