手撕 排序算法

归并排序

//归并排序--采用分治法，先分后治，递归的解决问题
/**
*分：将大问题拆分为小问题。具体来说，将数组氛围左右两个数组，然后递归的调用治理
* 治：采用合并有序数组的方式
*/
public void mergeSort(int[] arr, int left, int right){
    if(left < right){
        int mid = left +right;
        mergeSort(arr, left,mid);
        mergeSort(arr, mid+1, right);
        merge(arr,left,mid,right);
    }
}


/**治：思想，需要合并两个有序数组
* 
*/
public void merge(int[] arr, int left, int mid ,int right){
    int[] temp = new int[right + left];
	int i = left;
    int j = mid+1;
    int k = 0;
    while( i <= mid && j <= right){
        if(arr[i]<=arr[j]){
            temp[k++] = arr[i++]
        }else{
            temp[k++] = arr[j++]
        }
    }
    while(i<=mid){
        temp[k++] = arr[i++];
    }
    while(j <= right){
        temp[k++] = arr[j++];
    }
    for(int n = 0; n< temp.lenght;n++){
        arr[n+left] = temp[n];
    }
    
}

快速排序

/**快速排序：头尾双指针、比较base值并交换
* 递归：
*/
public void quickSort(int[] arr,int left,int right){
    if(i < j){
        int base = arr[left];
        int i = left;
        int j = right;

        while(left < right){
            while( i<j && arr[j] > base){
                j--;
            }
            if(i < j){
                arr[i++] = arr[j];
            }
            while(i<j && arr[i] < base){
                i++;
            }
            if(i<j){
                arr[j--] = arr[i];
            }
        }
        arr[i] = base;

        //递归调用
        quickSort(arr, left, i-1);
        quickSort(arr ,i+1, right);
    }

}

冒泡排序

/**相邻元素比较，将前一个较大的元素做交换，一趟排序之后，最大的元素沉入数组末尾
*
*/
public void bubbleSort(int[] arr){
    int temp = 0;
    //冒泡的趟数
	for(int i=0; i< arr.lengh-1;i++  ){
        //第i趟中，相邻元素比较
        for(int j=0; j< arr.length-i-1;j++){
            //swap
            if(arr[j+1] < arr[j]){
                int temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

堆排序

/**堆排序
*
*/
public void heapSort(int[] arr){
    int len = arr.length;
   	//构建堆
    bulidMaxHeap(arr);
    
    //调整堆，进行排序
    for(int i = len-1; i > 0;i--){
        swap(arr,0,i);
        len--;
        //调用堆化
        heapify(arr, 0, len);
    }
    
}


/**调整堆，参数arr，i是子树的根节点，len是数组的长度
* 
*/
public void heapify(int[] arr,int i,int len){
    //定义好左右子节点的下标
    int left = 2*i+1;
    int right =2*i+2;
    int large = i;
    
    //将较大的节点的下标赋值给最大小标
    if(left < len && arr[left] > arr[large]){
        large = left;
    }
    if(right < len && arr[right] > arr[large]){
        large = right;
    }
    
    //如果新的较大的值下标，不是最大值得下标，则 交换较大值和最大值
    if( large != i){
        swap(arr,i,large);
        heapify(arr,large,len);//递归调用堆化；
    }
}

public void  bulidMaxHeap(int[] arr,int len){
    for(int j = (int)Math.floor(len/2);i>=0;i--){
        heapify(arr,j,len);
    }
}

//交换元素位置
public void swap(int[] arr,int i,int j){
     int temp = arr[j+1];
     arr[j+1] = arr[j];
     arr[j] = temp;
}