Java选择排序和冒泡排序示例

package cc.test;
/**
 * Demo描述:
 * 选择排序和冒泡排序
 */
public class TestSort {

	public static void main(String[] args) {
           TestSort testSort=new TestSort();
           int intArray []=new int []{11,3,-2,4,8,7};
           testSort.selectSort(intArray);
           testSort.bubbleSort(intArray);
	}

	//选择排序
	//取出第一个元素依次与其后的每个元素比较,若大于则交换位置
	//在第一次排序完成后第一个元素存放的就是数组中的最小值
	//继续第二次排序,依次类推.....
	//但已经排过序的元素不需要再次参加排序
	//即代码:int j = i+1
	public void selectSort(int [] intArray){
		int temp;
		for (int i = 0; i < intArray.length; i++) {
			for (int j = i+1; j < intArray.length; j++) {
				if (intArray[i]>intArray[j]) {
					temp=intArray[j];
					intArray[j]=intArray[i];
					intArray[i]=temp;
				}
			}
		}

		System.out.println("选择排序结果如下:");
		for (int i = 0; i < intArray.length; i++) {
			System.out.print(intArray[i]+" ");
		}
		System.out.println("");
	}

	//冒泡排序
	//两个相邻的元素比较,一轮后一个最大值排在了数组最后面
	//继续上面操作,只是在上一轮中已排出的最大元素不再参加排序
	//备注说明:
	//1 外层for循环控制的是比较的轮数.
	//  注意:轮数总比数组长度小1.因为最后一轮就剩下一个元素没有排序的必要了
	//  因为此时第一个元素已经是最小值
    //  即代码:i < intArray.length-1
	//2 内存for循环控制每一轮的比较
	//  注意:要防止下标越界而且在以往轮中已经排序出来的值就不要再次参加排序
	//  即代码:j < intArray.length-1-i
	public void bubbleSort(int[] intArray) {
		int temp;
		for (int i = 0; i < intArray.length-1; i++) {
			for (int j = 0; j < intArray.length-1-i;j++) {
				if (intArray[j] > intArray[j + 1]) {
					temp = intArray[j + 1];
					intArray[j + 1] = intArray[j];
					intArray[j] = temp;
				}
			}
		}
		System.out.println("冒泡排序结果如下:");
		for (int i = 0; i < intArray.length; i++) {
			System.out.print(intArray[i]+" ");
		}
	}

}
时间: 2024-10-02 12:02:51

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

选择排序与冒泡排序

/// <summary> /// 选择排序 /// </summary> /// <param name="arr"></param> static void Sort1(int[] arr) { int len = arr.Length; for (var i = 0; i < arr.Length; i++) { int min = i; for (var n = i + 1; n < arr.Length; n++)

C语言实现选择排序、冒泡排序和快速排序的代码示例_C 语言

选择和冒泡 #include<stdio.h> void maopao(int a[],int len){ int i,j,temp; for(i = 0;i < len - 1 ; i ++){//从第一个到倒数第二个 for (j = 0 ; j < len - 1 - i ; j ++)//排在后的是已经排序的 { if (a[j] > a[j + 1])//大的数换到后面去 { temp = a[j]; a[j] = a[j + 1]; a [j + 1] = tem

Python选择排序、冒泡排序、合并排序代码实例_python

前两天刚装了python 3.1.1, 禁不住技痒写点code.1.选择排序 复制代码 代码如下: >>> def SelSort(L):     length=len(L)     for i in range(length-1):         minIdx=i         minVal=L[i]         j=i+1         while j<length:             if minVal>L[j]:                 min

VC++实现选择排序算法简单示例_C 语言

本文以一个非常简单的实例说明VC++选择排序算法的实现方法,对n个记录进行n-1趟简单选择排序,在无序区中选取最小记录. 具体实现代码如下: #include<iostream> using namespace std; //简单选择排序 void SelectSort(int r[ ], int n) { int i; int j; int index; int temp; for (i=0; i<n-1; i++) //对n个记录进行n-1趟简单选择排序 { index=i; for

Java实现的各种排序算法(插入排序、选择排序算法、冒泡排序算法)_java

一.插入排序算法实现java版本 public static int[] insert_sort(int[] a) { for (int i = 0; i < a.length; i++) { for(int j=i+1;j>0&&j<a.length;j--) { if(a[j]<a[j-1]) { int tmp = a[j]; //这样定义初始化逻辑上是可以的,j变量,每次tmp的值变化的 a[j] = a[j-1]; a[j-1] = tmp; } } }

JAVA简单选择排序算法原理及实现_java

简单选择排序:(选出最小值,放在第一位,然后第一位向后推移,如此循环)第一位与后面每一个逐个比较,每次都使最小的置顶,第一位向后推进(即刚选定的第一位是最小值,不再参与比较,比较次数减1) 复杂度: 所需进行记录移动的操作次数较少 0--3(n-1) ,无论记录的初始排列如何,所需的关键字间的比较次数相同,均为n(n-1)/2,总的时间复杂度为O(n2):空间复杂度 O(1) 算法改进:每次对比,都是为了将最小的值放到第一位,所以可以一比到底,找出最小值,直接放到第一位,省去无意义的调换移动操作

JavaScript 冒泡排序和选择排序的实现代码_javascript技巧

废话不多说了,直接给大家贴代码了,具体代码如下所述: var array = [1,2,3,4,5]; // ---> 服务 //效率 ---> 针对一个有序的数组 效率最高 //标志 true false for(var j = 0; j < array.length - 1;j++ ){ //- j 每次排序完成之后 后面减少比较的次数 var isTrue = true; //如果数组本身就是升序,则直接输出 for(var i = 0; i < array.length -

java实现选择排序算法_java

java实现选择排序算法 public static void selectSort(int[] array) { for (int i = 0; i < array.length - 1; i++) { int min = i; for (int j = i + 1; j < array.length; j++) { if (array[j] < array[min]) { min = j; } } Sort.swap(array, i, min);//交换i和min } } 选择排序

JAVA数组之选择排序算法

注意选择排序和冒泡排序的异同点: 它们两者比较的次数一样,O[N^2]的时间. 但选择排序的交换次数要比冒泡少.我想是因为它在每次循环之前,就设计了一个锚点.(如下面的MIN),这样就避免了已排序好的元素再交换.其适用于排序量少而交换多. public void insert(long value) { int j; int i; long temp; long min; a[nElems] = value; nElems++; for(j = 0; j < nElems; j++){ min