冒泡和快速排序

package com.demo.ds.sort;
/**
 * 优化1：每趟循环不需要比较到最后，比较完无序队列即可
 *     j<arr.length-1-i
 * 
 * 优化2：如果已经优先，不需要进行后续趟的循环，提高效率
 *        至多需要n-1趟循环，至少1趟
 *    判断是否已经有序，需要一趟循环。如果一趟循环没有发生交换，就是已经有序
 * @author Administrator
 *
 */
public class TestBubble {

    public static void main(String[] args) {
        //定义一个无序数组
        int [] scoreArr = {75,87,56,45,89,100,76,34,89,97};
        //int [] scoreArr = {10,20,30,80,40,50,60};
        
        //排序前输出
        System.out.println("排序前");
        for(int score :scoreArr){
            System.out.print(score+"\t");
        }
        //排序
        bubbleSort(scoreArr);
        
        //排序后输出
        System.out.println("\n排序后");
        for(int score :scoreArr){
            System.out.print(score+"\t");
        }
    }
    public static void bubbleSort(int[] arr) {
        //外循环：n个数，最多循环n-1趟
        for(int i=0;i<arr.length-1;i++){
            //System.out.println(i);
            //定义符号量flag，表示是否发生过交换
            boolean flag = false;//没有交换
            //小循环:
            for(int j=0;j<arr.length-1-i;j++){
                //如果前一个大于后一个，交换
                if(arr[j] > arr[j+1]){                    
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    
                    flag =  true;//发生了交换
                }
            }
            //判断是否有序
            if(!flag){
                break;
            }
            
        }        
    }
    public static void bubbleSort2(int[] arr) {
        //外循环：n个数，最多循环n-1趟
        for(int i=0;i<arr.length-1;i++){
            //小循环
            for(int j=0;j<arr.length-1;j++){
                //如果前一个大于后一个，交换
                if(arr[j] > arr[j+1]){
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }        
    }

}

package com.demo.ds.sort;

import java.util.Arrays;

public class TestQuickSort {
	
	private static int partition(int[] arr, int low, int high) {
		//定义两个指针i，j，分别指向开始元素和结束元素
		int i = low;
		int j = high;
		//挖坑，将第一个元素作为基准值
		int x = arr[i];
		
		//通过循环完成分区操作
		while(i<j){
			//1.右指针j向左移动，找到小于基准值的元素
			while(i<j && arr[j]>=x ){
				j--;
			}
			//2.使用右边元素填左边的坑，右边生成坑
			if(i<j){
				arr[i] = arr[j];
				i++;
			}
			//3.左指针i向右移动，找打大于基准值的元素
			while(i<j && arr[i] < x){
				i++;
			}
			//4.使用左边元素填右边的坑，左边生成坑
			if(i<j){
				arr[j] = arr[i];
				j--;
			}
		}		
		//将基准元素放入i=j的坑中
		arr[i] = x;
		//arr[j] = x;
		
		//返回分区界限的索引
		return i;//return j;
	}
	
	private static void quickSort(int[] arr, int low, int high) {
		if(low < high){
			//对数组进行分区，分为前后两个分区，返回分区的界限
			int n = partition(arr,low,high);
			//对左分区进行快速排序
			quickSort(arr,low,n-1);
			//对右分区进行快速排序
			quickSort(arr,n+1,high);
		}		
	}
	
	

	public static void quickSort(int[] arr) {
		int low = 0;
		int high = arr.length-1;
		quickSort(arr,low,high);
		
	}
	public static void main(String[] args) {
		//指定一个无序数列
		int arr[] = {72,6,57,60,88,60,42,83,73,88,48,85};

		//输出无序数列
		System.out.println(Arrays.toString(arr));
		//快速排序
		quickSort(arr);
		//partition(arr,0,arr.length-1);
		//输出有序数列
		System.out.println(Arrays.toString(arr));
	}

	
}