精华内容
下载资源
问答
  • 选择排序法与冒泡排序法的区别

    千次阅读 2014-11-05 11:25:11
    以下是选择排序法与冒泡排序法的对比,给初学者的一个参考! 代码如下: #include<stdio.h> #include<time.h> #include<stdlib.h> #define N 12 int main(void) { int ch[N]; int i,j,min,...

    以下是选择排序法与冒泡排序法的对比,给初学者的一个参考!

    代码如下:

    #include<stdio.h>
    #include<time.h>
    #include<stdlib.h>
    #define N 12
    
    int main(void)
    {
        int ch[N];
        int i,j,min,temp;
        printf("%d rand number:\n",N);
        srand(time(NULL));
        for(i=0;i<N;i++) {
            ch[i]=rand()%100; //产生100以内的随机数
            printf("%d ",ch[i]);
        }
        printf("\n");
    
        //selectsort
        for(i=0;i<N;i++) {
           min=i;
           for(j=i+1;j<N;j++) {
             if(ch[min]>ch[j]) {
                min=j;
             }
          }
          if(min != i) { 
              temp=ch[i];
              ch[i]=ch[min];
              ch[min]=temp;
          }
    }
    
    printf("selcet sorted is:\n");
    for(i=0;i<N;i++) {
      printf("%d ",ch[i]);
    }
    printf("\n");
    
    
    //bubblesort
    
    
    for(i=0;i<N-1;i++) {
      for(j=0;j<N-1-i;j++) {
        if(ch[j+1]<ch[j]) {
            temp=ch[j];
            ch[j]=ch[j+1];
            ch[j+1]=temp;
        }
      }
    }
    
    printf("bubble sorted is:");
    for(i=0;i<N;i++) {
      printf("%d ",ch[i]);
    }
    printf("\n");

     

    //有不正之处请指正!

     

     

     

    展开全文
  • 为了更好的理解两种方法的区别,我们分别用图解和代码实现来区分一下~ 例如有一组数据arr[5]={9,5,7,3,0},分别用两种方法对其进行排序选择排序图解说明 如图,数组arr有5个数,需要比较4次,如果按照从小到大...

    为了更好的理解两种方法的区别,我们分别用图解法和代码实现来区分一下~
    例如有一组数据arr[5]={9,5,7,3,0},分别用两种方法对其进行排序

    选择排序法图解说明
    这里写图片描述

    如图,数组arr有5个数,需要比较4次,如果按照从小到大排序的话;第一次比较:将数组中arr[0]与后面的每个元素进行比较,找到最小的元素与arr[0]交换,再进行第二次比较;第二次比较,将数组中arr[1]与后面的每个元素进行比较,找到第二小的元素与arr[1]交换……依次循环

    冒泡排序法图解

    这里写图片描述

    如图,冒泡排序法的思路:每次将相邻两个数进行比较,将小的调到前头,依次冒泡从而实现排序

    接下来用代码分别简单实现一下~
    选择排序法的数组实现代码

    #include<stdio.h>
    void sort(int arr[], int n)
    {
        int i, j, k, t;
        for (i = 0; i < n - 1; i++)//排序需要排n-1次
        {
            k = i;//排到arr[i]位置上
            for (j = i + 1; j < n; j++)//查找第i小的元素
            {
                if (arr[j] < arr[k])
                {
                    k = j;//将最小值下标j附给k
                }
            }
            t = arr[k];
            arr[k] = arr[i];
            arr[i] = t;     //进行交换
        }
    }
    int main()
    {
        int i = 0;
        int arr[] = { 9, 5, 7, 3, 0 };
        sort(arr, 5);
        for (i = 0; i < 5; i++)
        {
            printf("%d ", arr[i]);
        }
        system("pause");
        return 0;
    }

    选择排序法的指针实现代码

    void sort(int *arr, int sz)
    {
        int i, j, k;
        for (i = 0; i < sz - 1; i++)//排序需要排n-1次
        {
            k = i;//排到arr[i]位置上
            for (j = i+1; j < sz; j++)//查找第i小的元素
            {
                if (*(arr + j) < *(arr + k))
                {
                    k = j;//将最小值下标j附给k
                }
            }
                    int *tmp = *(arr + k);
                    *(arr + k) = *(arr + i);
                    *(arr + i) = tmp;     
        }
    }
    print(int *arr, int sz)
    {
        int i;
        for (i = 0; i < sz; i++)
        {
            printf("%d ", *(arr + i));
        }
        printf("\n");
    }
    int main()
    {
        int i = 0;
        int arr[] = {9,5,7,3,0};
        int sz = sizeof(arr) / sizeof(arr[0]);
        sort(arr, sz);
        print(arr,sz);
    
        system("pause");
        return 0;
    }

    冒泡排序法的数组实现代码

    #include<stdio.h>
    int main()
    {
        int a[5] = {9,5,7,3,0};
        int i = 0;
        int j = 0;
        int tmp = 0;
        for (i = 0; i < 4; i++)//比较4趟
        {
            for (j = 0; j < 4 - i; j++)//每趟两两比较4-i次
            {
                if (a[j]>a[j + 1])
                {
                    tmp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = tmp;
                }
            }
        }
        for (i = 0; i < 5; i++)
        {
            printf("%d ", a[i]);
        }
        system("pause");
        return 0;
    }

    冒泡排序法的指针实现代码

    void bubble_sort(int *arr,int sz)
    {
        int i = 0;
        int j = 0;
        for (i = 0; i < sz - 1; i++)
        {
            for (j = 0; j < sz - 1 - i; j++)
            {
                if (*(arr + j)>*(arr + j + 1))
                {
                    int *tmp = *(arr + j);
                    *(arr + j )= *(arr + j + 1);
                    *(arr + j + 1) = tmp;
                }
            }
        }
    }
    print_sort(int *arr, int sz)
    {
        int i;
        for (i = 0; i < sz; i++)
        {
            printf("%d ", *(arr + i));
        }
        printf("\n");
    }
    
    int main()
    {
        int i = 0;
        int arr[] = { 9, 5, 7, 3, 0 };
        int sz = sizeof(arr) / sizeof(arr[0]);
        bubble_sort(arr, sz);
        print_sort(arr, sz);
        system("pause");
        return 0;
    }
    展开全文
  • 选择排序法与冒泡排序法的区别: 1.冒泡排序是比较相邻位置的两个数,而选择排序是按顺序比较,找最大值或者最小值; 2.冒泡排序每一轮比较后,位置不对都需要更换位置,选择排序每一轮比较都只更换一次位置; 3....

    选择排序法与冒泡排序法的区别:
    1.冒泡排序是比较相邻位置的两个数,而选择排序是按顺序比较,找最大值或者最小值;

    2.冒泡排序每一轮比较后,位置不对都需要更换位置,选择排序每一轮比较都只更换一次位置;

    3.冒泡排序是通过数去找位置,选择排序是给定位置去找数;

    代 码:

    一、冒泡排序法

    #include <stdio.h>
    
    int main()
    
    {
    
    int i,j,t,a[11]; //定义变量及数组为基本整型
    
    printf("请输入7个数:\n");
    
    for(i=1;i<8;i++)
    
    scanf("%d",&a[i]); //从键盘中输入7个数
    
    for(i=1;i<7;i++) //变量i代表比较的次数
    
    for(j=1;j<11-i;j++) //变最j代表每次两两比较的次数
    
    if(a[j]>a[j+1])
    
    {
    
    t=a[j]; //产利用中间变童实现两值互换
    
    a[j]=a[j+1];
    
    a[j+1]=t;
    
    }
    
    printf("排序后的顺序是:\n");
    
    for(i=1;i<=10;i++)
    
    printf("%5d",a[i]); //将冒泡排序后的顺序输出
    
    printf("\n");
    
    return 0;

    二、选择排序法

    # include <stdio.h>
    int main(void)
    {
        int i, j;  //循环变量
        int MinIndex;  //保存最小的值的下标
        int buf;  //数据互换时做的中间变换
        int a[] = {5, 6, 3, 7, 4, 2, 5, 4, 9, 1, 8, 6};
        int n = sizeof(a) / sizeof(a[0]);  //存放数组a中元素的个数
        for (i=0; i<n-1; ++i)  //n个数比较n-1轮
        {
            MinIndex = i;
            for (j=i+1; j<n; ++j)  //每轮比较n-1-i次, 找本轮最小数的下标
            {
                if (a[MinIndex] > a[j])
                {
                    MinIndex = j;  //保存小的数的下标
                }
            }
            if (MinIndex != i)  /*找到最小数之后如果它的下标不是i则说明它不在最左边, 则互换位置*/
            {
                buf = a[MinIndex];
                a[MinIndex] = a[i];
                a[i] = buf;
            }
        }
        printf("最终排序结果为:\n");
        for (i=0; i<12; ++i)
        {
            printf("%d ", a[i]);
        }
        printf("\n");
        return 0;
    }

     

    展开全文
  • 感觉自己混淆了选择排序冒泡排序了,求教如何区别? #include #include typedef struct list { int data; struct list *next; } SLIST; SLIST *creat(int *a) { SLIST *h,*p,*q; int i; h=p=(SLIST *)malloc...
  • 直接选择排序是将指定排序位置其他数组元素分别对比,如果满足条件就交换元素,注意区分冒泡排序,他不是交换相邻,而是把满足条件的与指定位置交换。比如array{7,8,6,5,9,3,1},指定把最大放在最后一位,...

    直接选择排序法是将指定排序位置与其他数组元素分别对比,如果满足条件就交换元素,注意区分冒泡排序,他不是交换相邻的,而是把满足条件的与指定位置的交换。

    比如array{7,8,6,5,9,3,1},指定把最大的放在最后一位,先从第一位开始比较,8比7大,则下一次就是6与8比较(因为6比8小),再5与8比较,以此类推

    for(int j=1;j<a.length;j++){   
    			int index=0;
    			for(int i=1;i<=a.length-j;i++){
    				if(a[i]>a[index]){
    					index=i;
    					/*
    					 * 交换下一个要比较的值,但不是交换两个值的内容
    					 * 比如a2与a1比较,现在换成a3与a2比较,而不是交换a2和a1的值				 
    					 */
    			
    			}
    							
    	}

    到最后一位再交换位置

    for(int j=1;j<a.length;j++){   
    			int index=0;
    			for(int i=1;i<=a.length-j;i++){
    				if(a[i]>a[index]){
    					index=i;
    					/*
    					 * 交换下一个要比较的值,但不是交换两个值的内容
    					 * 比如a2与a1比较,现在换成a3与a2比较,而不是交换a2和a1的值				 
    					 */
    			
    			}
    							
    	}
    			/*
    			 * 不能放在第二个for里面,因为要到最后再交换位置
    			 */
    			temp=a[a.length-j];
    			a[a.length-j]=a[index];
    			a[index]=temp;	
    		}

    实现从小到大(大的在最后)的排列顺序


    代码如下

    public static void main(String[] args) {
    		// TODO Auto-generated method stub		
    		int a[]=new int[]{7,8,6,5,9,3,1}; 
    		int temp;
    		
    		System.out.println("排序前的数组");
    		for(int i=0; i<a.length;i++){
    			System.out.print(a[i]+"\t");
    		}
    		for(int j=1;j<a.length;j++){   
    			int index=0;
    			for(int i=1;i<=a.length-j;i++){
    				if(a[i]>a[index]){
    					index=i;
    					/*
    					 * 交换下一个要比较的值,但不是交换两个值的内容
    					 * 比如a2与a1比较,现在换成a3与a2比较,而不是交换a2和a1的值				 
    					 */		
    			}							
    	}
    			/*
    			 * 不能放在第二个for里面,因为要到最后再交换位置
    			 */
    			temp=a[a.length-j];
    			a[a.length-j]=a[index];
    			a[index]=temp;	
    		}
    		
    		
    		System.out.println();
    		System.out.println("排序后的数组");
    		
    		for(int i=0;i<a.length;i++){
    			System.out.print(a[i]+"\t");
    
    		}			
    		}
    								
    }
    

    展开全文
  • 区别主要在交换方式上 ...但是 对于每一轮 比如第一轮 要把1~n 中最大那个放到n这个位置 冒泡法每次比较和移动相邻两项 而选择排序每次交换当前项和第n项 我把代码写出来你就懂了: 冒泡: for...
  • 冒泡排序 ...冒泡法按从小到大顺序排序步骤: 1、我们假设数组第一个值(a[0])为整个数组最小值。 2、比较第一个元素 (a[0])和第二个元素(a[1])大小,若a[0]<=a[1],则比较第二个 元素第...
  • 冒泡排序与选择排序

    2020-07-26 13:35:08
    冒泡排序选择排序比较相似,但又有所区别冒泡是相邻两个比较,将最小一步一步移到最左边,而选择排序是一眼先看过去哪个最小,将最小移到最左边。 举个例子,我们进入新班级,要进行排队做早操,我们...
  • 这可以用冒泡排序法与选择排序法,两者的区别并不算很大。 1.冒泡排序法: 算法描述:通过嵌套循环,比较两个数,再通过交换位置把两个数从不符合排列顺序变成符合排列顺序。 假定要从小到大排序: #通过两次循环来...
  • 选择排序

    2018-10-08 06:40:26
    与冒泡排序法区别:冒泡排序是比较相邻两个元素大小进行比较交换位置,一次循环,可能数组元素每个位置都发生改变,也可能是某个数组位置发生改变。而选择排序是从循环一边找出最大最小值。与第一个元素位置...
  • 【算法导论】选择排序

    千次阅读 2013-08-01 21:15:37
    选择排序其实是冒泡法的一种改进,其基本思路也是:先确定最小元素,再找次最小元素,最后确定最大元素。  它与冒泡排序的最大区别在于:冒泡排序是只要碰见比它大的元素就交换,而选择排序是直接将元素放在最终的...
  • 冒泡排序”和“选择排序”是每个程序初学者都会学到两个排序方法,但是好多人对这两个排序方法是既熟悉又陌生,熟悉是因为凡是遇到排序一般都会想到这两个方法,陌生是因为细细一想对这两个方法原理和区别...
  • Java数组选择排序

    2020-12-04 18:46:12
    选择排序是算法排序中比较常见的一种数组排序方法,上次说过的冒泡排序,冒泡排序的方式是通过定位交换从大到小进行逐个依次交换来排序,他跟选择排序是有一定的区别的。 首先我说一下选择排序的原理大概是:通过...
  • 【算法】选择排序

    万次阅读 多人点赞 2018-08-22 09:24:31
    一、介绍 ...3.选择排序与冒泡排序的区别选择排序每次遍历时会记住最大元素的位置,只进行一次交换,而冒泡排序每次遍历时会交换两个顺序不合法的元素 二、思想 1.将序列分为两段,有序前列[0,r...
  • 习题7-1 选择法排序 (20 分)

    千次阅读 2019-10-11 14:31:20
    选择法排序与冒泡排序法的区别 本题要求将给定的n个整数从大到小排序后输出。 输入格式: 输入第一行给出一个不超过10的正整数n。第二行给出n个整数,其间以空格分隔。 输出格式: 在一行中输出从大到小有序的...
  • 选择排序也是一种简单直观的排序算法 ...选择排序与冒泡排序的区别 冒泡排序通过依次交换相邻两个顺序不合法的元素位置,从而将当前最小(大)元素放到合适的位置;而选择排序每遍历一次都记住了当...
  • 注意选择排序与冒泡排序的区别:冒泡排序通过依次交换相邻两个顺序不合法的元素位置,从而将当前最小(大)元素放到合适的位置;而选择排序每遍历一次都记住了当前最小(大)元素的位置,最后仅需一次交换操作即可将...
  • 满意答案j65365612013.07.04采纳率:51%等级:11已帮助:8799人排序算法①:选择法选择法(按升序来说):将第一位和第二位比较,小者放在第一位,再将此时第一位第三位比较,仍然是小者放在第一位,如此重复,...
  • 就是指定一个位置,与其他数组元素分别对比,如果满足条件就交换两个数的值,它与冒泡排序最明显的区别就是它不是交换相邻元素的值 举个例子: 数组:12,3,4,7,11,22 1.先随便拿一个出来比如说12,我们要按照从...
  • 简单的选择排序与冒泡排序的区别是: 冒泡: 冒泡排序是从一排数据的第一个数开始和右面的一个数进行比较,左面 比右面大则交换位置,然后第二个数和第三个数进行比较,左面比右面大就交换位置,遍历一遍之后就把...
  • 选择排序

    2020-07-16 20:00:12
    选择排序与冒泡排序的区别 选择排序: public static void main(String[] args){ int[] a=new int[]{5,2,9,13,-7} //选择排序,就是把小的放在前面,每次循环只和第一个数交换 for(int i=0;i<a.length-1;i++...
  • 选择排序与冒泡排序类似,采用逐轮扫描最值然后将其置于顶端方式完成数组排序。区别是,冒泡法采取是依次比较相邻元素并不断交换逆序元素策略,逐步将最值向前推进;而选择排序法采取标记最值位置策略,扫描...
  • 选择排序与冒泡排序的区别就是:不需要像冒泡排序那样每次都交换元素.选择排序法的第一层循环从起始元素开始选到倒数第二个元素,主要是在每次进入的第二层循环之前,将外层循环的下标赋值给临时变量,接下来的第二层...
  • 归并排序快速排序

    2021-03-18 09:14:29
    最开始几章我们分别介绍了冒泡排序,插入排序,选择排序归并排序。在介绍散列技术时也介绍了桶排序,基数排序,计数排序。在讨论优先级队列时也介绍了堆排序,以及更为常用锦标赛排序。 归并排序和快速排序都...

空空如也

空空如也

1 2 3 4
收藏数 76
精华内容 30
关键字:

选择法与冒泡法的区别