选择排序与冒泡排序（c语言+Java语言）

选择排序 O（n²）

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

例、/*选择排序(从小到大排列)  O(n)
 1  5  8  7  2  4  9  3  0  6
*0  5  8  7  2  4  9  3 *1  6
 0 *2  8 *7  5  4  9  3  1  6
 0 *1  8  7  5  4  9  3 *2  6
 0  1 *7  8 *5  4  9  3  2  6
 0  1 *5  8  7 *4  9  3  2  6
 0  1 *4  8  7 *5  9  3  2  6
 0  1 *3  8  7  5  9 *4  2  6
 0  1 *2  8  7  5  9  4 *3  6
  以此类推………………
 */

C语言代码演示

#include<stdio.h>
main() {
	int arr[10] = {1, 5, 8, 7, 2, 4, 9, 3, 0, 6};
	for (int i = 0; i < 9; i++) {
		for (int j = i + 1; j < 10; j++) {
			if (arr[i] > arr[j]) {
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
	//输出结果
	for (int i = 0; i < 10; i++) {
		printf("%d ", arr[i]);
	}
}

*c语言通用代码

#include<stdio.h>
main() {
	int arr[N] = {};
	for (int i = 0; i < N-1; i++) {
		for (int j = i + 1; j < N; j++) {
			if (arr[i] > arr[j]) {
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
	//输出结果
	for (int i = 0; i < N; i++) {
		printf("%d ", arr[i]);
	}
}

Java代码演示//运行时间2600纳秒

public class SelectionSort {
    public static void main(String[] args) {
        int []arr={1, 5, 8, 7, 2, 4, 9, 3, 0, 6};
        selectionSort(arr);//调用选择排序的函数
        for(int i=0;i< arr.length;i++)
            System.out.print(arr[i]+" ");
    }
    public static void selectionSort(int []arr){
        long startTime = System.nanoTime();//开始时间
        for (int i = 0; i < arr.length-1; i++) {
            int min=i;//记录最小值下标
            for (int j=i+1;j< arr.length;j++){
                if(arr[j]<arr[min])
                    min=j;// 遍历 i+1~length 的值，找到其中最小值的位置
            }
            if(i!=min){// 交换当前索引 i 和最小值索引 min 两处的值
                int temp=arr[i];
                arr[i]=arr[min];
                arr[min]=temp;
            }
        }
        long overTime = System.nanoTime();//结束时间
        System.out.println("程序运行时间为："+(overTime-startTime)+"纳秒");
    }
}

冒泡排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

例、/* 冒泡排序（从小到大排列）
  每一次遍历都把最大的排在最后
1  5  8  7  2  4  9  3  0  6                                 
1  5
   5  8
      7  8
         2  8
            4  8
               8  9
                  3  9
                     0  9
                        6  9
 *1  5  7  2  4  8  3  0  6  9  第一次遍历
  1  5  
     5  7 
        2  7 
           4  7
              7  8
                 3  8
                    0  8
                       6  8
                          8  9
 *1  5  2  4  7  3  0  6  8  9   第二次遍历
  1  5
     2  5
        4  5
           5  7
              3  7
                 0  7
                    6  7
                       7  8
                          8  9
 *1  2  4  5  3  0  6  7  8  9   第三次遍历
  1  2 
     2  4 
        4  5
           3  5
              0  5  
                 5  6
                    6  7
                       7  8
                          8  9
 *1  2  4  3  0  5  6  7  8  9   第四次遍历
以此类推……………… 
*/

C语言的代码演示

#include<stdio.h>
main(){
	int arr[10]={1,5,8,7,2,4,9,3,0,6};
	//外层循环表明要排多少次，内层循环表示比较的两个数
	for(int i=0;i<9;i++){
		//当有n个数时，外层循环需要排n-1次
		for(int j=0;j<(10-1)-i;j++){
			//(10-1)表示下标，-i表示最大的元素外层循环后，内层循环就不需要比较了
			//可以这样理解 j＋1不能越界 即j＋1＜10   所以是j＜10-1
			if(arr[j]>arr[j+1]){
				int temp=arr[j+1];
				arr[j+1]=arr[j];
				arr[j]=temp;
			}
		}
	}
	//输出结果
	for(int i=0;i<10;i++){
		printf("%d ",arr[i]);
	}
}

C语言通用代码

#include<stdio.h>
main(){
	int arr[N]={};
	//外层循环表明要排多少次，内层循环表示比较的两个数
	for(int i=0;i<N-1;i++){
		//当有n个数时，外层循环需要排n-1次
		for(int j=0;j<(N-1)-i;j++){
			//(10-1)表示下标，-i表示最大的元素外层循环后，内层循环就不需要比较了
			//可以这样理解 j＋1不能越界 即j＋1＜10   所以是j＜10-1
			if(arr[j]>arr[j+1]){
				int temp=arr[j+1];
				arr[j+1]=arr[j];
				arr[j]=temp;
			}
		}
	}
	//输出结果
	for(int i=0;i<N;i++){
		printf("%d ",arr[i]);
	}
}

Java语言演示//运行时间3100纳秒

public class Bubble_Sort {
    public static void main(String[] args) {
        int[] arr = {1, 5, 8, 7, 2, 4, 9, 3, 0, 6};
        BubbleSort(arr);
        for (int i=0;i< arr.length;i++)
            System.out.print(arr[i]+" ");
    }
    public static void BubbleSort(int arr[]){
        long startTime = System.nanoTime();//开始时间
        for (int i=0;i< arr.length-1;i++){
            for (int j=0;j< arr.length-1-i;j++){
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        long overTime = System.nanoTime();//结束时间
        System.out.println("程序运行时间为："+(overTime-startTime)+"纳秒");
    }
}