算法学习之一系列的排序

冒泡排序

思路：有N个数 在0-N-1范围上 从第一个数开始然后如果后一个数比前一个数小 那么就交换，然后一直交换到最后，最大的数就跑到了最后一个 然后再0-N-2范围上继续这个操作。

public class BubbleSort {
    public int[] bubbleSort(int[] A, int n) {
        // write code here
         for(int i=n-1;i>0;i--){
             for(int j=0;j<i;j++){
                 if(A[j]>A[j+1]){
                     swap(A,j,j+1);
                 }
             }
                
             
         }
        return A;
    }
    public static void swap(int[] arr, int index1, int index2) {
		int tmp = arr[index1];
		arr[index1] = arr[index2];
		arr[index2] = tmp;
	}
}

选择排序

在0-N-1范围内选择一个最大的数然后交换给N-1位置，然后再0-N-2继续选择

import java.util.*;

public class SelectionSort {
    public int[] selectionSort(int[] A, int n) {
        // write code here
     if(A.length<2||A==null){
         return ;
     }
       int temp =0;
        for(int i=0;i<A.length-1;i++){
            mini =i;
            for(int j=i;j<A.length-1;j++){
                 temp = A[mini]>A[j]?j:i;
            }
        }
    }
}

插入排序

插入排序就是最开始 第二个数与第一个数比较 如果第二个数比第一个数小 那么交换，然后插入第三个数，第三个数与第二个数比较 如果第三个数比第二个数小 然后交换，此时第二个数再与第一个数交换， 一直这个过程，那么最差的情况，第2个数交换1次 第3个数交换两次。第N个数交换N-1次 

public class InsertionSort {
    public int[] insertionSort(int[] arr, int n) {
        // write code 
     for(int i =1;i<n;i++){
         int  index = i;
			while (index > 0) {
				if (arr[index - 1] > arr[index]) {
					swap(arr, index - 1, index);
					index--;
				} else {
					break;
				}
			}
     }
        public static void swap(int[] arr, int index1, int index2) {
		int tmp = arr[index1];
		arr[index1] = arr[index2];
		arr[index2] = tmp;
	}
        return A;
        
    }
}

快速排序

快速排序就是在数组中随机选取一个数， 然后设置一个小于该数的边界，最开始为-1. 然后遍历，每次遇到小于他的数，就将他与边界的下一个数交换，然后边界+1，然后最终那个随机数与边界的下一个数交换，那么结果就是前边都是小于他的数，后边都是大于他的数，然后递归重复这个操作。

import java.util.*;

public class QuickSort {
    public int[] quickSort(int[] A, int n) {
        // write code here
      
        quickS(A,0,n-1);
        return A;
    }
    public void quickS(int[] A,int L,int R){
        if(A==null||A.length<2){
            return;
        }
           //随机选取一个数
        if(L>=R){
            return;
        }
         int max =A[R];
        
        //选定小于区间
         int length =L-1;
        // 数小于选定数 将其与小于区间之后一个数交换，然后小于区间扩大 然后缩小范围
        for(int i=L;i<R;i++){
            if(A[i]<max){
                sorts(A,length+1,i);
                length++;
            }
        }
         sorts(A,length+1,R);
         quickS(A,L,length);
         quickS(A,length+2,R);
    }
    
    public void sorts(int[] A,int n,int m){
       int  temp =A[n];
        A[n] =A[m];
        A[m]=temp;
    }
}

归并排序

归并排序就是将一个数组分成两个部分，然后两边设立游标，游标上小的数放到新的数组 放到新数组的前边，这样就在新数组上排好了序

import java.util.*;

public class MergeSort {
    public int[] mergeSort(int[] A, int n) {
        // write code here
        MergeSortF(A,0,n-1);
        return A;
    }
    public  void  MergeSortF(int []A,int left,int right){
        if(A.length<2||A==null){
            return ;
        }  
        if(left>=right){
            return;
        }
        //一分为二 分为左孩子 右孩子
        //左孩子右孩子一分为二之后 进行两边排序
        int  L=left;
        int RE =right;
        int mid =L+(RE-L)/2;
        int length =RE-L+1;
        int R =mid+1;
        MergeSortF(A,L,mid);
        MergeSortF(A,R,RE);
        merge(A,L,mid,R,RE,length);
     
 
    }
    public void merge(int[] A, int L,int mid,int R,int RE,int length){
        int [] temp = new int [length];
        int index =0;
        int start =L;
        while(L<=mid&&R<=RE){
            //如果小于 则交换
            temp[index++]=A[L]>A[R]?A[R++]:A[L++]; 
            
        }
       //一方越界之后则将另一方全部复制过去
       while(L>=mid&&R<=RE){
           temp[index++]=A[R++];
       }
        while(L<=mid&&R>=RE){
           temp[index++] =A[L++];
       }
        for(int i=0;i<length;i++){
            A[start+i]= temp[i];
           
        }
        
        //粘贴给A
        
        
    }
}

堆排序

堆排序就是利用大根堆，每次都排好大根堆，然后将根节点取出放到最后， 然后重新组成大根堆 再放到最后重复这一个操作

import java.util.*;

public class HeapSort {
    public int[] heapSort(int[] A, int n) {
        // write code here
        //排成大根堆
        int heapsize =n;
        for(int i =0;i<n;i++){
            heapfily(A,i);
        }
     
         while(heapsize>0){
            swap(A,0,--heapsize);
            heapre(A,0,heapsize);
            
           
        }
        return A;
    }
    public void  heapfily(int[] A,int index){
      
          while(A[index]>A[(index-1)/2]){
              swap(A,index,(index-1)/2);
              index =(index-1)/2;
          }
  
        
    }
    public void heapre(int[] arr,int index ,int size){
         int left = index * 2 + 1;
		while (left < size) {
			int largest = left + 1 < size && arr[left+1] > arr[left] ? left+1  : left;
			if(arr[largest]<=arr[index]){
                break;
            }
			swap(arr, largest, index);
			index = largest;
			left = index * 2 + 1;
		}
    }
    
    
    public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

}