排序算法汇总

1.选择排序

选择排序主要是通过2层循环，外层循环以i为标识，内层以j为标识，内层每循环一遍，会取出最大的数放在末尾；后面循环依次取出最大的数放在末尾；

 //选择排序
    static void chooseSort(int [] data) {
        for (int i=0;i<data.length-1;i++) {
            int smallIndex = i;
            for (int j=i+1 ;j<data.length;j++) {// 0-i 已经排好,从i+1开始排序
                if (data[i]>data[j]) {
                    smallIndex = j;//j是最小的数
                }
            }
            swap(data,i,smallIndex);  //交换i，j索引的数据，保证i是最小的数
        }
    }
  public static void swap (int[] data,int i,int j){
        int temp = data[j];
        data[j]=data[i];
        data[i]=temp;
    }

2.冒泡排序

	static void bubbleSort(int [] data) {
        for (int i=0;i<data.length-1;i++) {
            for (int j=0 ;j<data.length-i-1;j++) {// 0-i 已经排好,从i+1开始排序
                if (data[j]>data[j+1]) {
					swap(data,j,j+1); 
                }
            }
            swap(data,i,smallIndex);  //交换i，j索引的数据，保证i是最小的数
        }
    }
   public static void swap (int[] data,int i,int j){
        int temp = data[j];
        data[j]=data[i];
        data[i]=temp;
    }

3.快速排序

	  public static void qSort(int data[], int left, int right) {

            int base = data[left]; // 就是我们的基准数，取序列的第一个,不能用data[0],
            int ll = left; // 表示的是从左边找的位置
            int rr = right; // 表示从右边开始找的位置
            while (ll < rr) {//完成后，比基准小的都在左侧，比基准大的都在右侧
                // 从后面往前找比基准数小的数
                while (ll < rr && data[rr] >= base) {
                    rr--;
                }
                if (ll < rr) { // 表示右侧找到有比base小的
                    data[ll++] = array[rr];  //右侧到左侧，左侧右移,ll这个坑已经拿出来做基准数
                }
                while (ll < rr && data[ll] <= base) {//从前往后找比基准大的位置
                    ll++;
                }
                if (ll < rr) { //左侧找到比基准大的位置了，左右交换位置，右侧左移
                    data[rr--] = array[ll];  //左侧填到右侧，右侧左移，rr这个坑已经给了左侧
                }
            }//出来的时候ll数字为空
            data[ll] = base;//基准数填到最后的坑
            // 肯定是递归 分成了三部分,左右继续快排，注意要加条件不然递归就栈溢出了
            if (left < ll)
                qSort(data, left, ll - 1);
            if (ll < right)
                qSort(data, ll + 1, right);

        }

4.归并排序

package algorithm.sort;

import java.util.Arrays;

public class MegrSort {
	public static void main(String[] args) {

		int data[] = { 9, 5, 6, 8, 0, 3, 7, 1 };
		megerSort(data, 0, data.length - 1);
		System.out.println(Arrays.toString(data));
		//JDK里面的排序源码

	}

	public static void megerSort(int data[], int left, int right) { // 数组的两端
		if (left < right) { // 相等了就表示只有一个数了 不用再拆了
			int mid = (left + right) / 2;
			megerSort(data, left, mid);
			megerSort(data, mid + 1, right);
			// 分完了 接下来就要进行合并，也就是我们递归里面归的过程
			meger(data, left, mid, right);
		}
	}

	public static void meger(int data[], int left, int mid, int right) {
		int temp[] = new int[data.length];		//借助一个临时数组用来保存合并的数据
		
		int point1 = left;		//表示的是左边的第一个数的位置
		int point2 = mid + 1;	//表示的是右边的第一个数的位置
		
		int loc = left;		//表示的是我们当前已经到了哪个位置了
		while(point1 <= mid && point2 <= right){
			if(data[point1] < data[point2]){
				temp[loc] = data[point1];
				point1 ++ ;
				loc ++ ;
			}else{
				temp[loc] = data[point2];
				point2 ++;
				loc ++ ;
			}
		}
		//接下来要干嘛呢？合并排序完成 了吗？
		while(point1 <= mid){
			temp[loc ++] = data[point1 ++];
		}
		while(point2 <= right){
			temp[loc ++] = data[point2 ++];
		}
		for(int i = left ; i <= right ; i++){
			data[i] = temp[i];
		}
	}
}