精华内容
下载资源
问答
  • 汇编 从大到小排排序 冒泡法 需要在代码中设置数值
  • 汇编 从大到小排排序 选择排序法 需要 在程序中设置索要排序的数值
  • 传入true返回的数组则是从小到大排,传入flase则是从大到小排的 public class MySort { /* 自定义排序工具类 */ /** 冒泡排序传入true从小到大排 传入flase从大到小排 */ public static int[] bubbleSort(int...

    本文有两个类一个自定义排序工具类和一个测试类
    其中冒泡排序和选择排序的方法中还有一个boolean类型的参数
    传入true返回的数组则是从小到大排,传入flase则是从大到小排的

    public class MySort {
        /* 自定义排序工具类 */
    
        /**
        冒泡排序传入true从小到大排
              传入flase从大到小排
        */
        public static int[] bubbleSort(int[] array,boolean b){
            int temp;
            if (b==true){//从小到大排
                for (int i = 0; i < array.length-1; i++) {
                    for (int j=0;j< array.length-i-1;j++){
                        if(array[j]>array[j+1]){
                            temp=array[j+1];
                            array[j+1]=array[j];
                            array[j]=temp;
                        }
                    }
                }
            }else {//从大到小排
                for (int i = 0; i < array.length-1; i++) {
                    for (int j=0;j< array.length-i-1;j++){
                        if(array[j]<array[j+1]){
                            temp=array[j+1];
                            array[j+1]=array[j];
                            array[j]=temp;
                        }
                    }
                }
            }
            return array;
        }
    
        /**
        选择排序传入true从小到大排
         传入flase从大到小排
        */
        public static int[] selectionSort(int[] array, boolean b){
            int temp;  //临时变量
            int minindex;
            int maxindex;
            if (b==true){//从小到大排
                for (int i = 0; i < array.length-1; i++){
                    minindex=i;
                    for (int j=i+1;j< array.length;j++){
                        if (array[minindex]>array[j]){
                            minindex=j;
                        }
                    }
                    temp=array[i];
                    array[i]=array[minindex];
                    array[minindex]=temp;
                }
            }else {//从大到小排
                for (int i = 0; i < array.length-1; i++){
                    maxindex=i;
                    for (int j=i+1;j< array.length;j++){
                        if (array[maxindex]<array[j]){
                            maxindex=j;
                        }
                    }
                    temp=array[i];
                    array[i]=array[maxindex];
                    array[maxindex]=temp;
                }
            }
            return array;
        }
    
        /**
         插入排序
         */
        public static int[] insertionSort(int[] array){
            int insert; //插入的数
            for (int i = 1; i < array.length; i++){
                insert=array[i];
                int insertindex=i-1;  //应该插入的位置
                for (int j=0;j<i;j++){
                    if (insert<array[insertindex]){
                        array[insertindex+1]=array[insertindex];
                        if (insertindex==0){
                            break;
                        }
                        insertindex--;
                    }else {
                        insertindex++;
                        array[insertindex]=insert;
                        break;
                    }
                }
               array[insertindex]=insert;
            }
            return array;
        }
    }
    

    测试类

    public class Test {
        public static void main(String[] args) {
            int []a={51, 11, 15, 2, 36, 7, 59, 6,64,33};
            //MySort.bubbleSort(a,false);  //冒泡排序
            //MySort.selectionSort(a,false);   //选择排序
            //MySort.insertionSort(a);     //插入排序
            //System.out.println(Arrays.toString(a));
        }
    }
    

    本文只涉及了冒泡排序,选择排序,插入排序,其他几种排序会在今后补充。

    展开全文
  • 随便给一组数据,然后用几种方法来...从小到大排: int k = 3; int[] nums = new int[] { 4, 1, 6, 3, 7, 9, 2, 5 }; // 第一种,调库 Arrays.sort(nums); for (int i = 0; i < k; i++) { System.out.print(n...

    随便给一组数据,然后用几种方法来对它进行排序,再取前面k个较小/大的数,设k=3

    从小到大排:

    int k = 3;
    int[] nums = new int[] { 4, 1, 6, 3, 7, 9, 2, 5 };
     // 第一种,调库
    Arrays.sort(nums);
    for (int i = 0; i < k; i++) {
        System.out.print(nums[i] + " ");
    }
    // 第二种,动态数组
    ArrayList<Integer> list = new ArrayList<>();
    Arrays.sort(nums);
    for (int i = 0; i < k; i++) {
        list.add(nums[i]);
    }
    
    System.out.println(list);
    // 第三种,优先队列,将数组的元素加入到队列中,
    PriorityQueue<Integer> pq = new PriorityQueue<>();
    for (int i = 0; i < nums.length; i++) {
        pq.add(nums[i]);//排进去,会自动给你生成小顶堆
    }
    // 然后设一个ArrayList来存储要从队列中取出的元素
    ArrayList<Integer> list1 = new ArrayList<>();
    for (int i = 0; i < k; i++) {
        list1.add(pq.poll());
    }
    System.out.println(list1);
    // 第四种
    ArrayList<Integer> list2 = new ArrayList<>();
    for (int i : nums) {
        list2.add(i);
    }
    
    Collections.sort(list2);
    for (int i = 0; i < k; i++) {
        System.out.println(list2.get(i));
    }
    

     从大到小:

     第一种,PriorityQueue实现大顶堆,加入(new Comparator<Integer>(){});
     第二种,Collections.sort()方法
     

    import java.util.ArrayList;
    import java.util.Comparator;
    import java.util.PriorityQueue;
    
    public class FromBigToSmall {
    
    	public static void main(String[] args) {
    		int k = 3;
    		int[] nums = new int[] { 4, 1, 6, 3, 7, 9, 2, 5 };
    		PriorityQueue<Integer> pQueue = new PriorityQueue<>(new Comparator<Integer>() {
    
    			@Override
    			public int compare(Integer o1, Integer o2) {
    				// 本来应该o1-o2的,如果o2-o1>0,那么o2>o1;反之,o1>o2
    				return o2 - o1;
    			}
    		});
    		for (int i = 0; i < nums.length; i++) {
    			pQueue.add(nums[i]);
    		}
    		ArrayList<Integer> list = new ArrayList<>();
    		for (int i = 0; i < k; i++) {
    			list.add(pQueue.poll());
    		}
    		System.out.println(list);
    	}
    
    }
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    
    public class FromBigToSmall {
    	public static void main(String[] args) {
    		int k = 3;
    		int[] nums = new int[] { 4, 1, 6, 3, 7, 9, 2, 5 };
    		// 用Collections
    		ArrayList<Integer> list1 = new ArrayList<>();
    		for (int i : nums) {// for-each循环,把nums数组的元素的值依次赋给i
    			list1.add(i);
    		}
    		Collections.sort(list1, new Comparator<Integer>() {
    
    			@Override
    			public int compare(Integer o1, Integer o2) {
    				// TODO Auto-generated method stub
    				return o2 - o1;
    			}
    		});
    		for (int i = 0; i < 3; i++) {
    			System.out.print(list1.get(i));
    		}
    
    	}
    }

    end.

    展开全文
  • 有M个整数数组,都已经从大到小排好序。请写出程序把这M个数组合成一个数组,也从大到小排序。 public class MMArrays { public static void main(String[] args) { //给定数组 int[] arr1 = new int[]{500, ...

    笔试题:

    有M个整数数组,都已经从大到小排好序。请写出程序把这M个数组合成一个数组,也从大到小排序。

    public class MMArrays {
        public static void main(String[] args) {
            //给定数组
            int[] arr1 = new int[]{500, 400, 300, 200, 100};
            int[] arr2 = {555, 444, 333, 222, 111};
            int[] arr3 = {520, 432, 311, 250, 110};
            int length = arr1.length + arr2.length + arr3.length;
            int[] arr = new int[length];
            //遍历数组
            for (int i = 0; i < arr1.length; i++) {
                arr[i] = arr1[i];
            }
            for (int i = 0; i < arr2.length; i++) {
                arr[i + arr1.length] = arr2[i];
            }
            for (int i = 0; i < arr3.length; i++) {
                arr[i + arr1.length + arr2.length] = arr3[i];
            }
            //排序前
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
            }
            System.out.println("----------------");
            //升序排序
            Arrays.sort(arr);
            //降序(反向遍历)
            for (int i = arr.length - 1; i >= 0; i--) {
                System.out.println(arr[i]);
            }
        }
    }

     

    展开全文
  • import java.util.Arrays;import java.util.Collections;public class Test { public static void main(String[] args) { //注意,只能用对象类型,不可以使用简单类型 如int[] num则报错 Integer[] num = {5,8,3,9,...


    import java.util.Arrays;
    import java.util.Collections;
    public class Test {

    public static void main(String[] args) {
    //注意,只能用对象类型,不可以使用简单类型 如int[] num则报错
    Integer[] num = {5,8,3,9,1};
    //如果是num是List或 Set,则用Collections.sort(num,Collections.reverseOrder());
    Arrays.sort(num,Collections.reverseOrder());
    for(int i=0;i<num.length;i++){
    System.out.println(num[i]);
    }

    }
    }

    转载于:https://www.cnblogs.com/upstart/p/6011930.html

    展开全文
  • Java重载(Arrays.sort()从大到小排)

    千次阅读 2019-05-09 18:27:33
    Java中的Arrays.sort()方法默认将数组元素从大到小排序. 要实现从大到小排序java也提供了一种方法: Arrays中的sort(T[] a, Comparator<?super T> c), 但是传入的数组类型不能是基本类型(int char double),...
  • 题目:N个从大到小排好序的整型队列,求top M元素。 题意详解:有N个队列,其中的元素均已经从大到小排序,求出最大的M个元素。 分析: 很容易想到,top elements问题的通用解法是堆(优先队列),但是N...
  • 度度熊有一个N个数的数组,他想将数组从大到小排好序,但是萌萌的度度熊只会下面这个操作: 任取数组中的一个数然后将它放置在数组的最后一个位置. 问最少操作多少次可以使得数组从小到大有序? 输入描述: 首先...
  • 解题思路: if(a>b);将a与b互换。交换后,a是a.b之间的最小者...c),将b与c互换,交换后,b是b,c中的者,也是三者的中次者; 顺序输出:a,b,c; 代码如下: #include<stdio.h> int main() { int ...
  • 从大到小排1

    2020-11-18 06:40:53
    #include<bits/stdc++.h> using namespace std; int main() { int a,b,c,d; cin>>a>>b>>c; if(c>b&&b>a) cout<<c<<" "<<b<<...b)
  • 注意,第K大的数意味着从大到小排在第K位的数。 Input N K a1 a2 a3 a4 … aN Output b Sample Input 1 5 2 32 3 12 5 89 Sample Output 1 32 Source none 代码如下: #include<stdio.h> int main() { int n,k...
  • //同为奇数的在前  }  /**  * 打印数组  *  * @param a 数组  */  public void prints( int a[] )  {  for (int i = 0; i ; i++)  {  System.out.print(" " + a[i]);  ...
  • 表大概这个样子 gid level 1 9 1 8 1 9 1 5 1 6 3 5 4 4 5 3 3 5 4 3 5 4 3 8 5 9 6 2 假设N是2 那就需求显示成大致这样 gid level 1 9 1 9 3 8 3 5 4 4 4 3 5 9 ...小白求教
  • L是用户传入的一个线性表,其中ElementType元素可以通过>、==、Insert要将X插入Data[]中合适的位置,以保持结果依然有序(注意:元素下标0开始存储)。但如果X已经在Data[]中了,就不要插入,返回失败的标记false...
  • //成绩排行 //输入 //CS00000001 4 110 //CS00000002 4 120 //CS00000003 5 150 //输出 //CS00000003 5 150 //CS00000001 4 110 //CS00000002 4 120 #include <iostream> #include <...std...
  • JAVA实现快速排序 从大到小

    千次阅读 2018-09-28 22:51:58
     //i向右移,直到遇到比key的值  while(a[i]>=key && i){  i++;  }  if(i){//互换  int temp=a[i];  a[i]=a[j];  a[j]=temp;  }  }  a[left]=a[i];  a[i]=key;  QuickSort(a,left,i-1); ...
  • 数字排序(从大到小)

    2020-04-15 18:58:54
    从大到小排好序的数据 样例输入 2 1 5 样例输出 5 2 1 import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in)...
  • 图是这样的![图片说明](https://img-ask.csdn.net/upload/201912/16/1576477578_940793.png) 用scanner输入数字再从大到小排
  • 的方法类 package com.hcc.util; public class QuickSort { /** * * @param arr 存放数据的数组 * @param left 需要排序的开始下标 * @param right 需要排序的结束下标 */ public static void...
  • ch09_ex33 从大到小输出给定二叉

    千次阅读 2014-08-29 22:26:58
    9.33③ 编写递归算法,从大到小输出给定二叉排序树 中所有关键字不小于x的数据元素。要求你的算法的时 间复杂度为O(log2n+m),其中n为排序树中所含结点数, m为输出的关键字个数。 实现下列函数: void OrderOut...
  • JAVA冒泡排序从小到大和从大到小详细过程JAVA冒泡排序从小到大和从大到小详细过程1.从小到大的冒泡排序for(int i=0;i{for(int j=0;j{if(a[j]>a[j+1])//如果前一位大于后一位,则交换,大的数在后面{int temp=a...
  • 首发 公众号 EXCEL办公实战今天我们来唠唠图表中条形图,由于条形图的使用习惯,一般都是从大到小所以对于乱序的数据我们都需要排序处理,要是能实现自动排序就好了。这会儿我们就来和他对线先来看看乱序的情况,...
  • 首发 公众号 EXCEL办公实战今天我们来唠唠图表中条形图,由于条形图的使用习惯,一般都是从大到小所以对于乱序的数据我们都需要排序处理,要是能实现自动排序就好了。这会儿我们就来和他对线先来看看乱序的情况,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,012
精华内容 2,004
关键字:

从大到小排