希尔、归并、快速排序

JAVA实现

工具类

package com.wc4cloud.sort;

import java.util.Arrays;
import java.util.Random;
import java.util.stream.IntStream;

/**
 * @author WC
 * @date 2020/5/21
 */
public class Utils {

    /**
     * 生成随机数组
     *
     * @param len 数组长度
     * @param max 数组最大值
     * @return 生成的数组
     */
    public static int[] generatorRandomIntArray(int len, int max) {
        Random random = new Random();
        return IntStream.generate(() -> random.nextInt(max)).limit(len).toArray();
    }

    /**
     * 打印数组,方便比较
     *
     * @param array 需要打印的数组
     */
    public static void printArray(int[] array) {
        System.out.printf("sum:%s, array:%s\n", Arrays.stream(array).sum(), Arrays.toString(array));
    }

}

希尔排序

package com.wc4cloud.sort;

/**
 * 希尔排序
 *
 * @author WC
 * @date 2020/5/21
 */
public class ShellSort {

    public static void main(String[] args) {

        int[] array = Utils.generatorRandomIntArray(20, 100);
        Utils.printArray(array);

        int interval = array.length;
        // 当增量下降为1时,排序成功
        while (interval != 1) {
            // 每次减小一半的增量
            interval /= 2;

            //这里采用插入排序
            for (int i = interval; i < array.length; i++) {
                int temp = array[i];
                int j;
                for (j = i - interval; j >= 0 && array[j] > temp; j -= interval) {
                    array[j + interval] = array[j];
                }
                array[j + interval] = temp;
            }
        }

        Utils.printArray(array);
    }

}

归并排序

package com.wc4cloud.sort;

/**
 * 归并排序
 *
 * @author WC
 * @date 2020/5/22
 */
public class MergeSort {

    public static void main(String[] args) {

        int[] array = Utils.generatorRandomIntArray(10, 50);
        Utils.printArray(array);

        // 定义临时数组,与排序数组保持等长
        int[] tempArray = new int[array.length];
        merge(array, 0, array.length - 1, tempArray);

        Utils.printArray(array);
    }

    public static void merge(int[] array, int start, int end, int[] tempArray) {
        if (start < end) {
            // 数据拆分
            int mid = (start + end) / 2;
            merge(array, start, mid, tempArray);
            merge(array, mid + 1, end, tempArray);

            // 数据合并
            // 定义三个指针,分别为临时数组数据存放的起始位置、左边拆分项的起始位置、右边拆分项的起始位置
            int index = start, low = start, high = mid + 1;
            // 当左右有一项遍历成功后推出
            while (low <= mid && high <= end) {

                //将左右项中最小的一个
                if (array[low] < array[high]) {
                    tempArray[index++] = array[low++];
                } else {
                    tempArray[index++] = array[high++];
                }
            }

            while (low <= mid) {
                tempArray[index++] = array[low++];
            }

            while (high <= end) {
                tempArray[index++] = array[high++];
            }

            for (int i = start; i <= end; i++) {
                array[i] = tempArray[i];
            }
        }
    }
}

快速排序

package com.wc4cloud.sort;

/**
 * 快速排序
 *
 * @author WC
 * @date 2020/5/24
 */
public class QuickSort {

    public static void main(String[] args) {

        int[] array = Utils.generatorRandomIntArray(10, 100);
        Utils.printArray(array);

        sort(array, 0, array.length - 1);

        Utils.printArray(array);
    }

    private static void sort(int[] array, int low, int high) {
        if (high > low) {
            int left = low + 1, right = high;
            while (true) {

                // 左右指针移动
                while (array[right] >= array[low] && right > low) {
                    right--;
                }
                while (array[left] <= array[low] && left < right) {
                    left++;
                }

                // 当左右指针移动到相同位置退出,否则交换指针所在下标的值
                if (left >= right) {
                    break;
                } else {
                    int temp = array[right];
                    array[right] = array[left];
                    array[left] = temp;
                }
            }

            // 指针所在值与首位比较值交换
            int temp = array[low];
            array[low] = array[right];
            array[right] = temp;

            sort(array, low, right - 1);
            sort(array, right + 1, high);
        }
    }
}

golang实现

工具类

package sort

import (
	"fmt"
	"math/rand"
)

//生成随机数组
//len 数组长度
//max 数组中最大值
func generatorRandomArray(len int, max int) []int {

	arr := make([]int, len)
	for i := 0; i < len; i++ {
		arr[i] = rand.Intn(max)
	}
	return arr
}

//打印数组
//arr 需要被打印的数组
func printArray(arr []int) {

	var sum int
	for i := range arr {
		sum += i
	}
	fmt.Printf("sum:%d, array:%v\n", sum, arr)
}

希尔排序

package sort

func shellSort() {

	array := generatorRandomArray(10, 100)
	printArray(array)

	interval := len(array)
	for ; interval != 1; {
		//每次增量下降一半
		interval /= 2

		//这里就是一个直接排序
		for i := interval; i < len(array); i++ {

			tmp := array[i]
			var j int
			for j = i; j >= interval && array[j-interval] > tmp; j -= interval {
				array[j] = array[j-interval]
			}
			array[j] = tmp
		}
	}

	printArray(array)
}

归并排序

package sort

//归并排序
func mergeSort() {

	array := generatorRandomArray(20, 50)
	printArray(array)

	temp := make([]int, len(array))
	merge(array, 0, len(array)-1, temp)

	printArray(array)
}

func merge(array []int, start int, end int, temp []int) {

	if start < end {
		// 数据拆分
		mid := (start + end) / 2
		merge(array, start, mid, temp)
		merge(array, mid+1, end, temp)

		// 数据合并
		index, low, high := start, start, mid+1
		for ; low <= mid && high <= end; {

			if array[low] < array[high] {
				temp[index] = array[low]
				low++
			} else {
				temp[index] = array[high]
				high++
			}
			index++
		}

		for ; low <= mid; {
			temp[index] = array[low]
			index++
			low++
		}
		for ; high <= end; {
			temp[index] = array[high]
			index++
			high++
		}

		for i := start; i <= end; i++ {
			array[i] = temp[i]
		}
	}

}

快速排序

package sort

func quickSort() {
	array := generatorRandomArray(10, 100)
	printArray(array)

	sort(array, 0, len(array)-1)

	printArray(array)
}

func sort(arr []int, low int, high int) {
	if high > low {

		left, right := low+1, high
		for {
			// 左右指针移动
			for ; arr[right] >= arr[low] && right > low; {
				right--
			}
			for ; arr[left] <= arr[low] && left < right; {
				left++
			}

			// 当左右指针移动到相同位置退出,否则交换指针所在下标的值
			if left >= right {
				break
			} else {
				arr[right], arr[left] = arr[left], arr[right]
			}
		}

		// 指针所在值与首位比较值交换
		arr[low], arr[right] = arr[right], arr[low]

		sort(arr, low, right-1)
		sort(arr, right+1, high)
	}
}
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 数字20 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读