排序的第二天_快速排序与归并排序

标签：索引   分治法   快速排序   递归   quicksort   步骤   quic   --   arrays   

排序的第二天_快速排序与归并排序

快速排序

原理:

快速排序,说白了就是给基准数据找其正确索引位置的过程.,其实快速排序的本质就是把基准数大的都放在基准数的右边,把比基准数小的放在基准数的左边,这样就找到了该数据在数组中的正确位置.
??以后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。

按照上诉理论我写的代码如下:

package com.m.suan_pai;


import java.util.Arrays;

public class Test{
   
    public static void main(String[] args) {
        int[] arr = {9, 8, 4, 3, 6, 72, 37};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
	//开始快排
    //left：左指针
    //right：右指针
    public static void quickSort(int [] arr,int left,int right) {
        if(left < right){
            dealPivot(arr,left,right);
            int pivot = right - 1;
            int i = left;
            int j = right-1;

            while(true){
                while (i<right && arr[++i] < arr[pivot]){}
                while (j>left && arr[--j] > arr[pivot]){}

                if(i<j){
                    swap(arr,i,j);
                }else {
                    break;  	//i和j碰撞的情况下，跳出
 
                }
            }

            if(i<right){
                swap(arr,i,right-1);	//交换末尾值
            }
             //分别对子序列进行递归
            quickSort(arr,left,i-1);
            quickSort(arr,i+1,right);

        }
    }
	//获取基准值，并将其放入待排序序列末尾
    public static void dealPivot(int [] arr,int left,int right) {
        int mid = (left+right)/2;

        if(arr[left] > arr[mid]){
            swap(arr,left,mid);
        }
        if(arr[left] > arr[right]){
            swap(arr,left,right);
        }
        if(arr[mid] > arr[right]){
            swap(arr,right,mid);
        }

        swap(arr,mid,right-1);


    }
 	//交换
    public static void swap(int [] arr,int a,int b) {
        int t = arr[a];
        arr[a] = arr[b];
        arr[b] = t;
    }




}

二、归并排序（Merge Sort）

归并排序，是创建在归并操作上的一种有效的排序算法。算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。归并排序思路简单，速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列。

1. 基本思想

归并排序是用分治思想，分治模式在每一层递归上有三个步骤：

• 分解（Divide）：将n个元素分成个含n/2个元素的子序列。
• 解决（Conquer）：用合并排序法对两个子序列递归的排序。
• 合并（Combine）：合并两个已排序的子序列已得到排序结果。

按照上诉理论我写的代码如下:

package com.m.suan_pai;


import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        int[] arr = {9, 8, 4, 3, 6, 72, 37};
        merdeSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void merdeSort(int[] arr) {
        int[] temp = new int[arr.length];
        merdeSort(arr, 0, arr.length - 1, temp);
    }

    public static void merdeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;

			// 分治
            // 通过递归的方式，使左右归并的子树都有序

            // 1.左边归并排序
            merdeSort(arr,left,mid,temp);
			// 2.右边归并排序
            merdeSort(arr,mid+1,right,temp);
			 // 3.合并排序
            combine(arr,left,mid,right,temp);

        }
    }

    public static void combine(int[] arr, int left,int mid ,int right, int[] temp) {
        int index = 0;
        int i = left;
        int j = mid + 1;

        while (i<=mid && j<=right){
            if(arr[i] < arr[j]){
                temp[index++] = arr[i++];
            }else{
                temp[index++] = arr[j++];
            }
        }

        while (i<=mid){
            temp[index++] = arr[i++];
        }
        while(j<=right){
            temp[index++] = arr[j++];
        }

        index = 0;

        while (left <= right){
            arr[left++] = temp[index++];
        }
    }

}

排序的第二天_快速排序与归并排序

标签：索引   分治法   快速排序   递归   quicksort   步骤   quic   --   arrays   

原文地址：https://www.cnblogs.com/k-class/p/13773658.html