精华内容
下载资源
问答
  • 交换数组元素 二重循环 其他常用排序法 本节是贸大95%学生的噩梦。其实我觉得,之所以是噩梦,可能只是老师没讲清楚,自己上课没认真听,ppt也没说清楚导致的。所以我在这里会尽可能地简单地把冒泡排序法拆解成...

    以下是本节涉及的知识点

    • 冒泡排序法
    • 交换数组元素
    • 二重循环
    • 其他常用排序法

    本节是贸大95%学生的噩梦。其实我觉得,之所以是噩梦,可能只是老师没讲清楚,自己上课没认真听,ppt也没说清楚导致的。所以我在这里会尽可能地简单地把冒泡排序法拆解成一个一个的小步骤。希望各位能尽可能地理解。

    当然实在理解不了也没问题。本来排序法就不是考试的重点,只有一个比较小的概率会出成程序大题。但是如果理解了的话,会对自己编程能力有很大提升

    首先还是说说排序法为什么很重要

    • 排序是很常见的操作
      我们在很多情况下都需要对数据进行排序,比如考试成绩出来了,我们想看自己排在第几名,亦或是玩牌的时候对自己抽到的牌按自己希望的顺序排列,都需要用到排序。
    • 排序是很复杂的操作
      把东西按照自己希望的顺序去排列,即使在现实中也是一个相当大的工程量(请自行想象把一个考室所有学生的卷子打乱,再让你按学号从小到大顺序排列)图书管理员为图书辛辛苦苦编号,分门别类排列,就只为减少排序和查找的工作量。

    排序的方法有很多种,我们现阶段可能接触得到有冒泡排序法、选择排序法、插入排序法和快速排序法。它们都是以排序方法的基本思路命名的。就我个人而言,我在现实中对什么文件进行排序的话,我都是用的插入排序法(下面会介绍其基本思路)。

    冒泡排序法基本原理

    冒泡排序法是排序法里面最低级,最低效,但也是最简单的一种排序法,因为其对元素的排序过程像是水中的气泡在上浮,所以被称为冒泡排序法。

    其基本思路是这样的:逐个比较相邻元素,如果有顺序不对的,就把它们调换,使得顺序正确。只走访一次数组,基本上不能完成排序。但只要我们不断重复走访数组,不断地找到顺序有误的相邻元素,不断地纠正其顺序,就可以实现让数组按顺序排列。

    比如下面是一个例子,我们试图把下面的数组按从小到大顺序排列:
    5 1 4 2 3
    对于这个数组,我们首先比较其头两个元素,发现51的顺序反了,1应该在5的前面,所以我们把51调换位置,得到
    1 5 4 2 3
    接下来我们比较第2个和第3个元素,发现54的顺序依旧反了,所以我们让54调换位置,得到
    1 4 5 2 3
    接下来是第3个和第4个元素,发现52的顺序依旧反了(事实上,直到5被放到最后之前,都一直是5和其他数比较),所以我们让52调换位置,得到
    1 4 2 5 3
    接下来是第4个和第5个元素,发现53的顺序依旧反了,所以我们让53调换位置,得到
    1 4 2 3 5
    到这里,我们已经成功走访了一次数组,并实现了4次调换。会发现此时的数组已经开始稍微有点顺序了。
    此时在数学上可以证明:数组中最大的元素已经被我们移到数组末尾,不论它原先在什么位置

    但数组还没有实现完全的按顺序排列。所以我们重新开始比较头两个元素:
    1 4 2 3 5
    其头两个元素,14的顺序是正确的,所以我们不调换其位置。下面比较第2和第3个元素:
    1 4 2 3 5
    我们发现42的顺序反了,所以我们把42交换顺序,得到:
    1 2 4 3 5
    下面比较第3和第4个元素,发现43的顺序反了,所以我们把43交换顺序,得到:
    1 2 3 4 5
    因为前一次走访中,我们已经让最大的元素移到了第5号位置,所以此时无需再比较第4和第5个元素,因为第5个元素必然是最大的。
    由于这个操作和前一次走访数组是一样的,所以同理也有这个性质:数组中第二大的元素已经被我们移到了倒数第二的位置,不论它原先在什么位置

    当然此时已经把数组排好序了,但如果顺序依旧不对的话,也是这样做。让第三大的元素排到倒数第3号位,直至数组实现完全从小到大顺序排列。

    至此,数组排序完毕。
    我们可以发现,元素5在第一次走访数组的时候,从数组的第一号位置,逐渐移到最后一号位置,其行为就像是一个石头逐渐下沉(或者一个气泡逐渐上浮),这就是冒泡排序法的名字由来。

    用数学化的语言来说,冒泡排序法就是这样的:

    • 对于一个长度为N的数组:

      • 对于其第1到第N-1个元素,我们逐一比较这个元素与其之后的元素的大小顺序,若相反,则交换他们次序,使得这两个元素顺序正确
      • 走访第一遍以后,我们可以确保最大的元素已经在最后的位置了
    • 然后我们就只需要对数组的前面1N-1个元素进行排列

      • 排列的方法是一样的,不过现在我们走访只需要走访其第1到第N-2个元素了。
      • 当此次走访完后,我们可以确保原数组里面倒数第二大的元素已经在倒数第二个位置。也就是说数组的第N-1和第N个元素已经实现了有序排列
    • 接下来是对数组的前面1N-2个元素进行排列

      • 排列的方法是一样的,不过现在我们走访只需要走访其第1到第N-3个元素了。
      • 当此次走访完后,我们可以确保原数组里面倒数第三大的元素已经在倒数第三个位置。也就是说数组的第N-2到第N个元素已经实现了有序排列
    • 接下来就不断重复这个操作,需要排序的部分越来越短,后面已经排好序的部分越来越长

    • 直到需要排序的部分长度为1时,此时就不需要再进行任何排序。

    • 此时这个数组在数学上就已经可以被证明是有序排列的了。

    冒泡排序法的代码实现

    首先,还是从一个情景展开讨论:

    针对一个长度为N整数数组(假定N=15),其中可能有重复的数字,也可能没有。请用冒泡排序法使其内部元素按从小到大顺序排列。

    根据前面我们对冒泡排序法的讲解,我们可以把这个情景分解为如下步骤:

    1. 定义并初始化数组
    2. 判断某个元素与它后面的那个元素的大小关系,如果顺序反了,就交换它们的位置
    3. (第1次走访数组)对于前N-1个元素的每一个都执行一遍上述操作
      执行完前一操作后,(第2次走访数组)再对数组前N-2个元素的每一个执行一遍第二步的操作
      执行完前一操作后,(第3次走访数组)再对数组前N-3个元素的每一个执行一遍第二步的操作
      ……
      直到第N-2次走访数组,此时只需要对数组的前1个元素执行第二步的操作(对第1个和第2个元素调整顺序)。此时无需再次走访数组,数组已经达到有序状态。
      总结便是这样:
    4. 对于第i次走访数组,我们都对数组的前N-i个元素的每一个执行一遍第二步的操作。
      其中i1一直加到N-2
    5. 当上述操作结束后,数组变得有序。此时只需在屏幕上输出数组

    定义并初始化数组

    首先我们先把最简单的工作做了:定义并初始化数组:

    #include<iostream>
    using namespace std;
    
    int main(){
        const int N = 15;
        int a[N]={9,7,15,6,2,18,6,24,-3,12,7,15,1,0,4};
    }
    

    其中数字是我随便输的,可以发现其中有重复的数字。不过这并不影响我们排序。

    交换变量的值

    接下来我们来做最基础的工作:交换两个变量的值。我们一般情况下是需要引入一个新的变量来暂时存储其中一个,不然就很难进行交换。(可以理解为,想要把两个箱子的位置交换,必须先把一个箱子移到别的地方,再把另一个箱子挪到这个箱子位置,最后再把最开始那个箱子挪到正确的位置去。)
    交换的代码可以是这样:

    int tmp;
    tmp=a[j];
    a[j]=a[j+1];
    a[j+1]=tmp;
    

    这样便实现了对数组a下标为j和下标为j+1的元素之间的交换。

    实现两元素间调整顺序

    下面我们加入判断:只要数组a下标为j和下标为j+1的元素不满足从小到大的顺序关系,我们就把它们交换顺序。这个用if语句很容易实现:

    if(a[j]>a[j+1]){
        int tmp;
        tmp=a[j];
        a[j]=a[j+1];
        a[j+1]=tmp;
    }
    

    第一遍走访数组的情况

    下面,我们要对数组的前N-1个元素都要执行这个判断(之所以是N-1,是因为第N个元素后面没有元素了,a[j+1]就会下标越界了。无法比较,所以只比较到N-1N)用一个for循环便能做到:

    int j;
    for(j=0; j<=N-2; j++)
        if(a[j]>a[j+1]){
            int tmp;
            tmp=a[j];
            a[j]=a[j+1];
            a[j+1]=tmp;
        }
    

    注意循环的判断条件是N-2!因为我们之前一直用的是“前N-1元素”,而C++里面下标从0开始,N-1个元素的下标是N-2!千万不要弄错第几个元素和元素下标之间的区别。

    这里我用小于等于,是因为j可以取到N-2(此时比较下标为N-2N-1的元素,也就是第N-1和第N号元素)。写成 j<N-1也是可以的,但这样可能大家就会对N-1的由来觉得理所当然,所以为了强调下标的差别,我用小于等于。

    第i次走访数组的情况

    目前第一次走访数组的代码我们就写出来了。下面拓展到第i次走访数组,其实只是修改了for循环的判断条件而已:

    int j;
    for(j=0; j<=N-1-i; j++)
        if(a[j]>a[j+1]){
            int tmp;
            tmp=a[j];
            a[j]=a[j+1];
            a[j+1]=tmp;
        }
    

    要注意的是,我们这里定义的i是走访数组的次数。最初的时候,也就是第一次走访数组,i1而不是0。我们很容易推出循环判断条件应该是 j<=N-1-i(因为i=1时,就是前一步的情况,即N-2

    走访N-2次数组

    最难的地方已经过去了。下面只剩下让i1N-2不断循环了:

    int i;
    for(i=1; i<=N-2; i++){
        第i次走访数组,需要对数组下标为0到N-i-1的元素调整顺序 
    }
    

    把文字替换为前一步得到的代码,就是:

    int i, j, tmp;
    for(i=1; i<=N-2; i++)
        for(j=0; j<=N-1-i; j++)
            if(a[j]>a[j+1]){
                tmp=a[j];
                a[j]=a[j+1];
                a[j+1]=tmp;
            }
    

    因为这两个for循环里面实质上都只有一条语句,所以我在这里就省略了大括号,如果觉得看起来不舒服也可以加上。

    最后是输出

    长吁一口气吧,前一步的代码执行完毕后,数组就变得有序了!下面我们只需要在屏幕上输出数组就好了:

    for(i=0; i<N; i++){
        cout<<a[i]<<' ';
    }
    

    小结

    整理一下,我们现在都写了些什么:

    #include<iostream>
    using namespace std;
    
    int main(){
        //定义常量与数组 
        const int N = 15;
        int a[N]={9,7,15,6,2,18,6,24,-3,12,7,15,1,0,4};
        
        //执行冒泡排序操作 
        int i, j, tmp;
        //对于第i次走访数组 
        for(i=1; i<=N-2; i++)
            //我们对数组的前N-i个元素的每个元素调整顺序 
            for(j=0; j<=N-1-i; j++)
                //只要下标为j的元素比它后面的大,就需要调整顺序 
                if(a[j]>a[j+1]){
                    //我们交换下标为j元素和其后面的元素 
                    tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                }
        
        //在屏幕上输出数组 
        for(i=0; i<N; i++){
            cout<<a[i]<<' ';
        }
    }
    

    参见附件知识网络1.4.1,运行一下看看效果吧。

    其实只是一个二重循环而已,但是

    • 内层循环的边界条件却在不断发生变化。
    • 两个for循环的初始化条件和循环条件都和常规for循环不太一样。
    • 两重循环不能像前面几个例子那样分开考虑,它们相互关联。

    这便是冒泡排序法真正难倒人的地方。

    为什么我的代码和PPT上的不太一样?

    我们在这里定义的i和j的意义可能与PPT的不太一样,所以导致两个for循环的边界条件不太一样。同时我们还用的是小于等于而不是小于,这也是导致区别的主要原因。
    看原代码:

    for(i=1; i<=N-2; i++)
        for(j=0; j<=N-1-i; j++)
            if(a[j]>a[j+1]){
                tmp=a[j];
                a[j]=a[j+1];
                a[j+1]=tmp;
            }
    

    注意到第一个for循环里面i<=N-2i<N-1等价,j<=N-1-ij<N-i等价,如果这么一换的话,-1就直接没了,for循环会更好看一点,但是此时for循环的条件可能没有前面那个易懂:

    for(i=1; i<N-1; i++)
        for(j=0; j<N-i; j++)
            if(a[j]>a[j+1]){
                tmp=a[j];
                a[j]=a[j+1];
                a[j+1]=tmp;
            }
    

    如果我们比较的不是某元素与其后面的元素顺序,而是比较与其前面的顺序的话,j的意义会发生本质变化。此时我们再稍微调整一下i的大小,此时i也失去了其原本意义,但是会让我们的两个for循环越来越接近我们以前接触的循环:

    for(i=0; i<N-2; i++)
        for(j=1; j<N-i; j++)
            if(a[j-1]>a[j]){
                tmp=a[j];
                a[j]=a[j-1];
                a[j-1]=tmp;
            }
    

    又或是ppt上的那个冒泡排序不是最大的往后走,而是最小的往前走,此时for循环的结构会变得更多(j++会变成j--,还有好多地方都要修改)。

    介绍了这么多微妙变化的版本,其实只是想说,这些都是正确的。没有一个绝对正确的答案

    后话:冒泡排序的可视化

    这个不是考点。只是这样做,能把冒泡排序的过程更加清晰地展示出来,可能让我们对冒泡排序的理解更加深刻。

    在每次for循环的时候,可以执行一遍输出,把正在排序的数组展示出来,可以让我们看清楚冒泡排序每次循环都干了些什么:

    #include<iostream>
    using namespace std;
    
    int main(){
        //定义常量与数组 
        const int N = 15;
        int a[N]={9,7,15,6,2,18,6,24,-3,12,7,15,1,0,4};
        
        //排序前进行输出 
        cout<<"排序前:"<<endl;
        for(int k=0; k<N; k++){
            cout<<a[k]<<' ';
        }
        cout<<endl;
        cout<<"下面是排序过程:"<<endl;
        //执行冒泡排序操作 
        int i, j, tmp;
        //对于第i次走访数组 
        for(i=1; i<=N-2; i++){
            //我们对数组的前N-i个元素的每个元素调整顺序 
            for(j=0; j<=N-1-i; j++){
                //只要下标为j的元素比它后面的大,就需要调整顺序 
                if(a[j]>a[j+1]){
                    //我们交换下标为j元素和其后面的元素 
                    tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                }
                
            }
            //每次走访数组完毕后进行输出 
            for(int k=0; k<N; k++){
                cout<<a[k]<<' ';
            }
            cout<<endl;
        }
        //排序前进行输出 
        cout<<"排序后:"<<endl;
        for(int k=0; k<N; k++){
            cout<<a[k]<<' ';
        }
        cout<<endl;
    }
    

    这个版本中,在排序前和每次走访完数组(即外层的循环里面,如果在内层循环,则是每次比较元素后都会输出,输出会太多不好看)都会把数组的内容输出的屏幕上。
    参见附件知识网络1.4.2,运行一下看看效果吧。

    可以发现,冒泡排序的排序过程和我们之前预想的是一样的。

    后话:别的排序方法呢?

    非考点。
    除了冒泡排序法外,常用的基础排序法还包括选择排序法、插入排序法、快速排序法等。
    下面简要介绍这些排序的主要思路:

    • 选择排序:从数组中找到最大值,将其移到数组末尾。再从剩下的元素里面找到第二大的,移到倒数第二位置。有点像冒泡排序法的原理,但其中部分细节不太一样。
    • 插入排序:对于数组中的每个元素,我们将它和已经排好序的部分逐个比较,看它能插入到这个这个有序的部分的哪里,始终保持这个部分的有序。当最后一个元素被插入时,整个数组也就有序了。
    • 快速排序:因为它比一般的排序算法快而得名。基本原理是,把数组按某个元素为分界,把所有小于这个元素的元素移到它的左边,大于的移到它的右边。然后对这个元素左右两边分别再执行上述操作。

    如果对其余的排序算法感兴趣的话,可以参考阅读下面的文章:
    http://www.cnblogs.com/eniac12/p/5329396.html
    这里面还有很多动图,可以形象地展示排序的过程。
    (后面有些算法的动图可能会让你赞叹人类智慧的伟大(奸笑))

    展开全文
  • $list=array(); foreach($data as $arr2){ //list是指定排序的列 $list[]=$arr2["list"]; } array_multisort($list,SORT_DESC,$data); $data就是想要的效果

    $list=array();

    foreach($data as $arr2){

    //list是指定排序的列

           $list[]=$arr2["list"];

    }

    array_multisort($list,SORT_DESC,$data);

    $data就是想要的效果

     

    作为一名合格的程序员不仅需要好的代码编写能力,还需要掌握服务器相关知识,下面给大家推荐腾讯云搞活动的服务器,刚开始不需要服务器配置太好,纯当练手!点击链接查看活动:https://cloud.tencent.com/act/cps/redirect?redirect=33567&cps_key=32f906e6e5f3be5e8669b35951da56fc&from=activity

    展开全文
  • Java实现数组排序

    千次阅读 2020-12-01 10:31:45
    选择排序法即是先将第一个数据分别与右侧其他数据依次比较,当第一个数据较大时,对调两数据位置,最终第一个位置的数据将是数组元素的最小值;再对第二个数据分别与右侧其他数据依次比较,当第二个数据较大时,对调...

    选择排序法

    算法原理
    首先原数组(未按顺序)如下(第一行表示对应位置存储的数据,第二行是其对应数据的索引值)
    在这里插入图片描述
    选择排序法即是先将第一个数据分别与右侧其他数据依次比较,当第一个数据较大时,对调两数据位置,最终第一个位置的数据将是数组元素的最小值;再对第二个数据分别与右侧其他数据依次比较,当第二个数据较大时,对调两数据位置,最终第二个位置的数据将是除第一个数据之外的数组元素的最小值。同理可以进行其他位置的比较和对调。如下:
    在这里插入图片描述
    程序代码

    class test
    {
    	public static void main(String[] args)
    	{
    		int[] Arr = new int[]{14,52,56,32,17};
    		printArray(Arr);
    		selectSort(Arr);
    		printArray(Arr);
    	}
    	
    	public static void printArray(int[] arr)
    	{
    		System.out.print("[");
    		for(int x=0; x<arr.length; x++)
    		{
    			if(x!=arr.length-1)
    				System.out.print(arr[x]+",");
    			else
    				System.out.println(arr[x]+"]");
    		}
    	}
    	
    	public static void swap(int[] arr, int a, int b)
    	{
    		int temp = arr[a];
    		arr[a] = arr[b];
    		arr[b] = temp;
    	}
    	
    	//选择排序法
    	public static void selectSort(int[] arr)
    	{
    		for(int x=0; x<arr.length-1; x++)
    		{
    			for(int y=x+1; y<arr.length; y++)
    			{
    				if(arr[x]>arr[y])
    					swap(arr,x,y);
    			}
    		}
    	}
    }
    

    但是仔细沿着过程我们会发现,有的位置上其实进行了多次对调,当数据较少时性能影响不大,但是当数据量较大的时候,这必将带来运算的缓慢,于是我们可以想办法减少对调交换位置的次数。我们可以通过另外设置两个变量,以第一个数据的比较为例,先将第一位数据存储在num中,然后将第一个下标存储在index中,接下来用num与后边值依次比较,较小者直接赋值给num存储起来并用index存储下标,直到比较结束,最终将index指代的下标对应的数组数据与第一个数据进行交换,即可使得第一位数据为数组元素的最小值。以此类推,每一轮比较结束都可以使该轮的首位元素成为右边元素的最小值,同时每一轮也只进行了一次对调,显然减少了对调交换的次数。
    改进后的代码

    /*
    需求:对数组进行升序排序
    思路:利用选择排序算法
    步骤:
    1.定义生成一个未排序的数组
    2.打印原数组
    3.排序
    4.打印新数组
    */
    
    class test
    {
    	public static void main(String[] args)
    	{
    		int[] Arr = new int[]{14,52,56,32,17};
    		printArray(Arr);
    		selectSort2(Arr);
    		printArray(Arr);
    	}
    	
    	public static void printArray(int[] arr)
    	{
    		System.out.print("[");
    		for(int x=0; x<arr.length; x++)
    		{
    			if(x!=arr.length-1)
    				System.out.print(arr[x]+",");
    			else
    				System.out.println(arr[x]+"]");
    		}
    	}
    	
    	public static void swap(int[] arr, int a, int b)
    	{
    		int temp = arr[a];
    		arr[a] = arr[b];
    		arr[b] = temp;
    	}
    	
    	//选择排序法(改进)减少了换位次数
    	public static void selectSort2(int[] arr)
    	{
    		for(int x=0; x<arr.length-1; x++)
    		{
    			int num = arr[x];
    			int index = x;
    			for(int y=x+1; y<arr.length; y++)
    			{
    				if(num>arr[y])
    				{
    					num = arr[y];
    					index = y ;
    				}
    			}
    			if(index!=x)
    				swap(arr,index,x);
    		}
    	}
    }
    

    冒泡排序法

    算法原理
    首先原数组(未按顺序)如下(第一行表示对应位置存储的数据,第二行是其对应数据的索引值)
    在这里插入图片描述
    冒泡排序法即是先将第一个数据与第二个元素比较,当第一个数据较大时,对调两数据位置;再对第二个数据与第三个数据比较,当第二个数据较大时,对调两数据位置;以此类推一直比较到最后一个元素,最终最后位置的数据将是数组元素的最大值。如下:
    在这里插入图片描述
    程序代码

    /*
    需求:对数组进行升序排序
    思路:利用冒泡排序算法
    步骤:
    1.定义生成一个未排序的数组
    2.打印原数组
    3.排序
    4.打印新数组
    */
    
    class Array4
    {
    	public static void main(String[] args)
    	{
    		int[] Arr = new int[]{14,52,56,32,17};
    		printArray(Arr);
    		bubbleSort(Arr);
    		printArray(Arr);
    	}
    	
    	public static void printArray(int[] arr)
    	{
    		System.out.print("[");
    		for(int x=0; x<arr.length; x++)
    		{
    			if(x!=arr.length-1)
    				System.out.print(arr[x]+",");
    			else
    				System.out.println(arr[x]+"]");
    		}
    	}
    	
    	public static void swap(int[] arr, int a, int b)
    	{
    		int temp = arr[a];
    		arr[a] = arr[b];
    		arr[b] = temp;
    	}
    	
    	//冒泡排序法1
    	public static void bubbleSort(int[] arr)
    	{
    		for(int x=0; x<arr.length-1; x++)
    		{
    			for(int y=0; y<arr.length-1-x;y++)
    			{
    				if(arr[y]>arr[y+1])
    					swap(arr,y+1,y);
    			}
    		}
    	}
    }
    

    /*
    需求:对数组进行升序排序
    思路:利用冒泡排序算法
    步骤:
    1.定义生成一个未排序的数组
    2.打印原数组
    3.排序
    4.打印新数组
    */
    class Array4
    {
    	public static void main(String[] args)
    	{
    		int[] Arr = new int[]{14,52,56,32,17};
    		printArray(Arr);
    		bubbleSort2(Arr);
    		printArray(Arr);
    	}
    	
    	public static void printArray(int[] arr)
    	{
    		System.out.print("[");
    		for(int x=0; x<arr.length; x++)
    		{
    			if(x!=arr.length-1)
    				System.out.print(arr[x]+",");
    			else
    				System.out.println(arr[x]+"]");
    		}
    	}
    	
    	public static void swap(int[] arr, int a, int b)
    	{
    		int temp = arr[a];
    		arr[a] = arr[b];
    		arr[b] = temp;
    	}
    	
    	//冒泡排序法2
    	public static void bubbleSort2(int[] arr)
    	{
    		for(int x=arr.length-1; x>=0; x--)
    		{
    			for(int y=0; y<x; y++)
    			{
    				if(arr[y]>arr[y+1])
    					swap(arr,y+1,y);
    			}
    		}
    	}
    }
    

    直接调用库函数排序

    以上两种排序虽然涉及到算法基础,但是在实际工程应用中,性能并不算是太好,在实际应用中,java将排序函数封装到了库中,我们一般直接调用来使用。

    /*
    需求:对数组进行升序排序
    思路:直接导入库调用数组函数
    步骤:
    1.定义生成一个未排序的数组
    2.打印原数组
    3.排序
    4.打印新数组
    */
    import java.util.*;
    
    class Array4
    {
    	public static void main(String[] args)
    	{
    		int[] Arr = new int[]{14,52,56,32,17};
    		printArray(Arr);
    		Arrays.sort(Arr);
    		printArray(Arr);
    	}
    	
    	public static void printArray(int[] arr)
    	{
    		System.out.print("[");
    		for(int x=0; x<arr.length; x++)
    		{
    			if(x!=arr.length-1)
    				System.out.print(arr[x]+",");
    			else
    				System.out.println(arr[x]+"]");
    		}
    	}
    	
    	public static void swap(int[] arr, int a, int b)
    	{
    		int temp = arr[a];
    		arr[a] = arr[b];
    		arr[b] = temp;
    	}
    }
    
    展开全文
  • 有时候会遇到将B数组按照A数组进行排序的情况,尤其是在写程序统计频率的时候。之前遇到过一次,然后情急之下是采用的冒泡排序算法,后进行关联排序。这样效率低了。今天有幸看到了一位博主的解法,就是用ZIP来...

    有时候会遇到将B数组按照A数组进行排序的情况,尤其是在写程序统计频率的时候。之前遇到过一次,然后情急之下是采用的冒泡排序算法,后进行关联排序。这样效率太低了。今天有幸看到了一位博主的解法,就是用ZIP来进行数组压缩,再完成排序。下面分别把这个方法演示一下,还有就是展示一下实战效果。


    1.简单用法

    A = ['a', 'b', 'c', 'd', 'e']  # 出现的元素
    B = [1, 5, 0, 45, 78]  # 元素出现的次数(统计结果)
    
    Z = zip(B, A)  # 对AB进行封装,把频率放在前面
    Z = sorted(Z, reverse=True)  # 进行逆序排列
    B, A = zip(*Z)  # 进行解压,其中的AB已经按照频率排好
    for i,j in zip(B, A):
        print(i,'\t',j)

    最终结果:

    78 	 e
    45 	 d
    5 	 b
    1 	 a
    0 	 c

    需要注意的地方是:

    1.封装时要将频率放在前面

    2.解压的时候Z前面有个*

    2.实战演练

    在构建知识图谱时,对文章进行三元组抽取后要进行关系统计,已经将所有的关系找了出来,并且统计了频率。

    好了,现在就是要对频率进行逆序排列,用这个方法:

    for i in relationship:
        if i not in words:
            words.append(i)
            times.append(1)
        else:
            times[words.index(i)] = times[words.index(i)] + 1
    print(words)
    print(times)
    Z = zip(times, words)
    Z = sorted(Z, reverse=True)
    print(Z)
    times, words = zip(*Z)
    for i, j in zip(times, words):
        print(i, '\t', j)

    最终结果:

    1733 	 SameAs
    1102 	 是
    600 	 包括
    549 	 有
    520 	 为
    253 	 出现
    202 	 可见
    192 	 如
    153 	 可出现
    138 	 呈
    128 	 可有
    121 	 无
    100 	 显示
    100 	 导致
    95 	 分为

    知识图谱抽取效果图:

     

     

    展开全文
  • 对数组元素进行排序

    2019-06-12 13:00:00
     就是将数组从第一个元素开始,依次与后面的元素进行比较,再将比较的最值替换。 1 public class Demo{ 2 public static void main(String[] args) { 3 int[] arry= {15,2,0,6,-3,49}; 4 printArray(arry...
  • php实现数组按指定KEY排序的方法本文实例讲述了php实现数组按指定KEY排序的方法。分享给大家供大家参考。具体实现方法如下:function array_sort($arr,$keys,$orderby='asc'){$keysvalue = $new_array = array();...
  • C语言数组排序

    万次阅读 2019-03-25 19:56:34
    输入某门课的成绩,按编程将分数从高到低顺序进行排序输出 第一种:采用交换法排序,也称作冒泡排序。 基本过程是先将第一个数分别于后面的数一个一个进行比较,若后面的数小,则交换后面这个数和第一个数的位置,...
  • MATLAB中对cell数组排序

    千次阅读 2020-10-08 21:11:49
    近期在干啥差不多有24天没写推送了。。。...一直干活,期间好几晚都没回宿舍,惨了,净在干些没啥用的事情。虽然不想干,但确实学到了一些东西(大半个月没找工作了,更想找工作来着)。MATLA...
  • 文章目录数组一、数组定义方法二、数组包括的数据类型三、获取数组长度四、数组遍历五、数组切片六、数组替换七、数组删除八、数组追加元素九、向函数传数组参数十、排序算法1.冒泡排序算法2.直接选择排序2.反转排序...
  • 数组合并排序和快速排序

    千次阅读 2018-06-18 23:09:13
    学习C语言的都知道很时候我们都需要对数组进行排序,之前给大家分享了选择排序和冒泡排序,现在给大家分享一个比较难一点数组合并排序和快速排序。同样分析其相应的时间复杂度和空间复杂度。如果分析错了,还望...
  • C语言——数组中的插入排序法!

    千次阅读 2020-07-19 11:15:03
    C语言——插入排序法! C语言中有很多排序的方法,这次我先介绍一下插入排序法。
  • 如何将一个数组元素顺序打乱

    千次阅读 2021-03-06 16:55:55
    这个算法其实简单,首先从所有元素中随机选取一个与第一个元素进行交换,然后在第二个之后选择一个元素与第二个交换,直到最后一个元素。这样能确保每个元素在每个位置的概率都是1/n。代码如下:#include #include #...
  • 因为我发现每日一题难了,总会出现一些加班已经很累了(懒得不想动)的时候,而且周末有事做两道题都叫做同一天的每日一题也让我这个强迫症贼难受. 因此![每日一题]系列从今天开始变为[随缘一题]系列! 来源: ...
  • python 删除多行数组元素

    万次阅读 2017-12-18 17:36:35
    笔者在项目过程中需要删除连续的多行数组,查了好多资料,发现python只能一行一行的删除,如果删除连续的多行的话,由于其中指针的变化,会出现后面数组的指标越界的现象,为此,将资料进行整合,以及给出自己的代码...
  • 删除一个数组或字符串中的重复...2.用将数组元素向前移覆盖掉重复元素的方法删除重复元素。 #include<stdio.h> #include<string.h> int num; void rank(char *str,int num) { int i,j; char temp...
  • 经过我的测试,js内置方法sort的效率非常高我们知道在js中默认提供了sort函数,但是这个函数默认是按照数组内容的ascii码升序进行排列的,如果我们要对二维数组排序要如何做呢?在php中是有multi_...
  • Day5 数组中插入元素与插入排序

    千次阅读 2021-01-24 15:17:49
    Day5 数组中插入元素 那么接下来,我们趁热打铁,先学习最基础的数据结构:array(数组)和vector(向量),数据结构和算法是相辅相成的,二者结合彰显算法之美,所以对于常见的数据结构的掌握是很有必要的。 每日一...
  • 通用冒泡排序和指针数组

    万次阅读 2017-09-14 17:10:31
    指针在C语言中,可以使用指针对变量进行操作。 一个有意思的比喻是,把变量比作一个盒子,而把指针比作一个抽屉, 那么,一个不恰当的例子是,当你想要盒子里的东西的时候,你可以直接找到盒子,当然,也可以先...
  • Java日报 部门:**大数据开发六部 姓名:cqmfx(阡陌飞絮) 日期:2020.10.25 备注:部分转自百度,CSDN,菜鸟,侵权删 大纲 一、数组介绍 二、排序 数组那些事
  • IOS数组排序整理

    2016-12-12 11:56:44
    IOS数组排序整理demo git地址 说起ios的排序,方法有很种,最近正好有时间,做了一次整理,顺便测试了一下各种排序方法的效率,有不对的地方,望大家指正 测试的排序方法主要有以下几种: 插入排序(自己实现) ...
  • 学习了数据的基本类型,条件从句,循环等从句,到了c语言中重点也是比较难的一部分——数组数组的练习题是第一套让我卡这么久的练习题,直到写下这此博客的时间,我的oj上的题依旧有两个等待着我去攻克。在攻克...
  • 六、数组排序

    2021-11-12 23:16:07
    1.数组基础 1.1. 引入数组 1.2 数组的初始值与创建 1.3 数组练习 2. 数组扩容 2.1 自定义数组扩容 2.2 系统定义的数组扩容方法 3.数组中的方法封装 3.1 关于方法的传参 3.2 可变参数 3.3 方法的返回值返回...
  • 冒泡排序数字数组和字符串数组

    千次阅读 2016-04-19 17:57:07
    冒泡排序: 将一个整形数组中的元素按照从小到大的顺序排列,具体方法:数组元素进行一次依次循环比较,找出最大的元素,放在数组最右边, 嵌套循环时要注意循环次数的控制, 进行n-1趟冒泡排序后,就完成了,这里...
  • 思路1:可以用hash表来存储数组中的元素,这样我们取得一个数后,去判断sum - val 在不在数组中,如果在数组中,则找到了一对二元组,它们的和为sum,该算法的缺点就是需要用到一个hash表,增加了空间复杂度。...
  • 对数组进行重新排序

    千次阅读 2017-08-15 01:26:34
    时候,我们从数据库中取出我们要的数据后,并不是就完成了工作,更的我们需要对数据进行遍历处理等,这时候我们从数据库中获取数据时的排序可能就被打乱了, 需要对数组重新排序,下面就写写汇总到的对一维和...
  • ' 使用%s占位符, 使用 % 表示需要格式化字符串,后跟tuple变量 使用list和tuple list其实就是数组,定义:['1', 'hello'] 使用len(list)计算数组元素个数 使用(1, 2, 3)定义tuple,其实就是不可变的数组。...
  • 指针数组的输入输出和排序

    千次阅读 2014-01-09 13:56:30
    有时用二维数组方便的时候,或者数据较大时,可能会超时,解决的办法就是用指针数组,但在百度,谷歌.......等,对指针数组的输入都没有详细的介绍,今天我就给大家介绍,指针数组的输入和输出,以及注意事项。 ...
  • js 数组排序

    千次阅读 2018-08-16 21:12:05
    代码改变世界 Posts - 29, Articles - 0, Comments - 62  Cnblogs   Dashboard   Login HOME CONTACT GALLERY RSS ...js中的数组对象排序 2014-04-27 19:15 by 那时候的我, 66416...
  • 快排查找数组中的第K个最大元素

    千次阅读 2021-11-08 02:08:07
    排序一个数组,先把数组从中间分成前后两部分,然后对前后两部分分别排序,再将排好序的两部分合并,整个数组就有序了。 使用的分治思想,跟递归思想很像。 因为分治算法一般都是用递归实现: 分治是一种解决...
  • * 具体的流程是 数组---》大顶堆(或者是小顶堆)---》第一个个元素和最后一个元素调换位置---》重复元素下沉,以完成排序 */ public class HeapSort { // 将一个数组 转化成 大顶堆 (根节点一定是比 左右子节点...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 91,772
精华内容 36,708
关键字:

数组元素太多怎么进行排序