2017.12.9 Java中的排序---冒泡排序、快速排序、选择排序

//冒泡排序

public class demo{
	public static void main(String[] args) {
		int[] sum={2,9,10,1,5,88};
		System.out.println("==============排序前==========");
		for(int i=0;i<6;i++){
			System.out.print(sum[i]+"	");
		}
		for(int j=1;j<=sum.length-1;j++){ //外层循环轮数
			for(int k=0;k<sum.length-j-1;k++){  //内层循环次数
				if(sum[k]>sum[k+1]){//交换值
					int temp=sum[k];
					sum[k]=sum[k+1];
					sum[k+1]=temp;
				}
			}	
		}
		System.out.println();
		System.out.println("=======排序后=======");
			for(int a=0;a<sum.length;a++){
				System.out.print(sum[a]+"	");
		}
	}
}

//选择排序算法，比冒泡排序简单

public class demo{
public static void main(String[] args){
int[] arr={57,68,59,89,45,52}; //定义一个整型arr数组
for(int i=0;i<arr.length-1;i++){//外层循环,循环次数就是数组的个数减1
int k=i;//标注第一个为最小值并取下标
for(int j=arr.length-1;j>i;j--){ //内层循环，取数组最后一个数
if(arr[j]<arr[k]){
k=j;
}
}

		int temp = arr[i];//交换两个数字
		arr[i]=arr[k];
		arr[k]=temp;
	}
	for(int i=0;i<arr.length;i++){ //遍历输出整个数组
		System.out.print(arr[i]+"	");
	}
}

}

//快速排序

快排原理

在要排的数（比如数组A）中选择一个中心值key（比如A[0]），通过一趟排序将数组A分成两部分，其中以key为中心，key右边都比key大，key左边的都key小，然后对这两部分分别重复这个过程，直到整个有序。
        整个快排的过程就简化为了一趟排序的过程，然后递归调用就行了。

一趟排序的方法：

1，定义i=0，j=A.lenght-1，i为第一个数的下标，j为最后一个数下标
2，从数组的最后一个数Aj从右往左找，找到第一小于key的数，记为Aj；
3，从数组的第一个数Ai 从左往右找，找到第一个大于key的数，记为Ai；
4，交换Ai 和Aj 
5，重复这个过程，直到 i=j
6，调整key的位置，把A[i] 和key交换
假设要排的数组为：A[8] ={ 5 2 8 9 2 3 4 9 }
           选择 key = 5， 开始时 i=0，j=7
  index       0    1    2    3    4    5    6    7

package com.glut.demo;

import java.util.Arrays;
/**
 * 快速排序
 * @author qichunlin
 *
 */
public class Test{
	public static void main(String[] args) {
		int[] a = {1, 2, 4, 5, 7, 4, 5 ,3 ,9 ,0};
		System.out.println(Arrays.toString(a));  
        quickSort(a);  
        System.out.println(Arrays.toString(a));  

	}
	
	public static void quickSort(int[] a) {  
        if(a.length>0) {  
            quickSort(a, 0 , a.length-1);  
        }  
    }

	private static void quickSort(int[] a, int low, int high) {
		// TODO Auto-generated method stub
		//找到递归算法的出口
		if(low>high) {
			return;
		}
		
		//2.存
		int i = low;
		int j = high;
		
		//3.key
		int key = a[low];
		//4.完成一趟排序
		while(i<j) {
			//4.1 ，从右往左找到第一个小于key的数  
            while(i<j && a[j] > key){  
                j--;  
            } 
            // 4.2 从左往右找到第一个大于key的数  
            while( i<j && a[i] <= key) {  
                i++;  
            }
            
          //4.3 交换  
            if(i<j) {  
                int p = a[i];  
                a[i] = a[j];  
                a[j] = p;  
            }
            
		}
		
		//4.4 调整key的位置
		int p = a[i];
		a[i] = a[low];
		a[low] = p;
		
		//5.对key左边的数快排
		quickSort(a, low, i-1);
		
		//6.对key有边的数快排
		quickSort(a, i+1, high);
		
	} 
	
}