选择和冒泡排序

  1 #include <stdio.h>
  2
  3 int main()
  4 {
  5         int arr[5] = {4, 7, 9, 2, 6};
  6         int brr[5] = {7, 8, 4, 2, 1};
  7 /*冒泡排序*/
  8         int i, j, tmp=0, swap=0;
  9
 10         for(i=0; i<5; i++)
 11                 for(j=0; j<4-i; j++){
 12                         if(arr[j] < arr[j+1]){
 13                                 tmp = arr[j];
 14                                 arr[j] = arr[j+1];
 15                                 arr[j+1] = tmp;
 16                         }
 17                 }
 18 /* 选择排序 */
 19         for(i=0; i<5; i++)
 20                 printf("%d \n", arr[i]);
 21
 22         for(i=0; i<5; i++){
 23                 tmp = i;
 24                 for(j=i; j<5; j++){
 25                         if(brr[tmp] < brr[j])
 26                                 tmp = j;
 27                 }
 28                 swap = brr[i];
 29                 brr[i] = brr[tmp];
 30                 brr[tmp] = swap;
 31         }
 32         for(i=0; i<5; i++)
 33                 printf("%d \n", brr[i]);
 34 }
  1. 冒泡排序(大到小):比如有五个数,将第一个与第二个比较,再将第二个与第三个比较。。如果后者比前者大值是要交换的,自然得到最后一个最小,请注意 j+1是已经比较到最后一个的,把i=0带进去一试就知道;每一论都是从最前面开始比较的,把最小的推到最后,得到最小值后下一轮将不再比较。
  2. 选择排序(大到小):每一次把最大的值放到最前面,tmp用来存放最大值的下标,最后再与当前下标i的值交换,下一次从又下一个数开始,恰好与上面的冒泡不同,冒泡是将得到的值放到最后了。
时间: 2024-10-18 05:06:44

选择和冒泡排序的相关文章

01. Java的经典排序--选择排序--冒泡排序--折半查找(二分查找)

Java的经典排序--选择排序--冒泡排序--折半查找 选择排序 选择排序 3 2 1 5 8 0 1 3 2 5 8 1 1 2 3 5 8 2 1 2 3 5 8 3 1 2 3 5 8 public static void main(String[] args) { int[] arr={3,2,1,5,8}; selectSort(arr); for(int i = 0 ; i < arr.length ; i ++){ System.out.println(arr[i]) ; } }

选择、冒泡排序,二分查找法以及一些for循环的灵活运用

import java.util.Arrays;//冒泡排序 public class Test { public static void main(String[] args) { int[] array = { 31, 22, 15, 77, 52, 32, 18, 25, 16, 7 }; // 冒泡 --> 两两比较 --> 提取出最大的数 在最后一位 //拿第一位和它后面的一位进行 两两比较 System.out.println(Arrays.toString(array)); fo

简单分析选择排序,冒泡排序

1,选择排序的原理  1.1 选择排序就是会依次利用每一位索引上的值,与它后面的所有值进行比较,而且在每经过一轮比较,最值就会出现在最前面 2,冒泡排序的原理  2.1 冒泡排序的原理就是两个相邻的元素进行比较,每比较一轮,最值就会出现在最后面 #include <stdio.h>void getLow(int count[],int length);void countNumber(int count1[],int length);void getLarge(int count[],int

Java——选择、冒泡排序、折半查找

1 //选择排序对数据进行升序排序 2 public static void selectSortArray(int[] arr){ 3 for(int i = 0; i<arr.length-1;i++){ 4 for(int j = i+1;j<arr.length;j++){ 5 if(arr[i]>arr[j]){ 6 int temp = arr[j]; 7 arr[j] = arr[i]; 8 arr[i] = temp; 9 } 10 } 11 } 12 } 13 //冒泡

选择排序&amp;冒泡排序&amp;折半查找

//选择排序 void test2(int a[],int len){ //每次找出一个最小值,最小值依次与原数组交换位置,通过下标来完成交换,最小值下标每次都在变,变量存储 //    假如第一个是最小值 int mine=0; int teamp=0; //    外层负责趟数 for (int i=0; i<len; i++) { //    假如每一次的第一个是最小值 mine=i; //    内层负责寻找每趟的最小值 //        每次起始比较值都不一样所以j=i+1,改变次数

选择排序 冒泡排序 简单插入排序

排序: public class SortDemo { public static void main(String[] args) { int[] arr = { 5, 8, 9, 12, 55, 565, 421, 12, 2512, -5, -56 }; // int[] arr = { 6, 9, 4589, 442, 458, 5232, -788, 7, 545, -44, 55, -11 // }; // selectionSort(arr); // bubbleSort(arr)

Java习题(选择,冒泡排序,折半查找)

解决问题如下: 1.求1+2!+3!+...+20!的和. 2.获取数组中的最大和最小值. 3.对数组进行选择排序.冒泡排序. 4.在数组中查找某个数的位置(折半查找). 折半查找:      适合顺序表的查找,数组中存的是按顺序排列的元素,方法如下:定义变量low,mid,high分别指向数组中的最低位,中间和最高位的元素:比较要查找的元素和mid指向的元素,如果比mid大,则在mid和high之间继续查找,low=mid+1; 否则在low和mid之间继续查找,high=mid-1.直到lo

二分算法,选择,冒泡排序算法

package com.zlhj.logic.doc; import java.util.Arrays; /** * 类的作用: * * @ClassName : Tser * @Author : liyang * @Date : 2019/1/19 17:00 * @Version 1.0 *//* * 冒泡排序 */public class Tser { public static void main(String[] args) { int[] arr = {5, 4, 7, 78, 12

选择排序 冒泡排序 插入排序

1.选择排序 每一次找出最小的值,放在最前面的位置,一个一个安置 //选择排序 #include<iostream> #include<climits> using namespace std; template<class T> void gcd(T a[],int n){ int mix,temp; for(int i=0;i<n-1;i++){ mix=i; for(int j=i+1;j<n;j++) if(a[j]<a[mix]) mix=j