精华内容
下载资源
问答
  • 我只是一个小白 各位大神看到不要介意var a = Number(prompt("请输入你需要排列的第一个数字"))var b = Number(prompt("请输入你需要排列的第二个数字"))var c = Number(prompt("请输入你需要排列的三个数字"))if(a&...

    我只是一个小白 各位大神看到不要介意

    var a = Number(prompt("请输入你需要排列的第一个数字"))

    var b = Number(prompt("请输入你需要排列的第二个数字"))

    var c = Number(prompt("请输入你需要排列的三个数字"))

    if(a>b&&b>c){

    console.log(a);console.log(b);console.log(c);

    }else if(b>a&&a>c){

    console.log(b);console.log(a);console.log(c);

    }else if(c>a&&a>b){

    console.log(c);console.log(a);console.log(b);

    }else if(c>b&&b>a){

    console.log(c);console.log(b);console.log(a);

    }else if(a>c&&c>b){

    console.log(a);console.log(c);console.log(b);

    }else if(b>c&&c>a){

    console.log(b);console.log(c);console.log(a);

    }

    欢迎大家一同前行

    原文:http://www.cnblogs.com/F001li/p/6834199.html

    展开全文
  • 我已经设置了一个firebase数据库,我想知道我是如何制作它的,以便我的listView以升序或降序显示我的数据.例如:如果我想要的东西是最贵的,我会在listView的顶部和底部的便宜的东西.基本上我正在尝试创建一个排名活动,...

    我已经设置了一个firebase数据库,我想知道我是如何制作它的,以便我的listView以升序或降序显示我的数据.

    例如:如果我想要的东西是最贵的,我会在listView的顶部和底部的便宜的东西.

    基本上我正在尝试创建一个排名活动,其中我有两个单独的列表视图,按成本和单独计数排名.

    GFaGI.jpg

    这就是我的计算:

    @Override

    protected void onStart() {

    super.onStart();

    itemlists=new ArrayList();

    databaseItems.child("items").addValueEventListener(new ValueEventListener() {

    @Override

    public void onDataChange(DataSnapshot dataSnapshot) {

    for (DataSnapshot itemSnapShot : dataSnapshot.getChildren()) {

    String itemname=itemSnapShot.child("itemName").getValue().toString();

    itemlists.add(itemname);

    adapter = new ArrayAdapter(SearchActivity.this,android.R.layout.simple_list_item_1,itemlists);

    listFinalCount.setAdapter(adapter);

    }

    }

    @Override

    public void onCancelled(DatabaseError databaseError) {

    }

    });

    }

    展开全文
  • 顶堆升序顶堆降序的堆排序(以Java描述为例版本) 一、定义 堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值,称为顶堆;或者每个结点的值都小于或等于其左右孩子结点的值,...

    大顶堆升序、小顶堆降序的堆排序(以Java描述为例版本)

    一、定义

    1. 堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值,称为大顶堆;或者每个结点的值都小于或等于其左右孩子结点的值,称为小顶堆。

    2. 二叉树的相关性质

      当用数组来模拟二叉树的性质的时候,索引为i的结点的左孩子和右孩子对应的数组索引下标依次为:

      • 根节点: i i i

      • 左孩子: 2 ∗ i + 1 2 * i + 1 2i+1

      • 右孩子: 2 ∗ i + 2 2 * i + 2 2i+2

      数组长度为 l e n g t h length length,那么最后一个非叶子节点为 l e n g t h / 2 − 1 length/2-1 length/21

      可以分两种情形考虑:

      ①堆的最后一个非叶子节点若只有左孩子

      ②堆的最后一个非叶子节点有左右两个孩子

      完全二叉树的性质之一是:如果节点序号为 i i i,在它的左孩子序号为 2 i + 1 2i+1 2i+1,右孩子序号为 2 i + 2 2i+2 2i+2

      对于①左孩子的序号为n-1,则 n − 1 = 2 ∗ i − 1 n-1=2*i-1 n1=2i1,推出 i = n / 2 − 1 i=n/2-1 i=n/21

      对于②左孩子的序号为n-2,在 n − 2 = 2 ∗ i − 1 n-2=2*i-1 n2=2i1,推出 i = ( n − 1 ) / 2 − 1 i=(n-1)/2-1 i=(n1)/21;右孩子的序号为n-1,则

      n − 1 = 2 ∗ i + 2 n-1=2*i+2 n1=2i+2,推出 i = ( n − 1 ) / 2 − 1 i=(n-1)/2-1 i=(n1)/21

      很显然,当完全二叉树最后一个节点是其父节点的左孩子时,树的节点数为偶数;当完全二叉树最后一个节点是其父节点的右孩子时,树的节点数为奇数。

      根据java语法的特征,整数除不尽时向下取整,则若n为奇数时(n-1)/2-1=n/2-1。

      因此对于②最后一个非叶子节点的序号也是n/2-1。

      得证。

      同时,我们对堆中的结点按层进行编号,将这种逻辑结构映射到数组中就是下面这个样子

      img

      该数组从逻辑上讲就是一个堆结构,我们用简单的公式来描述一下堆的定义就是:

      大顶堆: a r r [ i ] > = a r r [ 2 i + 1 ] arr[i]>=arr[2i+1] arr[i]>=arr[2i+1] && a r r [ i ] > = a r r [ 2 i + 2 ] arr[i] >= arr[2i+2] arr[i]>=arr[2i+2]

      小顶堆: a r r [ i ] < = a r r [ 2 i + 1 ] arr[i]<=arr[2i+1] arr[i]<=arr[2i+1] && a r r [ i ] < = a r r [ 2 i + 2 ] arr[i] <= arr[2i+2] arr[i]<=arr[2i+2]

    二、第一阶段:建大顶堆

    第一步给定无序数组初始化:

    第二步开始构建大顶堆:

    2.1 此时我们从最后一个非叶子结点开始(叶结点自然不用调整,第一个非叶子结点 arr.length/2-1=5/2-1=1,也就是下面的6结点),从左至右,从下至上进行调整。

    2.2. 找到第二个非叶节点4,由于[4,9,8]中9元素最大,4和9交换。

    2.3 这时,交换导致了子根[4,5,6]结构混乱,继续调整,[4,5,6]中6最大,交换4和6。

    2.4 此时,初始化大顶堆以构建完成,但此时整体还是无序的,因为左右孩子的值没有比较过只是根节点和孩子节点之间的比较,不是左孩子和右孩子之间的比较。

    这个时候的大根堆是这样子的

    三、第二阶段:大顶堆排序

    将堆顶元素与末尾元素进行交换,使末尾元素最大。然后继续调整堆,再将堆顶元素与末尾元素交换,得到第二大元素。如此反复进行交换、重建、交换。

    重新调整结构,使其继续满足堆定义,此时堆为[8,6,4,5]

    再将堆顶元素8与末尾元素5进行交换,得到第二大元素8。

    后续再构建堆[6,5,4]

    再将堆顶元素6与末尾元素4进行交换,得到第三大元素6。

    然后4和5再交换,继续构建大顶堆 这个时候会是[5,4]

    然后继续交换,5下沉到此时的最后面,变成了[4],得到第四大元素5

    此时已经全部筛选完,是有序的了。

    再简单总结下堆排序的基本思路:

    a.将无需序列构建成一个堆,根据升序降序需求选择大顶堆或小顶堆;

    b.将堆顶元素与末尾元素交换,将最大元素"沉"到数组末端;

    c.重新调整结构,使其满足堆定义,然后继续交换堆顶元素与当前末尾元素,反复执行调整+交换步骤,直到整个序列有序。

    附上代码,这个是可以自由输入的。

    package heapsort;
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    /**
     * @author zhouyanxiang
     * @Date 2020-12-2020/12/30-10:50
     */
    public class BigHeapSort {
    
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入要排序的数组的长度:");
            int n = scanner.nextInt();
            int[] arr = new int[n];
            System.out.println("请输入要排序的数组:");
            for (int i = 0; i < n; i++) {
                arr[i] = scanner.nextInt();
            }
            scanner.close();
            buildHeap(arr);
        }
    
        public static void buildHeap(int[] arr) {
            int length = arr.length;
            // 先构建一个大顶堆
            for (int i = arr.length / 2 - 1; i >= 0; i--) {
                maximumHeap(arr,i, arr.length);
            }
            // 排序
            for (int i = arr.length - 1; i >= 0; i--) {
                // 过程中的每一步数组元素的变化过程
                 System.out.println(Arrays.toString(arr));
                swap(arr,0,i);
                length--;
                maximumHeap(arr,0, length);
            }
    
            System.out.println(Arrays.toString(arr));
        }
    
        public static void maximumHeap(int[] arr,int i ,int length) {
            int tmp = arr[i];
            for (int j = 2 * i + 1;j < length; j = j * 2 + 1) {
                // 右孩子比左孩子要大,那么指向右孩子
                if (j+1 < length && arr[j] < arr[j+1]) {
                    j++;
                }
                // 右孩子比根节点要大,一直往下探寻
                if (arr[j] > tmp) {
                    arr[i] = arr[j];
                    i = j;
                }
                //将temp放到最终位置
                arr[i] = tmp;
            }
        }
    
        public static void swap(int[] arr,int a,int b) {
           int tmp = arr[a];
           arr[a] = arr[b];
           arr[b] = tmp;
        }
    
    }
    

    测试用例

    这个是定义好自行修改数组的。

    package heapsort;
    
    import java.util.Arrays;
    
    /**
     * @author zhouyanxiang
     * @Date 2020-12-2020/12/30-10:50
     */
    public class BigHeapSort {
    
        public static void main(String[] args) {
            int[] arr = {5,4,8,9,6};
            buildHeap(arr);
        }
    
        public static void buildHeap(int[] arr) {
            int length = arr.length;
            // 先构建一个大顶堆
            for (int i = arr.length / 2 - 1; i >= 0; i--) {
                maximumHeap(arr,i, arr.length);
            }
            // 排序
            for (int i = arr.length - 1; i >= 0; i--) {
                // 过程中的每一步数组元素的变化过程
                 System.out.println(Arrays.toString(arr));
                swap(arr,0,i);
                length--;
                maximumHeap(arr,0, length);
            }
    
            System.out.println(Arrays.toString(arr));
        }
    
        public static void maximumHeap(int[] arr,int i ,int length) {
            int tmp = arr[i];
            for (int j = 2 * i + 1;j < length; j = j * 2 + 1) {
                // 右孩子比左孩子要大,那么指向右孩子
                if (j+1 < length && arr[j] < arr[j+1]) {
                    j++;
                }
                // 右孩子比根节点要大,一直往下探寻
                if (arr[j] > tmp) {
                    arr[i] = arr[j];
                    i = j;
                }
                //将temp放到最终位置
                arr[i] = tmp;
            }
        }
    
        public static void swap(int[] arr,int a,int b) {
           int tmp = arr[a];
           arr[a] = arr[b];
           arr[b] = tmp;
        }
    
    }
    

    如果只想看最后结果,可以在buildHeap()函数里把详细过程的输出打印代码注释掉就可以只看最后排序结果了。

    package heapsort;
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    /**
     * @author zhouyanxiang
     * @Date 2020-12-2020/12/30-10:50
     */
    public class BigHeapSort {
    
        public static void main(String[] args) {
            int[] arr = {5,4,8,9,6};
            buildHeap(arr);
        }
    
        public static void buildHeap(int[] arr) {
            int length = arr.length;
            // 先构建一个大顶堆
            for (int i = arr.length / 2 - 1; i >= 0; i--) {
                maximumHeap(arr,i, arr.length);
            }
            // 排序
            for (int i = arr.length - 1; i >= 0; i--) {
                // 过程中的每一步数组元素的变化过程
                // System.out.println(Arrays.toString(arr));
                swap(arr,0,i);
                length--;
                maximumHeap(arr,0, length);
            }
    
            System.out.println(Arrays.toString(arr));
        }
    
        public static void maximumHeap(int[] arr,int i ,int length) {
            int tmp = arr[i];
            for (int j = 2 * i + 1;j < length; j = j * 2 + 1) {
                // 右孩子比左孩子要大,那么指向右孩子
                if (j+1 < length && arr[j] < arr[j+1]) {
                    j++;
                }
                // 右孩子比根节点要大,一直往下探寻
                if (arr[j] > tmp) {
                    arr[i] = arr[j];
                    i = j;
                }
                //将temp放到最终位置
                arr[i] = tmp;
            }
        }
    
        public static void swap(int[] arr,int a,int b) {
           int tmp = arr[a];
           arr[a] = arr[b];
           arr[b] = tmp;
        }
    
    }
    

    小顶堆的只需要修改那个maximumHeap()函数里面的arr[j]和tmp的比较语句,还有左孩子和右孩子的比较语句,把比较的大于小于号分别改为相反的就行。

    package heapsort;
    
    import java.util.Arrays;
    
    /**
     * @author zhouyanxiang
     * @Date 2020-12-2020/12/30-10:50
     */
    public class BigHeapSort {
    
        public static void main(String[] args) {
            int[] arr = {5,4,8,9,6};
            buildHeap(arr);
        }
    
        public static void buildHeap(int[] arr) {
            int length = arr.length;
            // 先构建一个大顶堆
            for (int i = arr.length / 2 - 1; i >= 0; i--) {
                maximumHeap(arr,i, arr.length);
            }
            // 排序
            for (int i = arr.length - 1; i >= 0; i--) {
                // 过程中的每一步数组元素的变化过程
                 System.out.println(Arrays.toString(arr));
                swap(arr,0,i);
                length--;
                maximumHeap(arr,0, length);
            }
    
            System.out.println(Arrays.toString(arr));
        }
    
        public static void maximumHeap(int[] arr,int i ,int length) {
            int tmp = arr[i];
            for (int j = 2 * i + 1;j < length; j = j * 2 + 1) {
                // 右孩子比左孩子要大,那么指向右孩子
                if (j+1 < length && arr[j] > arr[j+1]) {
                    j++;
                }
                // 右孩子比根节点要大,一直往下探寻
                if (arr[j] < tmp) {
                    arr[i] = arr[j];
                    i = j;
                }
                //将temp放到最终位置
                arr[i] = tmp;
            }
        }
    
        public static void swap(int[] arr,int a,int b) {
           int tmp = arr[a];
           arr[a] = arr[b];
           arr[b] = tmp;
        }
    
    }
    

    展开全文
  • 本关任务: 输入N个字符串,编写程序将它们按照字符串长度大小进行升序排列。 相关知识 为了完成本关任务,你需要掌握: 1.指针数组的使用, 2.冒泡或者选择排序算法。 编程要求 根据提示,在编辑器补充代码,...

    任务描述

    本关任务: 输入N个字符串,编写程序将它们按照字符串长度大小进行升序排列。

    相关知识

    为了完成本关任务,你需要掌握: 1.指针数组的使用, 2.冒泡或者选择排序算法。

    编程要求

    根据提示,在编辑器补充代码,完成本关功能。

    测试说明

    平台会对你编写的代码进行测试: 若输入的5个字符串为: 123a 1 a abc123 1b2c3 输出结果为: 按照字符串长度大小进行升序排列为: 1 a 123a 1b2c3 abc123

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    #define SIZE 5 
    int main()
    {
    	char * str[SIZE];//定义指针数组,分别指向SIZE个字符串
    	int i,j;
    	char * ch; 
    	for(i = 0; i < SIZE; i++)
    	{
    		str[i] = (char *)malloc(sizeof(char)*10); 
    		scanf("%s",str[i]);//从键盘读取字符串,等价gets(str[i])	
    	}
    	for(i=0;i<SIZE;i++)
    	{
    		for(j=0;j<SIZE-i-1;j++)
    		{
    			if(strlen(str[j])>strlen(str[j+1]))
    			{
    				ch = str[j];
    				str[j]=str[j+1];
    				str[j+1]=ch;
    			}
    		}
    	}
    
    printf("按照字符串长度大小进行升序排列为:\n");
    for(i=0;i<SIZE;i++)
    	printf("%s\n",str[i]);
    printf("\n");
    return 0;
    }

    展开全文
  • 题目:键盘上输入五个整数分别存放变量a,b,c,d,e中,将这五个数按升序排列并且输出。 思路:定义最大值,最小值函数。通过函数迭代,求出每组最小值,再通过对调法,将最小值一次置于变量a,b,c,d,e。...
  • 如果把待排序序列分为未排序区间和有序区间,堆排序的思想是每次选一个数放有序区间,没经历一个循环有序区间就会加一,无序区间减一,循环结束序列也就有序了,像这样: 可以发现堆排序的思路和选择排序很像...
  • * 实验二 10个元素数组冒泡排序 小到大 */ #include <iostream> using namespace std; void bubblesort(int array[]) { for (int i = 0; i < 10 - 1; i++) { bool flat = false; for (int j = 0; j &...
  • #三个数比较大小,然后按照升序输出 nums = [22,6,12] if nums[0] > nums[1]: if nums[1] > nums[2]: print(nums[2],nums[1],nums[0]) elif nums[2] > nums[0]: print(nums[1],nums[0],nums[2]) else: ...
  • 其中begin为指向待sort()的数组的第一个元素的指针,end为指向待sort()的数组的最后一个元素的下一个位置的指针(注:类似于左闭右开区间),cmp参数为排序准则,cmp参数可以不写,如果不写的话,默认从小到大进行...
  • Time:Created on 2016-08-29 Author: Sure ''' ----------------------------------------------------------------------------- 题目:将输入的数由小到大排序输出 """ #!/usr/bin/python # -*- coding: UTF-8 -*...
  • 把打印的那里改成System.out.println();就可以了,目前那里是.../***str(需要排序的字符串),desc(true:从小到大,false:大到)*@paramstr*@paramdesc*/publicstaticvoidstringSort(Stringstr,booleandesc)...
  • import java.util.Arrays;import java.util.Scanner;public class SortArray {public static void main(String[] args) {// TODO Auto-generated method stubint[] A = new int[3];int[] B = new int[3];...
  • 给你一个正整数组成的数组 nums ,返回 nums 中一个 升序 子数组的最大可能元素和。 子数组是数组中的一个连续数字序列。 已知子数组 [numsl, numsl+1, …, numsr-1, numsr] ,若对所有 i(l <= i < r),nums...
  • ,arr[minindex] arr[i], arr[minindex] = arr[minindex],arr[i] print(arr) #打印:[99, 88, 78, 67, 56, 34, 32, 22, 5, 4, 3, 2, 1] #升序排列 arr1 = [1, 3, 99, 32, 22, 34, 4, 67, 5, 78, 88, 2, 56] l = len...
  • 参考【以右上角元素为基准】https://leetcode.com/problems/search-a-2d-matrix-ii/discuss/1001740/JAVA-oror-O(m%2Bn)-oror-Easy-to-understand * 以左下角做基准,tar比当前元素则往右找,tar比当前元素则往...
  • 【Python算法作业】“比较大小并计数,得到升序排列索引位置”的方法进行【升序排序】 # 【1.3.1】“比较大小并计数,得到升序排列索引位置”的方法进行【升序排序】 """ 算法思想:对于待排序的数组中的每一个...
  • 前言本文主要给大家介绍了一个功能,任意输入 3 个整数,编程实现对这 3 个整数由小到大进行排序。下面话不多少了,来一起看看详细的介绍吧实现过程:(1)定义数据类型,本实例中 a、b、c、t 均为基本整型。(2) 使用...
  • #输入是个整数,通过调用函数从大到小排序 #include<stdio.h> int sort(int b[],int n) { int i,j,k; for(i=0;i<n;i++) { for(j=i;j<n;j++) { if(b[i]<b[j]) { k=b[i]; b[i]=b...
  • 1、sort()简单排序sort() 函数对数值数组进行升序排序。将一个数组元素高进行简单排序,这个函数既可以按数字大小排列也可以按字母顺序排列。实例如下:...
  • 鉴于你的阵列>>> arrarray([[ 3.05706500e+06, 4.98000000e+01, -2.62500070e+01,-9.38135544e+01],[ 3.05706600e+06, 4.98000000e+01, -3.00000056e+01,-9.38135544e+01],[ 3.05706700e+06, 4.980000...
  • 1800. 最大升序子数组和 最大升序子数组和 给你一个正整数组成的数组 nums ,返回 nums 中一个 升序 子数组的最大可能元素和。 子数组是数组中的一个连续数字序列。 已知子数组 [numsl, numsl+1, …, numsr-1, ...
  • 判断升序

    2021-10-31 21:53:47
    判断整数数组元素是否已经按升序排序。 #include<stdio.h> int main() { int prev,next;//这个prev和next很形象啊 int flag=0;//标志,不用多说了吧 scanf("%d",&prev); while(scanf("%d",&...
  • 最大升序子数组和

    2021-03-26 21:26:02
    最大升序子数组和 题目描述 给你一个正整数组成的数组 nums ,返回 nums 中一个 升序 子数组的最大可能元素和。 子数组是数组中的一个连续数字序列。 已知子数组 [numsl, numsl+1, ..., numsr-1, numsr] ,若对所有 ...
  • 题目给出两个有序的整数数组A(长度m)和B(长度n) ,请将AB数组合并数组A中,变成一个有序的数组。算法思路合并后数据总长度m+n,最后一个元素的位置为A[m+n-1]从前(下标0)向后(下标m-1,n-1)合并需要挪动后续元素,...
  • ascii码值的大小顺序是怎样的?

    万次阅读 2021-05-20 02:48:27
    01ASCII码的值从小到大为数字、大写英文字母、小写英文字母。48~57为0到9十个阿拉伯数字;65~90为26个大写英文字母;97~122号为26个小写英文字母。ASCII(AmericanStandardCodeforInformationInterchange,美国...
  • 一、自己造轮子第一种方式的思路:拿出列表里的第0个元素,把它赋给一个叫做“最小值”的变量,然后用这个变量去跟后面的每个数字一一对比,如果碰到比它的,就把那个新发现的数字赋给“最小值”变量,否则维持...
  • sort()方法用于对数组的元素进行排序。 排序顺序可以是字母或数字,并按升序或降序。 默认排序顺序为按字母升序。...js sort排序是从小到大还是大到</title> <meta http-equiv="Content-Type" content.
  • 实现数组大到或从小到大排列(冒泡排序) 题目 编写一个程序,输入两个包含5个数值的数值,先将两个数组升序(从小到大)排列,然后将两个素组合并成一个升序素组: 题目分析 1、 通过题目我们已知要求排列数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 227,844
精华内容 91,137
关键字:

升序从大到小