算法-快速排序（go+java实现）

快速排序

Java实现

package com.lxm.study.algorithm.sort;

import java.util.Arrays;

/**
 * 功能描述: 快速排序， 选择数组中某个数作为基数，
 * 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数都比基数小，
 * 另外一部分的所有数都都比基数大，然后再按此方法对这两部分数据分别进行快速排序，循环递归，最终使整个数组变成有序。
 *
 * @author luxiaomeng
 * @date 2021/8/5 15:27
 * @修改日志：
 */
public class QuickSort {
    public static void main(String[] args) {
        Integer[] num = {5,5, 3, 1, 2, 9,5};
//        Integer[] num = {2, 2, 2, 2, 2};
        System.out.println(Arrays.toString(num));
        quickSort(num, 0, num.length - 1);
        System.out.println(Arrays.toString(num));
    }


    public static void quickSort(Comparable[] arr, int start, int end) {
        if (start > end) {
            return;
        }
        //将开始位置的索引作为基数
        int pivot = (int)arr[start];
        int i = start;
        int j = end;
        while (i<j) {
            // 从右边找到开始找，找到小于等于基数的数字的索引位置
            while ((i<j)&&((int)arr[j]>pivot)) {
                j--;
            }
            // 从左侧找到开始找，找到大于于等于基数的数字的索引位置
            while ((i<j)&&((int)arr[i]<pivot)) {
                i++;
            }
            // 考虑了相等的情况，两者会一直交换无法退出，可以手动给左侧挪动一位
            if ((arr[i]==arr[j])&&(i<j)) {
                i++;
            } else {
                int temp = (int)arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        System.out.println(Arrays.toString(arr));
        }
        // 此时i的左侧，所有的数字小于等于基数
        // 此时j的右侧侧，所有的数字大于等于基数
        System.out.println(Arrays.toString(arr));
        //再将左侧右侧分开单独进行快排
        quickSort(arr,start,i-1);
        quickSort(arr,j+1,end);
    }
}

Go实现

package main

import "fmt"

/*
   快速排序： 以第一个元素为基准，将 小于该元素的全部放到该元素的左侧，大于该元素的放到该元素的右侧
         然后将左侧的数据和右侧的数据，再这样处理

*/
func QuickSort(arr []int, _left, _right int) {
   //arr := []int{5,1, 3, 2, 6, 4, 9, 8, 7}
   //             5,4,3,2,6,1,9,8,7
   //             5,4,3,2,1,6,9,8,7
   if _left > _right {
      return
   }
   base := arr[_left] // 基准
   left := _left
   right := _right
   for left < right {
      // 从右侧往左侧找小于基准数字的索引
      for left < right && arr[right] > base {
         right--
      }
      // 从左侧侧往右侧找大于基准数字的索引
      for left < right && arr[left] < base {
         left++
      }
      if left < right && arr[left] == arr[right] {
         left++
      } else {
         arr[left], arr[right] = arr[right], arr[left]
      }
      fmt.Println(arr)
   }
   QuickSort(arr, _left, left-1)
   QuickSort(arr, right+1, _right)

}