排序算法

冒泡排序

package zll.material.sort_method;

import java.util.Arrays;
import org.junit.Test;


public class BubbleSort {
	/**
	 * 冒泡排序（Bubble sort）
	 * 1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
	 * 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
	 * 3.针对所有的元素重复以上的步骤，除了最后一个。
	 * 4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
	 */
	@Test
	public void test01(){
		int[] ints = {3,6,5,9,8,4,1,7,0};
		for(int i=0;i<ints.length-1;i++){
			for(int j=0;j<ints.length-1-i;j++){
				if(ints[j]>ints[j+1]){
					int tmp = ints[j];
					ints[j] = ints[j+1];
					ints[j+1] = tmp;
				}
			}
		}
		System.out.println(Arrays.toString(ints));
	}
}

 

快速排序

 

package zll.material.sort_method;

import java.util.Arrays;

import org.junit.Test;

public class FastSort {
	/** 
     * 快速排序（Fast sort） 
     * 快速排序的原理：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。 
     *  
     * 一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有继续比较下一个，直到找到第一个比基准值小的值才交换。 
     * 找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。直到从前 
     * 往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值来说，左右两边就是有序的了。 
     *  
     * 接着分别比较左右两边的序列，重复上述的循环。 
     * @param a 
     * @param low 
     * @param high 
     */  
    public void fastSort(int[] a,int low,int high){  
        int start = low;  
        int end = high;  
        int key =a[low];  
        while(end>start){  
            //从前往后排序  
            while(end>start&&a[end]>key)  
                end--;  
            if(a[end]<key){  
                int tmp = a[end];  
                a[end] = key;  
                key = tmp;  
            }  
            //从后往前排序  
            while(end>start&&a[start]<key)  
                start++;  
            if(a[start]>key){  
                int tmp = a[start];  
                a[start] = key;  
                key = tmp;  
            }  
        }  
        if(start>low)fastSort(a, low, start-1);  
        if(end<high)fastSort(a, end+1, high);  
    }  
    /** 
     * 快速排序（Fast sort）测试 
     */  
    @Test  
    public void test02(){  
        int[] ints = {3,6,9,5,8,4,1,7,0};  
        fastSort(ints, 0, ints.length-1);  
        System.out.println(Arrays.toString(ints));  
    }  
}

public class test4 {
    public static void main(String[] args) {
        int [] arrs = {9,5,8,7,0,4,6,2,20,47,76,9,4};
        fastSort(arrs);
        System.out.println(Arrays.toString(arrs));
    }
    public static void fastSort(int[] arrs){
        QuickSort(arrs,0,arrs.length-1);
    }
    public static void QuickSort(int[] arrs,int start,int end){
        if(start<end){
            int index = getIndex(arrs,start,end);
            QuickSort(arrs,0,index-1);
            QuickSort(arrs,index+1,end);
        }
    }
    public static int getIndex(int[] arrs,int start,int end){
        int i=start;
        int j=end;
        int x=arrs[start];
        while (j>i){
            //先从右向左比，找比x小的
            while (j>i&&arrs[j]>x)j--;
            if(j>i){
                //把找到的元素放到第一个坑位
                arrs[i]=arrs[j];
                i++;
            }
            //从左向右比，找比x大的
            while (j>i&&arrs[i]<x)i++;
            if(j>i){
                arrs[j]=arrs[i];
                j--;
            }
        }
        arrs[i]=x;
        return i;
    }
}

归并排序

 

package zll.material.sort_method;

import java.util.Arrays;

import org.junit.Test;

public class MergeSort {
	/**
	 * 归并排序
	 */
	@Test
	public void test01(){
		int[] ints = {3,6,9,5,8,4,1,7,0}; 
		int[] results = mergeSort(ints);
		System.out.println(Arrays.toString(results));
	}

	private int[] mergeSort(int[] ints) {
		int[] tmp = new int[ints.length];
		mergeSort(ints,tmp,0,ints.length-1);
		return tmp;
	}

	private void mergeSort(int[] ints, int[] tmp, int left, int right) {
		int[] t = new int[right+1];
		if(left==right){
			tmp[left] = ints[left];
		}else{
			int mid = (left+right)/2;
			mergeSort(ints, t, left, mid);
			mergeSort(ints, t, mid+1, right);
			merge(t,tmp,left,mid,right);
		}
	}

	private void merge(int[] ints, int[] tmp, int left, int mid, int right) {
		int begin1 = left;
		int end1 = mid;
		int begin2 = mid+1;
		int end2 = right;
		int index = left;
		while (begin1<=end1&&begin2<=end2) {
			if(ints[begin1]<ints[begin2]){
				tmp[index]=ints[begin1];
				begin1++;
			}else {
				tmp[index]=ints[begin2];
				begin2++;
			}
			index++;
		}
		while (begin1<=end1) {
			tmp[index]=ints[begin1];
			begin1++;
			index++;
		}
		while (begin2<=end2) {
			tmp[index]=ints[begin2];
			begin2++;
			index++;
		}
	}
}

选择排序

package zll.material.java_base_homework;  
  
import java.util.Arrays;  
/*  
选择排序算法： 
首先在未排序序列中找到最小元素，存放到排序序列的起始位置 
 然后，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。    以此类推，直到所有元素均排序完毕。 
 */    
public class D04 {  
    public static void main(String[] args) {  
         int[] a = new int[]{5,9,3,78,65,38};  
         selectSort(a);  
         System.out.println(Arrays.toString(a));  
    }  
  
    private static void selectSort(int[] a) {  
        if(a==null||a.length<=0){  
            return;  
        }  
        for(int i=0;i<a.length;i++){  
            int tmp = a[i];  
            int flag = i; // 将当前下标定义为最小值下标  
            for(int j=i+1;j<a.length;j++){  
                if(a[j]<tmp){// a[j] < temp 从小到大排序；a[j] > temp 从大到小排序  
                    tmp=a[j];  
                    flag=j;// 如果有小于当前最小值的关键字将此关键字的下标赋值给flag  
                }  
            }  
            if(flag != i){  
                a[flag]=a[i];  
                a[i]=tmp;  
            }  
        }  
    }  
}