排序（java）

一、冒泡排序

基本思想：
重复遍历所要排序的数列，一次比较两个元素，如果大小顺序有误就交换，每次遍历可以把要排序的数列中最大的数移到最后。
时间复杂度：O(n^2)

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

二、快速排序

基本思想： 以第一个数为基点，比他大的移到后面，比他小的移到前面，再对左右两边进行递归操作。
时间复杂度：O(nlogn) 最坏情况是O(n^2)
空间复杂度：O(logn) 最坏情况是O(n)

public static void quickSort(int[] numbers,int begin,int end)
	{
		if(begin>=end)
			return ;
		int i=begin;
		int j=end;
		int key=numbers[begin];
		while(i<j)
		{
			while(i<j && numbers[j]>key)
			{
				j--;
			}
			if(i<j)
			{
				numbers[i]=numbers[j];
				
			}
			while(i<j && numbers[i]<key)
			{
				i++;
			}
			if(i<j)
			{
				numbers[j]=numbers[i];
				
			}
		}
		numbers[i]=key;
		quickSort(numbers,begin,i-1);
		quickSort(numbers,i+1,end);
	}

三、选择排序

基本思想： 从未排序队列中选择最小的数和未排序队列中第一个数交换。
时间复杂度：O(n^2)

public static void selectSort(int[] numbers)
	{
		
		for(int i=0;i<numbers.length-1;i++)
		{
			int min=i;
			for(int j=i+1;j<numbers.length;j++)
			{
				if(numbers[j]<numbers[min])
					min=j;
			}
			int tmp=numbers[min];
			numbers[min]=numbers[i];
			numbers[i]=tmp;
			
		}
	}

四、插入排序

基本思想： 前面有序，后面无序，将后面的数挨个按顺序插入到前面。

public static void InsertSort(int[] numbers)
	{
		int j;
		for(int i=1;i<numbers.length;i++)
		{
			int key=numbers[i];
			for(j=i;j>0 && numbers[j-1]>key;j--)
			{
				numbers[j]=numbers[j-1];
			}
			numbers[j]=key;
			printfNumbers(numbers);	
		}
		
	}

五、希尔排序

希尔排序是插入排序的变形，对于n比较大且无序的情况比插入排序更好。
记住三个for循环，一个if

public static void ShellSort(int[] nums)
	{
		int i=0;
		int j=0;
		for(int d=nums.length/2;d>=1;d=d/2)
		{
			for(i=d;i<nums.length;i++)
			{
				int value=nums[i];
				for(j=i-d;j>=0;j-=d)
				{
					if(nums[j]>value)   //这个地方容易错，开始写成nums[j]>nums[j+length],但是注意了，nums[j+length]是会变化的
					{
						nums[j+d]=nums[j];
						
					}
					else
					{
						
						break;
					}
				}
				nums[j+d]=value;
			}
			printfNumbers(nums);
		}
	}

六 堆排序

大顶堆，排序：升序
小顶堆，排序：降序
以大顶堆为例:先构成一棵大顶堆，将堆顶元素和最后一个交换，依次类推，直到最后结束。

public static int[] sort(int[] sourceArray)
	{
		int[] arr=Arrays.copyOf(sourceArray,sourceArray.length);
		
		int len=arr.length;
		
		buildMaxHeap(arr,len);
		printfNumbers(arr);
		for(int i=len-1;i>=0;i--)
		{
			swap(arr,0,i);
			printfNumbers(arr);
			len--;
			heapify(arr,0,len);
			printfNumbers(arr);
		}
		
		return arr;
	}
	public static void  swap(int[] arr,int index1,int index2)
	{
		int tmp=arr[index1];
		arr[index1]=arr[index2];
		arr[index2]=tmp;
		
	}
	public static void buildMaxHeap(int[] arr,int length)
	{
		for(int i=(int) Math.floor(length / 2);i>=0;i--)
		{
			heapify(arr,i,length);
			
		}
	}
	public static void heapify(int[] arr,int index,int len)
	{
		int left=2*(index+1)-1;  //注意此处是index，和我们日常计数不同
		int right=left+1;
		
		int largest=index;
		
		 if(left<len-1 && arr[left]>arr[largest])
			 largest=left;
		 if(right<len-1 && arr[right]>arr[largest])
			 largest=right;
		 
		 if(largest!=index)
		 {
			 swap(arr,largest,index);
			 heapify(arr,largest,len);
		 }
		
	}