三种排序(冒泡,插入,选择)-- java实现和时间复杂度分析

文章目录

    • 算法实现
      • 选择算法
      • 插入算法
      • 冒泡算法
    • 算法分析
      • 冒泡算法
      • 插入算法
      • 选择算法
    • 结论

算法实现

选择算法

  1. 遍历,找到最大值,最大值跟边边的值交换
  2. 遍历剩下的值,找到最大值,最大值跟边边的值交换
  3. 直至没东西遍历
package cn.edut.test_sort;

/**
 * 选择算法
 * 1.遍历,找到最大值,最大值跟边边的值交换
 * 2.遍历剩下的值,找到最大值,最大值跟边边的值交换
 * ...
 * 3.直至没东西遍历
 */
public class SelectingSort {
	public static void main(String[] args) {
		int a[]=new int[]
				{
						3,21,12,5,5,47,564,64,13,48,12,3,4,5,3,87,54,98
						};
		for(int i=0 ; i<a.length ; i++) {
			int maxIndex = i ;
			for(int x=i+1 ; x<a.length ; x++ ) {
				if(a[maxIndex]<a[x]) {
					maxIndex = x; 
				}
			}
			int temp = a[i] ; 
			a[i] = a[maxIndex] ;
			a[maxIndex] = temp;
		}
		
		for(int i=0 ; i<a.length ; i++) {
			System.out.print(a[i]+",");
		}
	}
}

插入算法

  1. 假设前第一位排好序
  2. 从第二位开始跟前一位对比,插入到正确的位置
  3. 从第三位开始跟前两位对比,插入到正确位置
  4. 从最后一位开始跟前面对比,插入到正确位置。。
package cn.edut.test_sort;

/**
 * 插入排序
 * 1.假设前第一位排好序
 * 2.从第二位开始跟前一位对比,插入到正确的位置
 * 3.从第三位开始跟前两位对比,插入到正确位置
 * ...
 * 4.从最后一位开始跟前面对比,插入到正确位置。。
 * @author Administrator
 *
 */
public class InsertingSort {
	public static void main(String[] args) {
		int b[] = new int[]
				{
						2, 6, 45, 54, 6, 8, 9, 12, 45, 6546, 13, 134, 13, 156, 48, 2
						};
		
		for(int i=1 ; i<b.length ; i++) {
			for(int index=0; index<i; index++ ) {
				if(b[index]<b[i]) {
					int temp = b[i] ;
					b[i] = b[index];
					b[index] = temp;
				}
			}
		}
		
		for(int i=0 ;i<b.length ;i++) {
			System.out.print(b[i]+",");
		}
	}
}

冒泡算法

  1. 从左边第一位开始,向右比较

  2. 发现右边大的,左右调换

  3. 遍历n次后,左边为最大的

  4. 从左边第二位开始,向右比较

  5. 发现右边大的,左右调换

  6. 遍历n-1次后,左边为最大的

  7. 从左边第倒数二位开始,向右比较

  8. 发现右边大的,左右调换

  9. 遍历1次后,左边为最大的

package cn.edut.test_sort;


/**
 * 冒泡算法
 * 1.从左边第一位开始,向右比较
 * 2.发现右边大的,左右调换
 * 3.遍历n次后,左边为最大的
 * 
 * 1.从左边第二位开始,向右比较
 * 2.发现右边大的,左右调换
 * 3.遍历n-1次后,左边为最大的
 * ...
 * 
 * 
 * 
 * 1.从左边第倒数二位开始,向右比较
 * 2.发现右边大的,左右调换
 * 3.遍历1次后,左边为最大的
 * @author Administrator
 *
 */
public class BubblingSort {
	public static void main(String[] args) {
		 int a[] = new int[]
				 {
				 2, 6, 45, 54, 6, 8, 9, 12, 45, 6546, 13, 134, 13, 156, 48, 2
				 };
		 for(int i=0 ; i<a.length-1 ; i++) {
			 for(int x=i+1; x<a.length ; x++) {
				 if(a[i] -a[x]<0) {
					 int temp = a[i] ; 
					 a[i] = a[x] ; 
					 a[x] = temp;
				 }
			 }
		 }
		 for(int i=0 ; i<a.length ; i++) {
			 System.out.print(a[i]+",");
		 }
	}
}

算法分析

冒泡算法

先给出结论,冒泡算法的算法复杂度O(N2)
看代码,分析复杂度怎么得出来的

		 for(int i=0 ; i<a.length-1 ; i++) { //循环n-1次
			 for(int x=i+1; x<a.length ; x++) { //第一次循环n-1次,第二次循环n-2次。。。第n-1次循环1次
			
				 if(a[i] -a[x]<0) {
					 int temp = a[i] ; 
					 a[i] = a[x] ; 
					 a[x] = temp;
				 }
			 }
		 }

因此,总共循环了 1 + 2 + 3 + . . . + ( n − 1 ) = ( n − 1 + 1 ) ∗ ( n − 1 ) / 2 1+ 2+3+...+(n-1)=(n-1+1)*(n-1)/2 1+2+3+...+(n1)=(n1+1)(n1)/2次。
O((n2-n)/2) = O(n2)
由此得出,冒泡算法的算法复杂度O(N2)。

插入算法

由下面分析可知,插入算法的复杂度也是O(N^2)。

for(int i=1 ; i<b.length ; i++) { //循环n-1次
			for(int index=0; index<i; index++ ) {
			//子循环次数分别为:1、2、3、...、n-1
				if(b[index]<b[i]) {
					int temp = b[i] ;
					b[i] = b[index];
					b[index] = temp;
				}
			}
		}

【看很多人说这是时间复杂度,还有一个空间复杂度。。emmm 好像好有道理,不过没学到那,就先这样】

选择算法

选择排序的时间复杂度仍然为O(N2)

for(int i=0 ; i<a.length ; i++) { // 循环n次
			int maxIndex = i ;
			for(int x=i+1 ; x<a.length ; x++ ) { 
			//分别循环 n-1、 n-2 、... 、1、 0次
				if(a[maxIndex]<a[x]) {
					maxIndex = x; 
				}
			}
			int temp = a[i] ; 
			a[i] = a[maxIndex] ;
			a[maxIndex] = temp;
		}
		

结论

三种算法的时间复杂度一样?

你可能感兴趣的:(三种排序(冒泡,插入,选择)-- java实现和时间复杂度分析)