精华内容
下载资源
问答
  • 从含有n个整数无序数组中找到每元素后面比它大的第一数,要求时间复杂度为O(N)。 解题思路 如果没有时间复杂度要求的话,可以使用二重遍历进行暴力解决。然而参考了各种大牛的博客,将自己的思路总结如下。 ...

    复习时候看到的一道题,总结了总结。

    题目描述

    从含有n个整数的无序数组中找到每个元素后面比它大的第一个数,要求时间复杂度为O(N)。

    解题思路

    如果没有时间复杂度要求的话,可以使用二重遍历进行暴力解决。然而参考了各种大牛的博客,将自己的思路总结如下。

    我们借助了辅助栈的方式进行解决。

    对于当前遍历的第i个元素有:

    1. 栈为空,则当前索引i入栈;
    2. 栈不为空,如果栈顶索引元素大于等于当前元素,则将当前索引i入栈;(目的是为了保持栈从栈底到栈顶非升序)
    3. 栈不为空,当前元素大于栈顶索引元素,则栈顶索引元素对应的第一个比它大的元素就是当前元素,保存当前元素;同时为了保证栈底到栈顶非升序需要将栈顶元素弹出,直到满足1、2条件。
    4. 输入遍历完,栈中还剩余的元素则是不能找见之后比他大的元素。

    AC代码

    vector<int> findMax(const vector<int>& nums)
    {
    	int n = nums.size();
    	if (n == 0)
    		return vector<int>();
    	vector<int> res(n);
    	int i = 0;
    	stack<int> s;
    	while (i < n)
    	{
            //这个if将1、2两个条件写到一起了
    		if (s.empty() || nums[s.top()] >= nums[i])
    			s.push(i++);
    		else
    		{
    			res[s.top()] = nums[i];
    			s.pop();
    		}
    	}
    	//处理当前栈中剩下的元素,也就是找不到它之后比它大的元素
    	while (!s.empty())
    	{
    		res[s.top()] = INT_MAX;
    		s.pop();
    	}
    	return res;
    }

     

    展开全文
  • n个整数无序数组,找到每元素后面比它大的第一数,要求时间复杂度为O(N) 今天看到的这样的一题,感觉还是挺有意思的,记录下来 它给出了一函数,填写以下函数完成功能 vector<int> FindMax(vector<...

    题目:n个整数的无序数组,找到每个元素后面比它大的第一个数,要求时间复杂度为O(N)

    今天看到的这样的一题,感觉还是挺有意思的,记录下来

    它给出了一个函数,填写以下函数完成功能

    vector<int> FindMax(vector<int> &num)
    {
    }
    

    从函数可以看出传入的无序数组使用vector来存储的,而且我们需要返回一个vector

    一开始拿到题目,我们很容易想到对于每个元素,遍历它后面的元素就能找到第一个比它大的了,但是这样的话时间消耗可能会超过O(N),因此在这当中可能会漏到很多信息,以至于我们每次都要去比较。那应该用什么呢?
    可以设想一下:如果我当前的处理对象是第1个元素,如果第2个元素比我小,那么我现在要做的不是去比较第3个元素与第1个元素的关系,而是将处理的对象变成第2个元素。如果第3个元素比第2个元素大,我在回过来比较第1个元素,这样是不是就省去了很多时间?

    因此我们需要一个容器来存储未处理的元素,可以看到,元素是后进先出的,比如第2个元素,后后到来却是先得到结果的。因此我们可以用栈(stack) 来存储未处理的元素

    根据以上思想可以得出以下代码:

    vector<int>  FindMax(vector<int> &num)
    {
        int len=num.size();
        if(len==0) return {};    //空数组,返回空
        vector<int> res(len,-1);    //返回结果:初始化-1,表示未找到
        stack<int> notFind; //栈:num中还未找到符合条件的元素索引
    
        int i=0;
        while(i<len)    //遍历数组
        {
             //如果栈空或者当前num元素不大于栈顶,将当前元素压栈,索引后移
            if(notFind.empty() || num[notFind.top()]>=num[i])
            {
                notFind.push(i++);
            }
           //有待处理元素,且num当前元素大于栈顶索引元素,符合条件,更新结果数组中该索引的值,栈顶出栈。
            else
            {
                res[notFind.top()]=num[i];
                notFind.pop();
            } 
        }
     return res;
    }
    

    可以输入几个测试样例,比如:

     vector<int> num = {1, 3, 2, 4, 99, 101, 5, 8};
    

    得到结果如下(-1表示后面没有比自己大的):
    在这里插入图片描述

    展开全文
  • 题目描述 ...输入第二行一个整数K,K在数组长度范围内,如:2 输出描述: 输出第K大的数,本例为第2大数:45 示例1 输入 45 67 33 21 2 输出 45 这一道题目排序的时间复杂度是NlogN, ...

    题目描述

    给定无序整数序列,求其中第K大的数,例如{45,67,33,21},第2大数为45

    输入描述:

    输入第一行为整数序列,数字用空格分隔,如:45 67 33 21
    输入第二行一个整数K,K在数组长度范围内,如:2

    输出描述:

    输出第K大的数,本例为第2大数:45

    示例1

    输入

    45 67 33 21
    2
    

    输出

    45

    这一道题目排序的时间复杂度是NlogN, 维护一个k个元素的最小堆,时间复杂度是NlogK, 空间复杂度是O(k) ,最优解法是快排的过程,时间复杂度为O(N)

    另外注意,这道题目的输入输出比较繁琐,用C++的sstream

     

    #include <iostream>
    #include <string>
    #include <sstream> 
    using namespace std;
    
    const int N = 1000000;
    
    // 这个函数的作用是将array前k大的元素都弄到右边
    void arrangeRight(int arr[], int k, int start, int end) 
    {
    	int key = arr[start];
    	int left = start, right = end;
    	while (left != right) {
    		while (left <right && arr[right] >= key) right--;
    		swap(arr[left], arr[right]);
    		while (left < right && arr[left] <= key) left++;
    		swap(arr[left], arr[right]);
    	}
    	if (end - left + 1 == k)          // 右边恰好是有k个元素
    		return;
    	else if (end - left + 1 > k)      // 如果右边多余k个元素
    		arrangeRight(arr, k, left + 1, end);
    	else                              // 
    		arrangeRight(arr, k-end+left-1, start, left-1);
    }
    
    int main()
    {
        int array[N];
        string str;
        getline(cin,str);
        int k,temp,i=0;
        cin>>k;
        istringstream strm(str);
        while(strm>>temp){
            array[i++]=temp;
        }
        int n = i-1;
        arrangeRight(array, k, 0,n);
        cout<<array[n-k+1]<<endl;       // 当k的1,输出的是最后一个, 所以n-k+1
    }

     

    展开全文
  • 个N个整数无序数组,给你一数sum,求出数组中是否存在两数,使他们的和为sum O(nlogn) 解题思路: 先排序 在左右夹击判断。 [cpp] view plaincopy /* 一个N个整数无序数组

    原文: http://blog.csdn.net/swgshj/article/details/7875482


    问题描述:

    一个N个整数的无序数组,给你一个数sum,求出数组中是否存在两个数,使他们的和为sum O(nlogn)


    解题思路:

    先排序 在左右夹击判断。

    1. /* 
    2. 一个N个整数的无序数组,给你一个数sum,求出数组中是否存在两个数,使他们的和为sum O(nlogn) 
    3. 解题思路:先排序 在左右夹击判断 
    4. */  
    5. #include <stdio.h>  
    6.   
    7. int find(int a[], int len, int sum, int *x, int *y)  
    8. {  
    9.   
    10.     int i = 0, j = len - 1;  
    11.   
    12.     if (sum < a[0]) {  
    13.         return -1;  
    14.     }  
    15.   
    16.     while (i != j) {  
    17.         if (a[i] + a[j] == sum) {  
    18.             *x = a[i]; *y = a[j];  
    19.             return 0;  
    20.         }  
    21.         else if (a[i] + a[j] > sum) {  
    22.             j--;  
    23.         }  
    24.         else {  
    25.             i++;  
    26.         }  
    27.   
    28.     }  
    29.   
    30.     return -1;  
    31. }  
    32.   
    33.   
    34. //test  
    35. int main()  
    36. {  
    37.     int a[] = {1,3,5,7,9,11,25,26,30,35,50};  
    38.     int sum = 32, x = 0, y = 0;  
    39.       
    40.     for(sum = 0; sum < 86; sum++)  
    41.     {  
    42.         if (-1 != find(a, sizeof(a) / sizeof(a[0]), sum, &x, &y)) {  
    43.             printf("find: sum=%d, (%d, %d)\n", sum, x, y);  
    44.         }  
    45.         else {  
    46.             printf("not find\n");  
    47.         }  
    48.     }  
    49.   
    50.     return 0;  
    51. }  


    总结:

    相信自己,你的答案就是正确的,面试需要自信。


    展开全文
  • 题目:n个整数无序数组,找到每元素后面比他大的第一元素,(要求时间复杂度为O(N)) 参考答案: vector<int> findMax(vector<int> num) { if(!num.size()) return num; //num为空则直接返回 ...
  • n个整数无序数组,找到每元素后面比它大的第一数,要求时间复杂度为O(N)
  • n个整数无序数组,找到每元素后面比它大的第一数,要求时间复杂度为O(N) class Solution: def ss(self, l): len_l = len(l) if len_l == 0: return l # 栈 array = [] # 返回的数组 r...
  • 有1包含N个整数数组A,定义1个数组的美丽值为数组中所有不同整数的和。求数组A的所有连续子序列的美丽值之和。
  • n个整数无序数组,找到每元素后面比它大的第一数,要求时间复杂度为 O(n) C++代码实现: #include <iostream> #include <vector> #include <stack> using namespace std; vector<int>...
  • 将一包含m个整数数组分成n个数组,每个数组的和尽量接近 3 思路 这问题是典型的动态规划的问题,理论上是无法找到最优解的,但是本次只是为了解决实际生产中的问题,而不是要AC,所以我们只需要找到一相对...
  • 先快速排序 #include #define count(a) sizeof(a)/sizeof(int) int main() ...%d+%d=%d\n " ,s[i],s[j],sum); i ++ ; } } if (!g) printf( " Not found!\n " ); return 0 ; }  
  • 个无序数组里有若干整数,范围从1到100,其中98个整数都出现了偶数次,只有两个整数出现了奇数次(比如1,1,2,2,3,4,5,5),如何找到这出现奇数次的整数? 解法: 遍历整个数组,依次做异或运算。由于数组...
  • 长度相同,元素为随机整数无序数组,交换位置,使得两数组的和的差值最小。 面试时,很多公司都会存在笔试这一环节,虽然心里一万不想写,但是毕竟是一打工仔,还是得老老实实的服从公司安排。 ...
  • 给定一个无序数组arr,找到数组中未出现的最小正整数 例如arr = [-1, 2, 3, 4]。返回1 arr = [1, 2, 3, 4]。返回5 [要求] 时间复杂度为O(n)O(n),空间复杂度为O(1)O(1) 示例1 输入 [-1,2,3,4] 返回值 1...
  • 给定一个无序整数类型数组,求最长的连续元素序列的长度。 例如: 给出的数组为[100, 4, 200, 1, 3, 2], 最长的连续元素序列为[1, 2, 3, 4]. 返回这序列的长度:4 你需要给出时间复杂度在O(n)之内的算法 ...
  • 给出一个整数K和一个无序数组A,A的元素为N个互不相同的整数,找出数组A中所有和等于K的数对。例如K = 8,数组A:{-1,6,5,3,4,2,9,0,8},所有和等于8的数对包括(-1,9),(0,8),(2,6),(3,5)。 Input 第1行:用空格...
  • 给出一个无序整数数组,求不在给定数组里的最小的正整数 例如: 给出的数组为[1,2,0] 返回3, 给出的数组为[3,4,-1,1] 返回2. 你需要给出时间复杂度在O(n)之内并且空间复杂度为常数级的算法 import java....
  • 无序数组中最小的k

    千次阅读 2016-04-07 19:04:34
    对于一个无序数组,数组中元素为互不相同的整数,请返回其中最小的k数,顺序与原数组中元素顺序一致。 给定一个整数数组A及它的大小n,同时给定k,请返回其中最小的k数。 测试样例: [1,2,4,3],4,2 返回:[1...
  • 我的思路是返回的这最小正整数的最大值是数组长度加一,也就是当数组里面得数正好是从1到数组长度n数都有,这时候返回的是n+1,其他情况返回的数都必然小于n+1。于是依次遍历数组里的数是否等于从1到n中间的数...
  •  Python——无序数组中找出和为N的两数(三数、四数) 【问题描述】无序数组中找出和为N的两数,例如,nums = [1, 4, 3, 2, 6, 5]中找出和为target = 6的序列,答案:[(1, 5), (4, 2)]。 参考博客: 1、...
  • 个无序数组里有99不重复正整数,范围从1到100,唯独缺少一个整数。如何找出这缺失的整数? 题目扩展:一个无序数组里有若干整数,范围从1到100,其中99个整数都出现了偶数次,只有一个整数出现了奇数次...
  • 给定一个无序数组,包含正数、负数和0,要求从中找出3数的乘积,使得乘积最大,要求时间复杂度:O(n),空间复杂度:O(1) 输入描述: 输入共2行,第一行包括一个整数n,表示数组长度 第二行为n个以空格隔开的整数...
  • 给定一个无序数组arr,找到数组中未出现的最小正整数 例如arr = [-1, 2, 3, 4]。返回1 arr = [1, 2, 3, 4]。返回5 [要求] 时间复杂度为O(n),空间复杂度为O(1) 题目分析 原地哈希,把数组中取值在1到n的数放到对应的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,620
精华内容 13,448
关键字:

n个整数的无序数组