数据结构与算法-常用排序（1）

交换排序的两种：

1.冒泡排序

基于从前往后遍历，比较前后的两个，然后根据比较情况决定交换与否

package math;

import java.util.Arrays;

public class BubbleSort {

	public static void main(String[] args) {
		
		int[]  arr  =  new int[]{4,7,2,3,9,13};
		
		for(int i = 0 ; i<arr.length-1 ;i++){
			for(int j=0;j<arr.length-1-i;j++){
				
				if(arr[j]>arr[j+1]){
					
					int temp = arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp ;
					
					
				}
				
				
				
			}
		}
		
		
		System.out.println(Arrays.toString(arr));
		
		
		
		
		

	}

}

2.快速排序

思想是以第一个元素作为一个基准，然后从后往前遍历，找到比它小的元素，然后交换两者位置，然后再从前往后遍历，找到

比它大的元素，交换位置，这样实现了基准左边的数一定比它小，而基准右边的数一定比它大。然后对基准元素的左边和右边用同样的方法操作，即使用递归

package math;

import java.util.Arrays;

public class QuickSort {

	public static void main(String[] args) {
		int[]  arr  =  new int[]{4,7,2,3,9,13};
		
		new QuickSort().quicksort(arr,0,arr.length-1);
		
		System.out.println(Arrays.toString(arr));
		
	}
	
	public void quicksort(int[] arr , int sta ,int end){
		
		int stard = arr[sta];  //先把基准数的大小记录下来
		int low = sta ;
		int high = end ;
		
		while(low<high){
			
			while( low<high&&stard<arr[high]){
				
				high--;
				
			}
			
			 arr[low]=arr[high]; //找出的high位置的元素最后放在初始基准数的位置
			
			while(low<high&&stard>arr[low]){
				
				low++ ;
				
			}
			
			arr[high]= arr [low];
			arr[low]= stard ; //此时low的位置已经改变
			
			
			quicksort(arr,sta,low-1);
			quicksort(arr, low+1, end);
			
		}
		
		
		
		
		
		
		
	}
	
	

}

3.插入排序中的直接插入排序

思路：从数组的第二个元素为开始下标，基于下标的左侧始终是有序的这一现实情况

这样只有在下标数比前一个数小时做操作，往前遍历，找出该下标数应该在的位置，插入，然后

把从插入位置开始的数依次向后移动一位

package math;

import java.util.Arrays;

public class InsertSort {

	public static void main(String[] args) {
		int[]  arr  =  new int[]{4,7,2,3,9,13};
		
		new InsertSort().insertsort(arr);
		
		System.out.println(Arrays.toString(arr));
		
	}
	
	public void insertsort(int[]  arr){
		
		//从第二个开始遍历
		for(int i = 1 ; i<arr.length;i++){
			
			if(arr[i]<arr[i-1]){
				//记录下这个较小的元素，便于后面的遍历条件的判断
				int temp = arr[i];
				int j ;
				
				for(  j = i-1 ; j>=0&&temp<arr[j] ; j-- ){
					
					arr[j+1]=arr[j];
					
				}
				
				arr[j+1]=temp ;
			}
			
			
			
			
			
		}
		
		
		
	}
	
	
	
	

}

4.选择排序中的简单选择排序

思路：从前往后遍历，找出数组中最小的数的下标，然后把该下标的元素与第首元素互换，然后

依次进行下去

个人感觉第一映像是对最小的元素的下标进行寻找，然后交换到合适的位置（也就是起始开始依次存放）

import java.util.Arrays;

public class SelectionSort {

	public static void main(String[] args) {
	int[]  arr  =  new int[]{4,7,2,3,9,13};
		
		 new SelectionSort().selectionsort(arr);
		
		System.out.println(Arrays.toString(arr));

	}
	
	
	public void  selectionsort(int[] arr){
		
		for(int i = 0 ;i<arr.length-1 ;i++){
			
			int index = i ;
			int temp = arr[index];  //先拿到原本最左元素的值
			
			for(int j = i+1 ; j<arr.length-1 ; j++){
				
				if(arr[index]>arr[j]){
					
					index = j ;
					
				}
			}
			
			arr[i]=arr[index];
			arr[index]=temp ;
		}
		
		
		
		
		
	}
	
	
	
	
	

}