几个常用的排序算法思想

冒泡排序（Bubble Sort）

思想（升序排序）：

比较相邻的两个元素。如果第一个元素比第二个元素大，就交换两个元素的位置，重复这项操作，直至没有再需要交换的元素，说明排序完成

代码实现

public void BubbleSort(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length-1; j++) {
				if(arr[j]>arr[j+1]) {
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
	}

例子：  arr={5,2,15,31,10,8,20,1}
第一趟：2,5,15,10,8,20,1,31
第二趟：2,5,10,8,15,1,20,31
第三趟：2,5,8,10,1,15,20,31
第四趟：2,5,8,1,10,15,20,31
第五趟：2,5,1,8,10,15,20,31
第六趟：2,1,5,8,10,15,20,31
第七趟：1,2,5,8,10,15,20,31
排序完成：
    升序数组为：1,2,5,8,10,15,20,31

选择排序（Selection Sort）

思想：

       首先在没有排序的数组中找到（选择）最大（或最小）的那个元素 ，将其放到排序数组的起始位置，然后又从没有排序的数组中寻找出最大（或最小）的那个元素，将其插入到排序数组末尾的位置，以此类推，直至排序完成

代码实现

    //选择排序
	public static void SelectionSort(int arr[]) {
		int maxIndex;//定义最大元素的下标
		int temp;//定义一个中间变量
		for (int i = 0; i < arr.length-1; i++) {
			maxIndex=i;//假设第一个元素为最大元素
			for (int j = i+1; j < arr.length; j++) {
				if (arr[j]>arr[maxIndex]) {
					//如果找到比最大元素还大的数,就交换两个下标的值
					maxIndex=j;
				}
			}
			temp =arr[i];
			arr[i]=arr[maxIndex];
			arr[maxIndex]=temp;
		}
	}


int []arr={5,2,15,31,10,8,20,1};
第1趟[31, 2, 15, 5, 10, 8, 20, 1]
第2趟[31, 20, 15, 5, 10, 8, 2, 1]
第3趟[31, 20, 15, 5, 10, 8, 2, 1]
第4趟[31, 20, 15, 10, 5, 8, 2, 1]
第5趟[31, 20, 15, 10, 8, 5, 2, 1]
第6趟[31, 20, 15, 10, 8, 5, 2, 1]
第7趟[31, 20, 15, 10, 8, 5, 2, 1]
    
排序完成：[31, 20, 15, 10, 8, 5, 2, 1]

插入排序（Insertion Sort）

思想：

        通过构建一个有序数组，对未排序的数据，在已经排序好的数组中从后往前扫，找到相应的位置并将其插入。

代码实现

//插入排序
	public static void InsertionSort(int arr[]) {
		int preIndex;
		int temp;
		for (int i = 0; i < arr.length; i++) {
			preIndex=i-1;
			temp=arr[i];//将第i个下标的元素赋值给temp
			while (preIndex>=0 && arr[preIndex]>temp) {
				arr[preIndex+1]=arr[preIndex];
				preIndex--;
			}
			arr[preIndex+1]=temp;
			System.out.println("第"+i+"趟"+Arrays.toString(arr));
		}
	}

int []arr={5,2,15,31,10,8,20,1};
第1趟[5, 2, 15, 31, 10, 8, 20, 1]
第2趟[2, 5, 15, 31, 10, 8, 20, 1]
第3趟[2, 5, 15, 31, 10, 8, 20, 1]
第4趟[2, 5, 15, 31, 10, 8, 20, 1]
第5趟[2, 5, 10, 15, 31, 8, 20, 1]
第6趟[2, 5, 8, 10, 15, 31, 20, 1]
第7趟[2, 5, 8, 10, 15, 20, 31, 1]
第8趟[1, 2, 5, 8, 10, 15, 20, 31]

排序完成：[1, 2, 5, 8, 10, 15, 20, 31]


第一趟：将元素5作为已经排序好的序列{5}
第二趟：找到2，比5小，将2插入到5的前面{2,5}
第三趟：找到15和{2,5}比较，插入到后边{2,5,15}
第四趟：找到31,和{2,5,15}比较，插入到后边,{2,5,15,31}
第五趟：找到10，和{2,5,15,31}比较,插入到15的前面:{2,5,10,15,31}
第六趟：找到8，和{2,5,10,15,31}比较，插入到5后边，10前边：{{2,5,8,10,15,31}}
第七趟：找20，和{2,5,8,10,15,31}比较，插入到15后边，30前边：{2,5,8,10,15,20,31}
第七趟：找到1,和{2,5,8,10,15,20,31}比较，1比2小，插入到2的前边：{1,2,5,8,10,15,20,31}
第八趟：排序完成{1,2,5,8,10,15,20,31}

希尔排序（Shell Sort）

思想：希尔排序是插入排序的改进版，跟插入排序差不多，不同之处在于，希尔排序优先选择距离比较远的元素来比较啊。希尔排序又称为缩小增量排序

//希尔排序
	public static void ShellSort(int []arr) {
		for (int i = arr.length/2; i >0; i=i/2) {
			for (int j = i; j < arr.length; j++) {
				int k=j;
				int temp=arr[j]; //arr[4]=10
				while(k-i>=0 && temp<arr[k-i]) {
					arr[k]=arr[k-i];
					k=k-i;
				}
				arr[k]=temp;
			}
			System.out.println("i="+i+Arrays.toString(arr));
		}
	}

原数组=[5, 2, 15, 31, 10, 8, 20, 1]

i=4时 [5, 2, 15, 1, 10, 8, 20, 31]
i=2时 [5, 1, 10, 2, 15, 8, 20, 31]
i=1时 [1, 2, 5, 8, 10, 15, 20, 31]
------------------------------------------------------------
i=4时：
    5跟10比，小，不变；10跟arr[8]=null比，不变
    2跟8比， 小，不变；8跟arr[9]=null比， 不变
    15跟20比，小，不变；20跟arr[10]=null比，不变
    31跟1比，大，交换位置

第一趟结果arr=[5,2,15,1,10,8,20,31]
-----------------------------------------------------------
i=2时：
    5跟15比，小，不变；
    15跟10比，大，交换位置；交换后的10的位置为15,15原来的位置为10,
    15跟20比，小，不变. 
    此时的arr= [5,2,10,1,15,8,20,31]

    2跟1比，大，交换位置；交换后1位置上的2跟8比，小，不变；
    8跟31比，小，不变
    此时的数组arr=[5,1,10,2,15,8,20,31]

第二趟结果arr=[5,1,10,2,15,8,20,31]
----------------------------------------------------
i=1时：
    1跟5比，小，交换位置，{1,5}；10跟5比大，插入到5后边{1,5,10};
    2跟10比，小；跟5比小；跟1比大，插入到1后边{1,2,5,10}；
    15跟10比大，插入到10后边，{1,2,5,10,15}；
    8跟15比小，再跟10比小，再跟5比大，插入到5后边，{1,2,5,8,10,15}；
    20跟15比，大，插入到15后边；{1,2,5,8,10,15,20}；
    31跟20比大，插入到20后边，{1, 2, 5, 8, 10, 15, 20, 31}

第三趟结果arr=[1, 2, 5, 8, 10, 15, 20, 31]
----------------------------------------------------
排序后的数组=[1, 2, 5, 8, 10, 15, 20, 31]

快速排序（Quick Sort）

思想：

1. 先从序列中取出一个数作为基准数
2. 分区过程，将比这个数大的数 全放到它的右边，小于或等于它的数全放到它的左边
3. 再对左右区间进行第二步步骤，直到各区间只有一个数

public static void quickSort(int arr[],int left,int right) {
		if (left<right) {
			int i=left;
			int j=right;
			//从后往前查找
			while(i<j && arr[j]>=arr[i]) {
				j--;
			}	
			//交换
			swap(arr,i,j);
			//从前往后查找
			while(i<j && arr[j]>=arr[i]) {
				i++;
			}
			//交换
			swap(arr, i, j);
			//对左边的递归
			quickSort(arr, left, j-1);
			//对右边的递归
			quickSort(arr, j+1, right);
		}
	}
//交换函数
	public static  void swap(int arr[],int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}