冒泡排序和选择排序

package arithmetic;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class BubbleSort {
	public static void main(String args[]){
		//BubbleSort bubble=new BubbleSort();
		int [] arr=new int[] {12,123,1232,11,12,2,2};
		arr=bubbleSort(arr);
		//遍历数组的一种方法
		for(int i:arr){
			System.out.println(i);
		}
		/*
		 *
		 //list 转换成数组
		 List list = new ArrayList();
		 list.add("1");
		 list.add("2");
		 final int size =list.size();
		 String[] arr = (String[])list.toArray(new String[size]);
		 for(String i:arr){
			 System.out.println(i);
		 }
		*/
		
		/*数组转list
		List list=Arrays.asList(arr);
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		*/
	}
	
	
	//冒泡排序,最佳时间是O(n),时间复杂度是O(n*n),
	public static int[] bubbleSort(int[] list){
		boolean needNextPass=true;//下一次遍历是否执行的标识
		
		for(int k=1;k<list.length;k++){
			needNextPass=false;//如果没有交换，说明所有元素已经排好了，那么下一次遍历就不用执行
			for(int i=0;i<list.length-k;i++){
				if(list[i]>list[i+1]){
					int temp=list[i];
					list[i]=list[i+1];
					list[i+1]=temp;
										
					needNextPass=true;//下一次遍历仍然需要
					
				}
			}
		}
		return list;
	}
}

 

　　选择排序，就是从一堆数中选择一个最小的，然后增加到一个新的数组中，这个新的数组最开始是空的。那么可想而知，从一堆数中找到最小的数，成为这个算法的核心部分，这个有点像冒泡，但是又不是冒泡，冒泡是涉及到了很多交换，而选择只是用一个游标来标记最小数的下标，确定这个游标 所指的数值，然后和新数组的接下来的一个位置进行交换，这样就可以确定新数组中的每个数都比旧数组中的数要小。这种实现减少了频繁的交换操作。这样的话，不难看出，需要两个for循环，外层的for表示需要确定位置的个数，比如三个数进行选择排序，那么需要确定两个位置就行了，第三个就明显得出，第二个for是用来取出 旧数组最小的数。于是，很容易得到以下核心部分的代码：

package arithmetic;

import java.util.Arrays;

/*选择排序，就是从一堆数中选择一个最小的，然后增加到一个新的数组中，这个新的数组最开始是空的。那么可想而知，从一堆数中找到最小的数，
 * 成为这个算法的核心部分，这个有点像冒泡，但是又不是冒泡，冒泡是涉及到了很多交换，而选择只是用一个游标来标记最小数的下标，确定这个游标
 * 所指的数值，然后和新数组的接下来的一个位置进行交换，这样就可以确定新数组中的每个数都比旧数组中的数要小。这种实现减少了频繁的交换操作。这样的话，不难看出，需要两个
 * for循环，外层的for表示需要确定位置的个数，比如三个数进行选择排序，那么需要确定两个位置就行了，第三个就明显得出，第二个for是用来取出
 * 旧数组最小的数。于是，很容易得到以下核心部分的代码：
 */
public class ChooseSort {

	public static void main(String[] args){
		int [] arr=new int[] {12,123,1232,11,12,2,2};
		System.out.println("排序之前"+Arrays.toString(arr));
		sort(arr);
		System.out.println("排序之后"+Arrays.toString(arr));
		
	}
	public static void sort(int[] arr){
		for(int i=0;i<arr.length;i++){
			int minIndex=i;//设置一个游标，这个游标来指示最小数

			for(int k=i+1;k<arr.length;k++){
				//和最小数进行比较，不断更新，最终获得旧数组中的最小数,用游标记下最小数的下表
				if(arr[minIndex]>arr[k]){
					minIndex=k;
				}
			}
		//将最小数和新数组中接下来的一个位置的数进行交换
			if(minIndex!=i){
				int temp=arr[i];
				arr[i]=arr[minIndex];
				arr[minIndex]=temp;
			}
		}
	}
}

　　但是，选择排序是不稳定，为什么不稳定呢？比如利用选择排序来排列下面的一组数：3,2,5,3,1，很容易知道，第一次的过后，第一个3会和1交换，那么这样，第一个3和第二3的位置就变换了，后来也不会再变回来了，所以，对于两个相等的数，在排序中前后位置如果在排序过后会改变，那么这种排序就是不稳定的。