记录一下常用的排序算法

非递归快排

void Push(stack<int>& s, int left, int right){
 s.push(left);
 s.push(right);
} 
void norecQsort(vector<int>& nums, int begin, int end){
 stack<int> s;
 Push(s,begin,end);
 while(!s.empty()){
  int r = s.top(); s.pop();
  int l = s.top(); s.pop();
  if(l>=r) continue;
  int mid = singlePartition(nums,l,r);
  Push(s,l,mid-1);
  Push(s,mid+1,r);
 }
}

递归快排

class Solution {
    public void quicksort(int start,int end, int[] nums)
    {
        if(start >= end)
            return;
        int low = start;
        int high = end;
        int mid = nums[low];
        while(low < high)
        {
            while(low < high && nums[high] >= mid)
                high --;
            nums[low] = nums[high];
            while(low < high && nums[low] < mid)
                low ++;
            nums[high] = nums[low];
        }
        nums[low] = mid;
        quicksort(start, low - 1, nums);
        quicksort(low + 1, end, nums);
    }

    public int[] sortArray(int[] nums) {
        quicksort(0, nums.length - 1, nums);
        return nums;
    }
}

2. 堆排

class heap{
    public void heapify_recursion(int[] arr, int i, int n)
    {
        int largest = i; // 将最大元素设置为堆顶元素
        int l = 2 * i + 1; // left = 2*i + 1
        int r = 2 * i + 2; // right = 2*i + 2
        // 如果 left 比 root 大的话
        if (l < n && arr[l] > arr[largest])
            largest = l;
        // I如果 right 比 root 大的话
        if (r < n && arr[r] > arr[largest])
            largest = r;
        if (largest != i)
        {
            swap(arr, i, largest);
            // 递归地定义子堆
            heapify_recursion(arr, largest, n);
        }
    }
    public void heapify(int[] a, int start, int size)
    {
        int temp = a[start];
        for(int k = 2 * start + 1; k < size; k = 2 * k + 1)
        {
            if(k + 1 < size && a[k] < a[k + 1])
            {
                k += 1;
            }
            if(a[k] > temp)
            {
                a[start] = a[k];
                start = k;
            }
            else
                break;
        }
        a[start] = temp;
    }
    public int[] sort(int[] arrays)
    {
     //构建堆
        int n = arrays.length;
        for(int i = n / 2 - 1; i >= 0; i --)
        {
            heapify_recursion(arrays, i, n);
        }
    //每次取出元素后调整堆
        for(int i = n - 1; i > 0; i--)
        {
            swap(arrays, 0, i);
            heapify_recursion(arrays, 0,i);
        }
        return arrays;
    }
    public void swap(int[] a, int i, int j)
    {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

3. 归并排序

import java.util.Arrays;

public class MergerSort {
    public static void merge(int[]a,int low,int mid,int high){
        int []temp = new int[high-low+1];
        int i = low;
        int j = mid+1;
        int k = 0;
        while(i<=mid&&j<=high){
            if(a[i]<a[j]){
                temp[k++] = a[i++];
            }else {
                temp[k++] = a[j++];
            }
        }
        while(i <= mid){
            temp[k++] = a[i++];
        }
        while(j <= high){
            temp[k++] = a[j++];
        }
        for(int k2 = 0;k2<temp.length;k2++){
            a[k2+low] = temp[k2];
        }
    }

    public static void mergeSort(int[] a, int low,int high){
        int mid = (low + high)/2;
        if(low < high){
            mergeSort(a, low, mid);
            mergeSort(a, mid+1, high);
            merge(a, low, mid, high);
            System.out.println(Arrays.toString(a));
        }
    }

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        int a[] = {52,45,77,33,4,5,22,77,43};
        mergeSort(a, 0, a.length-1);
        System.out.println("排序的结果"+Arrays.toString(a));

    }

}

本文使用 mdnice 排版