简单选择排序的基本思想：
给定数组：int[] arr={里面 n 个数据}；第 1 趟排序，在待排序数据 arr[1]~arr[n]中选出最小的数据，将它与 arrr[1]交 换；第 2 趟，在待排序数据 arr[2]~arr[n]中选出最小的数据，将它与 r[2]交 换；以此类推，第 i 趟在待排序数据 arr[i]~arr[n]中选出最小的数据，将它与r[i]交换，直到全部排序完成
快速排序
快速排序的原理：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。
快速排序的实现：
一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有继续比较下一个，直到找到第一个比基准值小的值才交换。找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值来说，左右两边就是有序的了。接着分别比较左右两边的序列，重复上述的环。
例如: 数组 int[] arr={5,2,8,4,9,1};
第一趟排序：选 5 为关键字,low=0,high=5
从 high 开始由，后向前找，找到比 5 小的第一个数 a[5]=1,进行替换
排序结果为:1 2 8 4 9 5
从 low 开始向后搜索,找到比 5 小的,交换1 2 5 4 9 8
从 high 开始由，后向前找，找到比 5 小,交换 1 2 4 5 9 8
直至 low 与 high 相遇重合,
第一趟排序结束以关键字为界,分成左右两个子序列,左边都比 5 小,右边都比 5 大
排序结果:
1 2 4 5 9 8
第二趟排序：
以相同的方式排序左子序列 1 2 4选 1 为关键字 ,low=0,high=2 从 high 开始由，后向前找,找到比 1 小,没有,直至 low 与 high 相遇重合,第二趟排序结束
第二趟以 1 为界,将左子序列分为两个序列,左边没有数据,右边 2,4 两个序列
排序结果: 1 2 4 5 9 8
以相同的方式排序子序列
2 4
选 2 位关键字 ,low=1,high=2 从 high 开始由，后向前找,找到比 2 小,没有,直至 low 与 high 相遇重合,第三趟排序结束
第三趟以 2 为界,将子序列分为两个序列,左边没有数据,右边 4 两个序列排序结果: 1 2 4 5 9 8
第四趟排序：
以相同的方式排序子序列9,8 选 9 位关键字 ,low=4,high=5 从 high 开始由后向前找,找到比 9 小,交换 8,9
第四趟以 9 为界,将子序列分为两个序列,左边 8,右边没有数据
排序结果: 1 2 4 5 8 9
快速排序是递归思想,可以采用递归的方式进行排序
/**
*
*/
package com.gem.demo.day04_practice;
/**
*
* Description:
*
* @author HadwinLing
*
* @date 2020年1月14日下午8:36:22
*
* @version 0.0.1
*
*/
public class Sort {
/*
* 冒泡排序
*
* */
public static int[] BubbleUpSort(int[] arry) {//冒泡升序
for(int i=0;i<arry.length;i++) {
for(int j =0;j<arry.length-i-1;j++) {
if(arry[j]>arry[j+1]) {
int temp =arry[j];
arry[j] = arry[j+1];
arry[j+1] = temp;
}
}
}
return arry;
}
/*
* 选择排序
*
* */
public static int[] selectSort(int[] arry) {
for(int i =0;i<arry.length-1;i++) {
int k =i;
for(int j =k+1;j<arry.length;j++) {
if(arry[j]<arry[k]) {
k=j;//记录目前找到最小值所在的位置
}
}
if(i!=k) {
int temp =arry[i];
arry[i]= arry[k];
arry[k]= temp;
}
}
return arry;
}
/*
* 快速排序
*
* */
public static int[] quickSort(int a[],int low,int high) {
int start = low;
int end= high;
int key = a[low];
while(end>start) {
//从后往前比较
//如果没有比关键值小的，比较下一个，知道有比关键值小的交换位置，然后又从前往后比较
while(end>start) {
end--;
if(a[end]<=key) {
int temp = a[end];
a[end] = a[start];
a[start] = temp;
}
//从前往后比较
while(end>start&&a[start]<=key) {//如果没有比关键值答的，比骄傲下一个，直到有比关键值答的交换位置
start++;
if(a[start]>=key) {
int temp =a[start];
a[start] = a[end];
a[end] = temp;
}
}
//此时第一次循环比较哦啊结束，关键值的位置已经确定了，左边的值都比关键值小，右边的值都比关键值大，但是两边的孙旭还有可能是不一样的，进行下面的递归调用
if(start>low) {
quickSort(a,low,start-1);
}
if(end<high) {
quickSort(a,end+1,high);
}
}
}
return a;
}
}
冒泡排序的优化
package com.hadwinling.learn;
import java.util.Arrays;
/**
* Title: TestBubbleSort.java
* Description: 冒泡排序及优化
* @author HadwinLing
* @date 2020年1月29日
* @version 1.0
*/
public class TestBubbleSort {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
bubbleSort(values);
System.out.println(Arrays.toString(values));
}
public static void bubbleSort(int[] values) {
int temp;
int i;
// 外层循环：n个元素排序，则至多需要n-1趟循环
for (i = 0; i < values.length - 1; i++) {
// 定义一个布尔类型的变量，标记数组是否已达到有序状态
boolean flag = true;
/*内层循环：每一趟循环都从数列的前两个元素开始进行比较，比较到无序数组的最后*/
for (int j = 0; j < values.length - 1 - i; j++) {
// 如果前一个元素大于后一个元素，则交换两元素的值；
if (values[j] > values[j + 1]) {
temp = values[j];
values[j] = values[j + 1];
values[j + 1] = temp;
//本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较；
flag = false;
}
}
//根据标记量的值判断数组是否有序，如果有序，则退出；无序，则继续循环。
if (flag) {
break;
}
}
}
}
