排序算法

一、冒泡排序算法

1.1 算法原理

    每次比较两个相邻的元素，将较大的元素后移一位

    每一轮比较后，都会把遍历到最大的数据移动到末尾（一次遍历保证一个数据有序）

    若有n个数据，n轮遍历下来，就会实现数据从小到大的有序排列

 

    时间复杂度：最好情况O(n)，最坏情况O()，平均情况O()

    空间复杂度：最坏情况O(n)

 

1.2 动图演示

 

 

1.3 代码实现

package SortAlgorithm;

/**
 * 冒泡排序算法
 * @author RoRoBear
 *
 */
public class BubbleSort {
	
	public static void main(String[] args) {
		int[] arr = {0,-3,-76,38,23,45,1,29,89,65,47,4,97};
		int temp = 0;
		//n个数据遍历n轮
		for(int i = 0;i<arr.length-1;i++){ 
			//每一次遍历，确定一个最大数在数组末尾
			for(int j = 0;j<arr.length-1-i;j++){
				//交换
				if(arr[j+1]<arr[j]){
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		//查看一下
		for(int k =0;k<arr.length;k++){
			System.out.print(arr[k]+"  ");
		}
	}
	
}

//结果
//-76  -3  0  1  4  23  29  38  45  47  65  89  97
 

---

二、快速排序算法

2.1 算法原理

    在目标序列中找一个"基准值"

    通过一趟排序将目标序列以“基准数”为界分割成两部分，左边部分数据都比“基准数”小，右边部分数据都比“基准数”大

    然后再按上一步对这两部分数据分别进行快速排序（递归进行），直到数据全部有序

 

    时间复杂度：最好情况：，最坏情况：，平均情况：

    空间复杂度：最好情乱：，最坏情况O(n)

 

2.2 动图演示

2.3 代码实现

package SortAlgorithm;

/**
 * 快速排序算法
 * @author RoRoBear
 *
 */
public class QuickSort {

	public static void quickSort(int[] arr,int left,int right){       
        if(left > right){
            return;
        }     
        int i = left,j = right;
        //选左边数为基准值
        int key = arr[left];
        //确定循环区间
        while (i < j) {
            //若右边数比基准值大，指针左移
            while (key <= arr[j] && i<j) {
                j--;
            }
            //若左边数比基准值小，指针右移
            while (key >= arr[i] && i<j) {
                i++;
            }
            //
            if (i < j) {
                int temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
            }

        }
        //将拿出来的arr[i]放入到正确位置
         arr[left] = arr[i];
       //将基准值放入正确位置（左边都比他小，右边都比他大）
         arr[i] = key;
        //递归调用左半数组
        quickSort(arr, left, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, right);
    }
		
    public static void main(String[] args){
        int[] arr = {5,12,3,3,9,35,-34,0,18,46,57,-1,-5,-32,19};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
    }
}

//结果
//-34  -32  -5  -1  0  3  3  5  9  12  18  19  35  46  57

---

三、归并排序 

这里以二路归并为例

3.1 算法原理

    归并排序的过程其实是左右分割再归并的过程，怎么理解呢，针对目标数组，从中间(mid)一分为二，对左边和右边分别进行“左右分割再归并”过程，对所有数据进行排序。

    所以要依赖两个函数实现，①通过递归函数实现不停的左右分割再归并，②通过排序函数对每次分割完的部分进行排序

 

    时间复杂度：

    空间复杂度：

 

3.2 动图演示

3.3 代码实现

package SortAlgorithm;
/**
 * 归并排序
 * 二路归并
 * @author RoRoBear
 *
 */
public class MergeSort {

	public static void mergeSort(int[] arr, int left, int right){
		int mid = (left+right)/2;
		if(left < right){
			mergeSort(arr, left, mid);
			mergeSort(arr, mid+1, right);
			merge(arr, left, mid, right);
		}
	}
	
	public static void merge(int[] arr, int left, int mid, int right ) {
		//额外空间存放排序数据
		int[] temp = new int[right-left+1];
		
		int i = left,j = mid + 1,k=0;
		
		//
		while (i <= mid && j <= right) {
			if(arr[i] <= arr[j]){
				temp[k++] = arr[i++];
			}else {
				temp[k++] = arr[j++];
			}
		}
		//将左边剩余数据存入temp
		while (i <= mid) {
			temp[k++] = arr[i++];
		}
		//将右边剩余数据存入temp
		while (j <= right) {
			temp[k++] = arr[j++];
		}
		for(int m = 0;m<temp.length;m++){
			arr[left+m] = temp[m]; 
		}
	}
	
	public static void main(String[] args) {
		int[] arr = {2,3,5,78,45,-1,42,0,5,-5,-5,27,38,72};
		mergeSort(arr, 0, arr.length-1);
		for(int i =0;i<arr.length;i++){
			System.out.print(arr[i]+"  ");
		}
	}
}

//结果
//-5  -5  -1  0  2  3  5  5  27  38  42  45  72  78  

---

四、选择排序

3.1 算法原理

选择第一个元素，分别与第二、第三...最后一个元素比较，每次比较之后保证小的元素在第一个位置，这样一轮排序下来就能确定第一个位置上的元素是最小的元素

从第二个元素开始，重复上一步，n轮比较下来，n个元素已排好序（升序）

 

    时间复杂度：

    空间复杂度：

 

3.2 动图演示

3.3 代码实现

这里提供两种写法，大家自己比对吧

//one
private static void selectSort(int[] a) {
        int length = a.length;
        int temp = 0;
        for (int j = 0; j <length- 1;j++) {
            for (int i = j; i < length- 1; i++) {
                if (a[j] > a[i + 1]) {
                    // 交换数值
                    temp = a[j];
                    a[j] = a[i + 1];
                    a[i + 1] = temp;
                }
            }
        }
    }

 

//two
private static void seletSort(int[] a) {
        int temp = 0;
        int minIndex;
        for (int j = 0; j <a.length- 1;j++) {
            minIndex = j;
            for (int i = j; i < length- 1; i++) {
                if (a[minIndex] > a[i + 1]) {
                    minIndex = i+1;
                }
            }
            temp = a[minIndex];
            a[minIndex]= a[j];
            a[j]=temp;
        }
    }