题目1431:Sort

时间限制:1 秒

内存限制:128 兆

特殊判题:

题目描述:

给你n个整数,请按从大到小的顺序输出其中前m大的数。

输入:

每组测试数据有两行,第一行有两个数n,m(0<n,m<1000000),第二行包含n个各不相同,且都处于区间[-500000,500000]的整数。

输出:

对每组测试数据按从大到小的顺序输出前m大的数。

样例输入:
5 3
3 -35 92 213 -644
样例输出:
213 92 3
#include <iostream>
#include <iostream>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#define OFFSET 500000
using namespace std;
int Hash[1000001];

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=-500000; i<=500000; i++)
        {
            Hash[i+500000]=0;
        }
        for(int i=1; i<=n; i++)
        {
            int x;
            scanf("%d",&x);
            Hash[OFFSET+x]=1;
        }
        for(int i=500000; i>=-500000; i--)
        {
            if(Hash[OFFSET+i]==1)
            {
                printf("%d",i);
                m--;
                if(m!=0)
                {
                    printf(" ");
                }
                else
                {
                    printf("\n");
                    break;
                }
            }
        }
    }
    return 0;
}

时间: 2024-10-20 19:56:41

题目1431:Sort的相关文章

147. Insertion Sort List

题目: Sort a linked list using insertion sort. 思路: 链表的插入排序和数组的插入排序略有不同.以链表4->2->3->1->5为例,为方便操作添加一个头节点-1,此时链表为-1->4->2->3->1->5.基本思路为一次选择前后两个节点,若后节点大于前节点则不断向后循环,若后节点小于前节点则取出后节点,并插入到头节点和前节点之间的位置. 举例说明: 头节点为-1,cur为节点4,nextnode为节点2.此

【LeetCode】 sort list 单链表的归并排序

题目:Sort a linked list in O(n log n) time using constant space complexity. 思路:要求时间复杂度O(nlogn) 知识点:归并排序,链表找到中点的方法 存在的缺点:边界条件多考虑!!! /** * LeetCode Sort List Sort a linked list in O(n log n) time using constant space complexity. * 题目:将一个单链表进行排序,时间复杂度要求为o

【链表】Insertion Sort List

题目: Sort a linked list using insertion sort. 思路: 插入排序是一种O(n^2)复杂度的算法,基本想法相信大家都比较了解,就是每次循环找到一个元素在当前排好的结果中相对应的位置,然后插进去,经过n次迭代之后就得到排好序的结果了.了解了思路之后就是链表的基本操作了,搜索并进行相应的插入.时间复杂度是排序算法的O(n^2),空间复杂度是O(1). /** * Definition for singly-linked list. * function Lis

148. Sort List (java 给单链表排序)

题目:Sort a linked list in O(n log n) time using constant space complexity. 分析:给单链表排序,要求时间复杂度是O(nlogn),空间复杂度是O(1).时间复杂度为O(nlogn)的排序算法有快速排序和归并排序, 但是,对于单链表来说,进行元素之间的交换比较复杂,但是连接两个有序链表相对简单,因此这里采用归并排序的思路. 编码: public ListNode sortList(ListNode head) { if(hea

【Sort List】cpp

题目: Sort a linked list in O(n log n) time using constant space complexity. 代码: /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNo

leetcode 147. Insertion Sort List (Python版)

题目: Sort a linked list using insertion sort. 大意是要实现一个链表的插入排序 算法思路:     从原链表中逐个弹出一个node 对于每一个node用插入排序的思想插入新的升序排列的链表中 这里有一个小trick,leetcode有一组数据是1~4999的升序序列,如果我们采用如上方法会超时 于是我们在插入排序的时候设置一个last位,记录当前插入的位置 在下一次插入的时候与上次插入位置last比较,如果当前node.val > last.val,那么

leetcode 【 Insertion Sort List 】 python 实现

题目: Sort a linked list using insertion sort. 代码:oj测试通过 Runtime: 860 ms 1 # Definition for singly-linked list. 2 # class ListNode: 3 # def __init__(self, x): 4 # self.val = x 5 # self.next = None 6 7 class Solution: 8 # @param head, a ListNode 9 # @re

【Lintcode】098.Sort List

题目: Sort a linked list in O(n log n) time using constant space complexity. Example Given 1->3->2->null, sort it to 1->2->3->null. 题解: O(n log n) : 快速排序,归并排序,堆排序 Solution 1 () class Solution { public: ListNode *sortList(ListNode *head) {

【链表】Sort List(归并排序)

题目: Sort a linked list in O(n log n) time using constant space complexity. 思路: nlogn的排序有快速排序.归并排序.堆排序.双向链表用快排比较适合,堆排序也可以用于链表,单向链表适合用归并排序. /** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this.next = null; * } */