精华内容
下载资源
问答
  • 内容提要:文章介绍excel时间排序中的分别年和讲解时间排序方法。对Excel感兴趣的朋友可加Excel学习交流群:284029260(www.itblw.com)  有时我们因工作原因需要进行excel时间排序。  第,excel时间排序...
    内容提要:文章介绍excel时间排序中的分别按年和月讲解时间排序方法。对Excel感兴趣的朋友可加Excel学习交流群:284029260(www.itblw.com

      有时我们因工作原因需要进行excel时间排序。

      第一,excel时间排序:按年排序

      如下面的截图,需要对B列的时间按年排序。

    excel时间排序

      方法很简单,单击数据——排序,弹出“排序”对话框,按“出生日期”升序排序就完成了excel时间排序:按年排序。

    excel时间排序1

      第二,excel时间排序:按月排序

      还是以上面的截图为例,如果需要完成excel时间排序:按月排序,我们在C列添加一个辅助列,C2输入公式:=TEXT(B2,"mmdd"),下拉提取B列日期的月和日,然后再以“辅助列”为主要关键字排序即可完成excel时间排序:按月排序。

    展开全文
  • MapReduce排序排序

    千次阅读 2015-01-18 20:25:54
    :背景 Hadoop中虽然有自动排序和分组,由于自带的排序是按照Key进行排序的,有些时候,我们希望...#需求1: 首先按照第列数字升序排列,当第列数字相同时,第列数字也升序排列(列之间用制表符\t隔开) 3 3 3

    一:背景

    Hadoop中虽然有自动排序和分组,由于自带的排序是按照Key进行排序的,有些时候,我们希望同时对Key和Value进行排序。自带的排序功能就无法满足我们了,还好Hadoop提供了一些组件可以让开发人员进行二次排序。


    二:技术实现

    我们先来看案例需求

    #需求1: 首先按照第一列数字升序排列,当第一列数字相同时,第二列数字也升序排列(列之间用制表符\t隔开)

    3	3
    3	2
    3	1
    2	2
    2	1
    1	1
    
    MapReduce计算之后的结果应该是:

    1	1
    2	1
    2	2
    3	1
    3	2
    3	3
    

    #需求2:第一列不相等时,第一列按降序排列,当第一列相等时,第二列按升序排列

    3	3
    3	2
    3	1
    2	2
    2	1
    1	1
    
    MapReduce计算之后的结果应该是:
    3	1
    3	2
    3	3
    2	1
    2	2
    1	1


    下面是实现代码,实现两种需求的关键是compareTo()方法的实现不同:

    public class SecondSortTest {
    
    	// 定义输入路径
    		private static final String INPUT_PATH = "hdfs://liaozhongmin:9000/data";
    		// 定义输出路径
    		private static final String OUT_PATH = "hdfs://liaozhongmin:9000/out";
    
    		public static void main(String[] args) {
    
    			try {
    				// 创建配置信息
    				Configuration conf = new Configuration();
    				
    				/**********************************************/
    				//对Map端输出进行压缩
    				//conf.setBoolean("mapred.compress.map.output", true);
    				//设置map端输出使用的压缩类
    				//conf.setClass("mapred.map.output.compression.codec", GzipCodec.class, CompressionCodec.class);
    				//对reduce端输出进行压缩
    				//conf.setBoolean("mapred.output.compress", true);
    				//设置reduce端输出使用的压缩类
    				//conf.setClass("mapred.output.compression.codec", GzipCodec.class, CompressionCodec.class);
    				// 添加配置文件(我们可以在编程的时候动态配置信息,而不需要手动去改变集群)
    				/*
    				 * conf.addResource("classpath://hadoop/core-site.xml"); 
    				 * conf.addResource("classpath://hadoop/hdfs-site.xml");
    				 * conf.addResource("classpath://hadoop/hdfs-site.xml");
    				 */
    
    				// 创建文件系统
    				FileSystem fileSystem = FileSystem.get(new URI(OUT_PATH), conf);
    				// 如果输出目录存在,我们就删除
    				if (fileSystem.exists(new Path(OUT_PATH))) {
    					fileSystem.delete(new Path(OUT_PATH), true);
    				}
    
    				// 创建任务
    				Job job = new Job(conf, SecondSortTest.class.getName());
    
    				//1.1	设置输入目录和设置输入数据格式化的类
    				FileInputFormat.setInputPaths(job, INPUT_PATH);
    				job.setInputFormatClass(TextInputFormat.class);
    
    				//1.2	设置自定义Mapper类和设置map函数输出数据的key和value的类型
    				job.setMapperClass(MySecondSortMapper.class);
    				job.setMapOutputKeyClass(CombineKey.class);
    				job.setMapOutputValueClass(LongWritable.class);
    
    				//1.3	设置分区和reduce数量(reduce的数量,和分区的数量对应,因为分区为一个,所以reduce的数量也是一个)
    				job.setPartitionerClass(HashPartitioner.class);
    				job.setNumReduceTasks(1);
    
    				//1.4	排序、分组
    				//1.5	归约
    				//2.1	Shuffle把数据从Map端拷贝到Reduce端。
    				//2.2	指定Reducer类和输出key和value的类型
    				job.setReducerClass(MySecondSortReducer.class);
    				job.setOutputKeyClass(LongWritable.class);
    				job.setOutputValueClass(LongWritable.class);
    
    				//2.3	指定输出的路径和设置输出的格式化类
    				FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));
    				job.setOutputFormatClass(TextOutputFormat.class);
    
    
    				// 提交作业 退出
    				System.exit(job.waitForCompletion(true) ? 0 : 1);
    			
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    	
    	public static class MySecondSortMapper extends Mapper<LongWritable, Text, CombineKey, LongWritable>{
    		
    		//定义联合的key
    		private CombineKey combineKey = new CombineKey();
    		
    		protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, CombineKey, LongWritable>.Context context) throws IOException,
    				InterruptedException {
    			//对输入的value进行切分
    			String[] splits = value.toString().split("\t");
    			//设置联合的key
    			combineKey.setComKey(Long.parseLong(splits[0]));
    			combineKey.setComVal(Long.parseLong(splits[1]));
    			
    			//通过context写出去
    			context.write(combineKey, new LongWritable(Long.parseLong(splits[1])));
    		}
    	}
    	
    	
    	public static class MySecondSortReducer extends Reducer<CombineKey, LongWritable, LongWritable, LongWritable>{
    		@Override
    		protected void reduce(CombineKey combineKey, Iterable<LongWritable> values, Reducer<CombineKey, LongWritable, LongWritable, LongWritable>.Context context)
    				throws IOException, InterruptedException {
    			//因为输入的CombineKey已经排好序了,所有我们只要获取其中的两个成员变量写出去就可以了。values在这个例子中没有什么作用
    			context.write(new LongWritable(combineKey.getComKey()), new LongWritable(combineKey.getComVal()));
    		}
    	}
    
    }
    
    /**
     * 重新组合成一个key,实现二次排序
     * @author 廖*民
     * time : 2015年1月18日下午7:27:52
     * @version
     */
    class CombineKey implements WritableComparable<CombineKey>{
    
    	public long comKey;
    	public long comVal;
    	
    	//必须提供无参构造函数,否则hadoop反射机制会出错
    	public CombineKey() {
    		
    	}
    	//有参构造函数
    	public CombineKey(long comKey, long comVal) {
    		this.comKey = comKey;
    		this.comVal = comVal;
    	}
    
    	
    	
    	public long getComKey() {
    		return comKey;
    	}
    	public void setComKey(long comKey) {
    		this.comKey = comKey;
    	}
    	public long getComVal() {
    		return comVal;
    	}
    	public void setComVal(long comVal) {
    		this.comVal = comVal;
    	}
    	
    	public void write(DataOutput out) throws IOException {
    		out.writeLong(comKey);
    		out.writeLong(comVal);
    	}
    
    	public void readFields(DataInput in) throws IOException {
    		this.comKey = in.readLong();
    		this.comVal = in.readLong();
    	}
    
    	/**
    	 * 这个方法一定要实现
    	 * java里面排序默认是小的放在前面,即返回负数的放在前面,这样就是所谓的升序排列
    	 * 我们在下面的方法中直接返回一个差值,也就相当于会升序排列。
    	 * 如果我们要实现降序排列,那么我们就可以返回一个正数
    	 */
    	/*public int compareTo(CombineKey o) {
    		//第一列不相同时按升序排列,当第一列相同时第二列按升序排列
    		long minus = this.comKey - o.comKey;
    		//如果第一个值不相等时,我们就先对第一列进行排序
    		if (minus != 0){
    			return (int) minus;
    		}
    		//如果第一列相等时,我们就对第二列进行排序
    		return (int) (this.comVal - o.comVal);
    	}*/
    	
    	/**
    	 * 为了实现第一列不同时按降序排序,第一列相同时第二列按升序排列
    	 * 第一列:降序,当第一列相同时,第二列:升序
    	 * 为了实现降序,
    	 */
    	public int compareTo(CombineKey o) {
    		//如果a-b<0即,a小于b,按这样 的思路应该是升序排列,我们可以返回一个相反数使其降序
    		long tmp = this.comKey - o.comKey;
    		//如果第一个值不相等时,我们就先对第一列进行排序
    		if (tmp != 0){
    			return (int) (-tmp);
    		}
    		//如果第一列相等时,我们就对第二列进行升序排列
    		return (int) (this.comVal - o.comVal);
    	}
    	
    	
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + (int) (comKey ^ (comKey >>> 32));
    		return result;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		CombineKey other = (CombineKey) obj;
    		if (comKey != other.comKey)
    			return false;
    		return true;
    	}
    	
    }



    程序运行结果就不贴了,和预想的一样!

    展开全文
  • MapReduce排序

    千次阅读 2015-01-19 17:23:44
    我们知道MapReduce是按照key来进行排序的,那么如果有个需求就是先按照第个字段排序,在第个字段相等的情况下,按照第个字段排序,这就是传说中的排序。 下面就具体说一下排序的实现方式 主要就是...

    本文主要介绍下二次排序的实现方式


    我们知道MapReduce是按照key来进行排序的,那么如果有个需求就是先按照第一个字段排序,在第一个字段相等的情况下,按照第二个字段排序,这就是传说中的二次排序。


    下面就具体说一下二次排序的实现方式


    主要就是4点


    1.自定义一个Key

    为什么要自定义一个Key,我们知道MapReduce中排序就是按照Key来排序的,我们既然想要实现按照两个字段进行排序,默认的方式肯定是不行的,所以自定义一个新的Key,Key里面有两个属性,也就是我们要排序的两个字段。

    首先,实现WritableComparable接口,因为Key是可序列化并且可以比较的。其次,重载相关的方法,例如序列化、反序列化相关的方法write()、readFields()。重载在分区的时候要用到的hashCode()方法,注意后面会说到一个Partitioner类,也是用来分区的,用hashCode()方法和Partitioner类进行分区都是可以的,使用其中的一个即可。重载排序用的compareTo()方法。


    2.分区函数类

    上面定义了一个新的Key,那么我现在做分发,到底按照什么样的规则进行分发是在分区函数中定义的,这个类要继承Partitioner类,重载其中的分区方法getPartition(),在main()函数里面给job添加上即可,例如:job.setPartitionerClass(XXX.class);

    注:这个类的作用和新Key中的hashCode()方法作用一样,所以如果在新key的hashCode()方法中写了分区的实现,这个分区类是可以省略的。


    3.比较函数类

    这个类决定着Key的排序规则,是一个比较器,需要继承WritableComparator类,并且重载其中的compare()方法。在main()函数里给job添加上即可,例如:job.setSortComparatorClass(XXX.class);

    注:这个类的作用跟自定义Key的compareTo()方法一样,如果在自定义的Key中重载了compareTo()方法,这个类是可以省略的。


    4.分组函数类

    通过分区类,我们重新定义了key的分区规则,但是多个key不同的也可以进入一个reduce中,这不是我们想要的,我们需要分区函数来定义什么样的key可以进入相应的reduce来执行,因为也涉及到比较,所以这个类也需要继承WritableComparator,也可以实现RawComparator,并且重载其中的compare()方法,在main()函数中给job加上即可,如:job.setGroupingComparatorClass(XXX.class)。


    下面我们来重新简化一下上一篇文章中提到了例子:

    #需求:第一列升序,第一列相同时,第二列升序,其第一列相同的放在一个分区中输出

    sort1	1
    sort2	3
    sort2	88
    sort2	54
    sort1	2
    sort6	22
    sort6	888
    sort6	58
    #预期输出结果

    #part-r-00000文件

    sort1	1
    sort1	2
    #part-r-00001文件

    sort2	3
    sort2	54
    sort2	88

    #part-r-00002

    sort6	22
    sort6	58
    sort6	888
    




    1.自定义组合键

    public class CombinationKey implements WritableComparable<CombinationKey>{
    
    	private Text firstKey;
    	private IntWritable secondKey;
    	
    	//无参构造函数
    	public CombinationKey() {
    		this.firstKey = new Text();
    		this.secondKey = new IntWritable();
    	}
    	
    	//有参构造函数
    	public CombinationKey(Text firstKey, IntWritable secondKey) {
    		this.firstKey = firstKey;
    		this.secondKey = secondKey;
    	}
    
    	public Text getFirstKey() {
    		return firstKey;
    	}
    
    	public void setFirstKey(Text firstKey) {
    		this.firstKey = firstKey;
    	}
    
    	public IntWritable getSecondKey() {
    		return secondKey;
    	}
    
    	public void setSecondKey(IntWritable secondKey) {
    		this.secondKey = secondKey;
    	}
    
    	public void write(DataOutput out) throws IOException {
    		this.firstKey.write(out);
    		this.secondKey.write(out);
    	}
    
    	public void readFields(DataInput in) throws IOException {
    		this.firstKey.readFields(in);
    		this.secondKey.readFields(in);
    	}
    
    	/**
    	 * 自定义比较策略
    	 * 注意:该比较策略用于MapReduce的第一次默认排序
    	 * 也就是发生在Map端的sort阶段
    	 * 发生地点为环形缓冲区(可以通过io.sort.mb进行大小调整)
    	 */
    	public int compareTo(CombinationKey combinationKey) {
    		int minus = this.getFirstKey().compareTo(combinationKey.getFirstKey());
    		if (minus != 0){
    			return minus;
    		}
    		return this.getSecondKey().get() - combinationKey.getSecondKey().get();
    	}
    	
    	/*	public int compareTo(CombinationKey combinationKey) {
    		System.out.println("------------------------CombineKey flag-------------------");
    		return this.firstKey.compareTo(combinationKey.getFirstKey());
    	}*/
    
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((firstKey == null) ? 0 : firstKey.hashCode());
    		return result;
    	}
    
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		CombinationKey other = (CombinationKey) obj;
    		if (firstKey == null) {
    			if (other.firstKey != null)
    				return false;
    		} else if (!firstKey.equals(other.firstKey))
    			return false;
    		return true;
    	}
    
    	
    }
    

    2.自定义分组

    /**
     * 自定义分组有中方式,一种是继承WritableComparator
     * 另外一种是实现RawComparator接口
     * @author 廖钟民
     * time : 2015年1月19日下午3:30:11
     * @version
     */
    public class DefinedGroupSort extends WritableComparator{
    
    
    	protected DefinedGroupSort() {
    		super(CombinationKey.class,true);
    	}
    
    	@Override
    	public int compare(WritableComparable a, WritableComparable b) {
    		System.out.println("---------------------进入自定义分组---------------------");
    		CombinationKey combinationKey1 = (CombinationKey) a;
    		CombinationKey combinationKey2 = (CombinationKey) b;
    		System.out.println("---------------------分组结果:" + combinationKey1.getFirstKey().compareTo(combinationKey2.getFirstKey()));
    		System.out.println("---------------------结束自定义分组---------------------");
    		//自定义按原始数据中第一个key分组
    		return combinationKey1.getFirstKey().compareTo(combinationKey2.getFirstKey());
    	}
    
    
    }
    

    3.自定义分区

    /**
     * 自定义分区
     * 
     * @author 廖钟*民 time : 2015年1月19日下午12:13:54
     * @version
     */
    public class DefinedPartition extends Partitioner<CombinationKey, IntWritable> {
    
    	/**
    	 * 数据输入来源:map输出 我们这里根据组合键的第一个值作为分区 如果不自定义分区的话,MapReduce会根据默认的Hash分区方法 将整个组合键相等的分到一个分区中,这样的话显然不是我们要的效果
    	 * 
    	 * @param key
    	 *            map输出键值
    	 * @param value
    	 *            map输出value值
    	 * @param numPartitions
    	 *            分区总数,即reduce task个数
    	 */
    	public int getPartition(CombinationKey key, IntWritable value, int numPartitions) {
    		
    		if (key.getFirstKey().toString().endsWith("1")){
    			return 0;
    		} else if (key.getFirstKey().toString().endsWith("2")){
    			return 1;
    		} else {
    			return 2;
    		}
    	}
    
    }
    

    4.主类

    public class SecondSortMapReduce extends Configured implements Tool{
    
    	// 定义输入路径
    		private String INPUT_PATH = "";
    		// 定义输出路径
    		private String OUT_PATH = "";
    
    		public static void main(String[] args) {
    
    			try {
    				ToolRunner.run(new SecondSortMapReduce(), args);
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    
    		
    	public static class SecondSortMapper extends Mapper<Text, Text, CombinationKey, IntWritable>{
    		/**
    		 * 这里要特殊说明一下,为什么要将这些变量写在map函数外边
    		 * 对于分布式的程序,我们一定要注意到内存的使用情况,对于MapReduce框架
    		 * 每一行的原始记录的处理都要调用一次map()函数,假设,这个map()函数要处理1一亿
    		 * 条输入记录,如果将这些变量都定义在map函数里面则会导致这4个变量的对象句柄
    		 * 非常的多(极端情况下将产生4*1亿个句柄,当然java也是有自动的GC机制的,一定不会达到这么多)
    		 * 导致栈内存被浪费掉,我们将其写在map函数外面,顶多就只有4个对象句柄
    		 */
    		private CombinationKey combinationKey = new CombinationKey();
    		Text sortName = new Text();
    		IntWritable score = new IntWritable();
    		String[] splits = null;
    		protected void map(Text key, Text value, Mapper<Text, Text, CombinationKey, IntWritable>.Context context) throws IOException, InterruptedException {
    			System.out.println("---------------------进入map()函数---------------------");
    			//过滤非法记录(这里用计数器比较好)
    			if (key == null || value == null || key.toString().equals("")){
    				return;
    			}
    			//构造相关属性
    			sortName.set(key.toString());
    			score.set(Integer.parseInt(value.toString()));
    			//设置联合key
    			combinationKey.setFirstKey(sortName);
    			combinationKey.setSecondKey(score);
    			
    			//通过context把map处理后的结果输出
    			context.write(combinationKey, score);
    			System.out.println("---------------------结束map()函数---------------------");
    		}
    		
    	}
    	
    	
    	public static class SecondSortReducer extends Reducer<CombinationKey, IntWritable, Text, Text>{
    		
    		StringBuffer sb = new StringBuffer();
    		Text score = new Text();
    		/**
    		 * 这里要注意一下reduce的调用时机和次数:
    		 * reduce每次处理一个分组的时候会调用一次reduce函数。
    		 * 所谓的分组就是将相同的key对应的value放在一个集合中
    		 * 例如:<sort1,1> <sort1,2>
    		 * 分组后的结果就是
    		 * <sort1,{1,2}>这个分组会调用一次reduce函数
    		 */
    		protected void reduce(CombinationKey key, Iterable<IntWritable> values, Reducer<CombinationKey, IntWritable, Text, Text>.Context context)
    				throws IOException, InterruptedException {
    			
    			//将联合Key的第一个元素作为新的key,遍历values将结果写出去
    			for (IntWritable val : values){
    				context.write(key.getFirstKey(), new Text(String.valueOf(val.get())));
    			}
    			
    			
    		}
    	}
    
    
    	public int run(String[] args) throws Exception {
    		// 给路径赋值
    		INPUT_PATH = args[0];
    		OUT_PATH = args[1];
    		try {
    			// 创建配置信息
    			Configuration conf = new Configuration();
    			conf.set(KeyValueLineRecordReader.KEY_VALUE_SEPERATOR, "\t");
    
    			// 创建文件系统
    			FileSystem fileSystem = FileSystem.get(new URI(OUT_PATH), conf);
    			// 如果输出目录存在,我们就删除
    			if (fileSystem.exists(new Path(OUT_PATH))) {
    				fileSystem.delete(new Path(OUT_PATH), true);
    			}
    
    			// 创建任务
    			Job job = new Job(conf, SecondSortMapReduce.class.getName());
    			//设置成jar运行型
    			job.setJarByClass(SecondSortMapReduce.class);
    			// 1.1	设置输入目录和设置输入数据格式化的类
    			FileInputFormat.setInputPaths(job, INPUT_PATH);
    			job.setInputFormatClass(KeyValueTextInputFormat.class);
    
    			// 部1.2	设置自定义Mapper类和设置map函数输出数据的key和value的类型
    			job.setMapperClass(SecondSortMapper.class);
    			job.setMapOutputKeyClass(CombinationKey.class);
    			job.setMapOutputValueClass(IntWritable.class);
    
    			// 1.3	设置分区和reduce数量(reduce的数量,和分区的数量对应)
    			job.setPartitionerClass(DefinedPartition.class);
    			job.setNumReduceTasks(3);
    			
    			//设置自定义分组策略
    			job.setGroupingComparatorClass(DefinedGroupSort.class);
    			//设置自定义比较策略(因为我的CombineKey重写了compareTo方法,所以这个可以省略)
    			//job.setSortComparatorClass(DefinedComparator.class);
    			
    			// 1.4	排序
    			//1.5	归约
    			// 2.1	Shuffle把数据从Map端拷贝到Reduce端。
    			// 2.2	指定Reducer类和输出key和value的类型
    			job.setReducerClass(SecondSortReducer.class);
    			job.setOutputKeyClass(Text.class);
    			job.setOutputValueClass(Text.class);
    
    			//2.3	指定输出的路径和设置输出的格式化类
    			FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));
    			job.setOutputFormatClass(TextOutputFormat.class);
    
    
    			// 提交作业 退出
    			System.exit(job.waitForCompletion(true) ? 0 : 1);
    		
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return 0;
    	}
    }
    
    注:使用jar包的方式运行程序一定不要忘记很重要的一句:job.setJarByClass(XXX);

    程序运行的结果:


    展开全文
  • 1.月份排序 SELECT *  FROM 表 ORDER BY CAST(月份列 as int) ...ORDER BY CHARINDEX (月份列,N'一月,二月,三月,四月,五月,六月,七月,八月,九月,十月,十一月,十二月')  是汉字的话不可能ASCII码排序

    1.按月份排序

    SELECT * 
    FROM  表
    ORDER BY CAST(月份列 as int)

    2.按汉语数字排序
    SELECT * 
    FORM  表
    ORDER BY  CHARINDEX (月份列,N'一月,二月,三月,四月,五月,六月,七月,八月,九月,十月,十一月,十二月') 

    是汉字的话不可能按ASCII码排序。


    展开全文
  • 前言 选择排序种简单直观的排序方法,每次寻找排序中最小值,然后放在最末尾的位置。
  • 选择排序&分搜索

    千次阅读 2020-01-24 16:18:49
    C语言实现选择排序分搜索
  • 花色和牌大小排序,红桃>方块>黑桃>梅花。 大概思路:新建Card对象,属性有 private int id; //花色,1234对应红方黑梅 private int values; //数字1-13依次对应牌值12345678910JQK 分别对它们赋权值,values...
  • java实现分插入排序

    千次阅读 2014-10-11 20:32:48
    今天是分插入排序算法,分插入排序算法是直接插入排序算法de
  • 排序综述 Mapreduce框架会自动对映射器生成的键完成排序.再启动归约器之前,映射器中生成的所有中间键-值对必然是按键有序的(而不是值有序)。传入各个归约器的值并不是有序的,它们可能有任意的顺序。如果...
  • hadoop的排序——实例

    千次阅读 2018-05-31 11:08:14
    下面是个hadoop的排序案例:编写mapReduce程序,将下面的左边内容进行排序排序后变成右边的样子。mapReduce的程序如下:第步:定义个组合键的beanpackage com.bigdata.demo15_two_class_paixu; import ...
  • 路归并排序c语言实现

    千次阅读 2017-10-16 16:07:05
    路归并排序 c 语言实现。
  • 看到这个大家都知道吧,其实就是个相册的显示效果,他说不会分组排序,然后让我给他看看,ok,废话不多说,开始解说。 、题外话 在写代码之前一定搞清楚原理,这是个很重的过程,现在好多写代码的初学者都是看到...
  • [Spark的排序的实现]

    万次阅读 多人点赞 2018-06-05 20:59:56
    排序技术 假设对应的Key = K有如下值: (K,V1), (K,V2),…,(K,Vn) 另外假设每个Vi是包含m个属性的个元组,如下所示: (Ai1,Ai2,…,Aim)在这里我们希望Ai1对归约器的元组的值...
  • sql年、、日、查询排序

    千次阅读 2018-11-08 11:12:52
    如下表table1:  日期(exportDate) 数量(amount)  -------------- -----------  14-2 -08 20  10-3 -08 2  14-4 -08 ...
  • 排序算法系列:基数排序

    万次阅读 多人点赞 2016-06-16 23:14:07
    这也是基数排序的魅力所在,基数排序可以理解成是建立在“计数排序”的基础之上的排序算法。在实际项目中,如果对效率有所要求,而不太关心空间的使用时,我会选择用计数排序(当然还有一些其他的条件),或是...
  • //创建bucket时,在维中增加组标识位,其中bucket[x, 0]表示这维所包含的数字的个数 //通过这样的技巧可以少写很多代码 int[,] bucket = new int[bucketNum, array.Length + 1]; for (int i = 0; i < ...
  •  第行包含n个整数,相邻的整数之间用个空格分隔,表示所给定的整数。 输出格式  输出多行,每行包含两个整数,分别表示个给定的整数和它出现的次数。出现次数递减的顺序输出。如果两个整数出现的次数...
  • 在数据库中我们经常用sql语句对表进行简单的统计排序,对于日期字段,我们可以分别提出来日期中的年、、日,分别进行group,order。
  • 日期进行排序(结构体)

    千次阅读 2019-05-15 08:47:46
    小明希望将自己的通讯录好友的生日排序排序,这样就查看起来方便多了,也避免错过好友的生日。为了小明的美好愿望,你帮帮他吧。小明的好友信息包含姓名、出生日期。其中出生日期又包含年、、日三部分信息。输入...
  • 精通八大排序算法系列:、堆排序算法

    万次阅读 热门讨论 2011-02-21 21:46:00
    精通八大排序算法系列:二、堆排序算法作者:July 、二零一一年二月二十日本文参考:Introduction To Algorithms,second edition。-------------------此精通排序算法系列,前一节,已讲过了快速排序算法,据我所知...
  • 我与插入排序二三事

    2013-03-27 21:30:29
    个多前看了一些资料,了解了排序的思想,然后自己摸索出了代码的写法。并一直这样写了这么久。直到今天看了《算法导论》的时候,才恍然大悟,原来自己一直写的插入排序并不十分正确。虽然思想是相通的。但是运行...
  • 维数组每行单独排序

    千次阅读 2016-06-15 14:57:47
    * Function : 维数组每行单独排序 C++实现 * Created on : 2016年615日 * Author : beijiwei@qq.com * Copyright : 欢迎大家和我一起交流学习,转载请保持源文件的完整性。 任何单位和个人不经本人允许不得...
  • Hadoop排序及MapReduce处理流程实例详解

    万次阅读 多人点赞 2015-01-19 17:17:17
    MapReduce框架对处理结果的输出会根据key值进行默认的排序,这个默认排序可以满足部分需求,但是也是十分有限的,在我们实际的需求当中,往往有要对reduce输出结果进行排序的需求。对于排序的实现,网络上...
  • 冒泡排序种简单的排序算法。它重复地走访要排序的数列,次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字...
  • 路归并排序Python实现

    千次阅读 2017-10-16 16:33:42
    看了网上一些写法,总感觉 有点复杂,所以我参考之前写的程序,用Python 改写了路归并排序 算法 。路归并排序主要运用了“分治算法”,分治算法就是将个大的问题划分为n个规模较小而结构相似的子问题。 ...
  • 分查找折半查找排序

    千次阅读 2016-09-10 09:34:25
    个有序的数组中,折半查找个元素key,如果能找到返回数组的下表,如果找不到,返回-1。 实现如下所示: /** * 分查找法 * @author jcm * 2016年86日 */ public class BinarySerach { public static...
  • Hive()查询、排序

    千次阅读 2020-05-29 16:08:47
    Hive 查询语法SELECT常用函数LIMIT语句WHERE语句like 和 rlike分组GROUP BY 语句HAVING 语句表的别名内连接左外连接右外连接多表连接排序全局排序按照别名排序多个列排序每个MapReduce内部排序(Sort By)局部排序...
  • C 语言排序算法BB Time、冒泡排序1、原理2、代码、选择排序1、原理2、代码三、插入排序1、原理2、代码四、快速排序1、原理2、代码 代码均以从小到大排序为例 只写出来了排序的函数,减少博客冗余内容 BB ...
  • SQL查询单表数据之排序

    千次阅读 2020-02-18 21:39:12
    【SQL从一点一滴分析系列文章】为实际开发中的...本节讲述 对查询结果进行排序 1 以指定的次序返回查询结果 查询 用户表中所有用户的 姓名 年龄 地区,并按照年龄的升序排列,可以使用 order by 子句 select user_n...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 186,720
精华内容 74,688
关键字:

怎么按一月二月排序