八大排序算法

下面的排序算法都是以65 26 37 9 21 74 26 5 14为例，除了第一个排序之外，其他的就不写测试主函数了
一、选择排序
原理：
第一次就是选择最小的数跟第一个数进行交换（保证第一个数是最小的）
第二次就是除去第一个数，剩下的选择最小的跟第二个数进行交换（此时第一个数和第二个数是有序的，且是最小的）
以此类推
思路：
1、最外层当然是遍历整个数组。用i表示此次选择遍历开始的位置
2、用k=i，记录此次遍历最小值的位置。刚开始让等于此次遍历第一元素的位置
3、内层从i+1开始，遍历的同时和用arr[j]和arr[k]相比，要是比k位置小的话，就把k=j；保证k位置的值永远是最小的
4、内层遍历完事后，如果k!=i。说明最小值位置不是此次遍历的起始位置，那么就交换k和i的值。一次遍历完事

public class Selectsort {
	public static void selectSort(int[] arr)
	{
		int k=0;
		int len=arr.length;
		int temp=0;
		for(int i=0;i<len;i++)
		{
			k=i;
			for(int j=i+1;j<len;j++)
			{
				if(arr[j]<arr[k])
				{
					k=j;
				}
			}
			if(k!=i)
			{
				temp=arr[i];
				arr[i]=arr[k];
				arr[k]=temp;
			}
		}
	}
	public static void main(String[] args) {
		int []arr= {65 ,26, 37, 9, 21, 74, 26, 5, 14};
		selectSort(arr);
		int len=arr.length;
		for(int i=0;i<len;i++)
		{
			System.out.print(arr[i]+" ");
		}
	}

二、冒泡排序
原理：
最主要的两个字就是两两交换
利用每一次的两两交换保证大的最后面，这样一次两两交换结束后，最大的就是最后一个
第二次，除了最后一个外，剩下的继续两两交换，保证最大的在倒数第二个（此时倒数第二个和倒数第一个是有序的，且是最大的两个）
依次类推
（选择排序是通过选择把最小的放在第一个位置，冒泡排序是通过两两交换把最大的放在最后一个位置）
思路：
最外层还是通过i来遍历整个数组
内层通过i来确认j最后走到哪里
比较j和j+1的大小，要是arr[j]>arr[j+1]，交换

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

三、插入排序
原理
假设第一个记录已经是排好序的了
接着从第二个数开始，依次把这些数插入到前面已经排好序的序列的相应位置。
所以问题就是怎样找到要插入元素的相应位置
思路
因为第一个元素已经是有序的
所以最外层i从1开始（i代表了前i个数已经有序了）,i也是待插入的元素的位置
让temp记录i位置的元素，j=i-1。因为前i个数已经排好序了，所以j位置为最大的。
接下来进行判断，要是arr[temp]>arr[j]。直接把i的值插入到j的后面。
如果不是的话，就依次把前面排好序的元素往后移，找出要插入的位置
（思路说的不好，可以不看，直接看代码能懂）

public static void insertSort(int[] arr)
	{
		int len=arr.length;
		int temp=0;
		int j=0;
		for(int i=1;i<len;i++)
		{
			temp=arr[i];
			j=i-1;
			while(j>=0&&arr[j]>temp)
			{
				arr[j+1]=arr[j];
				j--;//保证j是要插入位置的前一个位置
			}
			arr[j+1]=temp;
			
		}
	}

四、快速排序
原理：
就是以第一个元素为基准，一次排序之后让左面都是小于它的数，右面都是大于它的数。然后再把它左右两面用递归的方式重复此操作，那么问题来了怎么把第一个元素放到合适的位置，让左面都是小于它的，右面都是大于它的。
思路：
开始让i处于第一个元素位置，j为最后一个元素位置，并用temp记录arr[i]，因为temp是要待插入的点。
j从后往前找到比temp小的数，然后让arr[i++]=arr[j]。注意这里将arr[j]赋给arr[i]后，i有个自加。
i从前往后找到比temp大的数，然后让arr[j–]=arr[i]。注意这里将arr[i]赋给arr[j]后，j有个自减。
重复此操作，直到条件不再满足于i<j。此时i的位置就是temp应有的位置。arr[i]=temp。
递归左右。

package Sort;

public class QuickSort {
	public static void quickSort(int[] arr,int start,int end)
	{
		int i=start;
		int j=end;
		if(start>=end)
		{
			return;
		}
		int temp=arr[start];
		while(i<j)
		{
			while(i<j && temp<=arr[j])
				j--;
			if(i<j)
				arr[i++]=arr[j];
			while(i<j && temp>=arr[i])
				i++;
			if(i<j)
				arr[j--]=arr[i];
			
		}
		arr[i]=temp;
		quickSort(arr,start,i-1);
		quickSort(arr,i+1,end);
	}
	public static void main(String[] args) {
		int[] arr= {65 ,26, 37, 9, 21, 74, 26, 5, 14};
		int len=arr.length;
		quickSort(arr,0,len-1);
		for(int i=0;i<len;i++)
		{
			System.out.print(arr[i]+" ");
		}
	}

}

五、希尔排序
原理写在笔记里了，总之就是插入排序。只不过，插入排序从1开始，希尔排序从d开始，插入排序里面是j=i-1,j=j–。而希尔排序里是j=i-d,j=j-d。（具体笔记笔记里会写）

package Sort;

public class ShellSort {
	public static void shellSort(int[] arr)
	{
		int len=arr.length;
		int d=len/2;
		int i,j;
		int temp;
		while(d>=1)
		{
			for(i=d;i<len;i++)
			{
				temp=arr[i]; //待插入元素
				j=i-d;       //待插入元素的前一个位置
				while(j>=0 && arr[j]>temp)
				{
					arr[j+d]=arr[j];
					j=j-d;
				}
				arr[j+d]=temp;
			}
			d=d/2;
		}
	}
	public static void main(String[] args) {
		int[] arr= {32,24,95,45,75,22,95,49,3,76,56,11,37,58,44,19,1};
		shellSort(arr);
		for(int i=0;i<arr.length;i++)
		{
			System.out.print(arr[i]+" ");
		}
	}

}