常用排序算法总结（代码）

概述

稳定的排序算法：

1. 冒泡排序
2. 插入排序
3. 归并排序
4. 桶排序

不稳定的排序算法：

1. 选择排序
2. 希尔排序
3. 堆排序
4. 快速排序

各算法时间复杂度以及空间复杂度：

冒泡算法

冒泡排序可用于当数据已经基本有序，且数据量较小时

public static void bubblesort(int[] arr) {
		int temp = 0;
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					temp = arr[j + 1];
					arr[j + 1] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}

选择排序

当数据规模较小时，选择排序性能较好

public static void selectsort(int[] arr) {
		int n = arr.length;
		for (int i = 0; i < n; i++) {
			int k = i;
			// 找出最小值的下标
			for (int j = i + 1; j < n; j++) {
				if (arr[j] < arr[k]) {
					k = j;
				}
			}
			// 将最小值放到未排序记录的第一个位置
			if (k > i) {
				int tmp = arr[i];
				arr[i] = arr[k];
				arr[k] = tmp;
			}
			for (int l = 0; l < arr.length; l++)
				System.out.print(arr[l] + " ");
			System.out.println();
		}
	}

插入排序

若数组基本有序且数据规模较小时，选用插入排序较好

public static void insertSort(int[] arr) {
		int temp = 0;
		int i, j;
		for (i = 1; i < arr.length; i++) {
			if (arr[i] < arr[i - 1]) {
				temp = arr[i];
				for (j = i; j > 0 && temp < arr[j - 1]; j--) {
					arr[j] = arr[j - 1];
				}
				arr[j] = temp;
			}
		}

	}

希尔排序

数据量较小且基本有序时

public static void shellsort(int arr[]) {
		int n = arr.length;
		if (n <= 1)
			return;
		int gapNum = n / items;
		while (gapNum >= 1) {
			for (int i = 0; i < n; i++) {
				for (int j = i; j < n - gapNum; j = j + gapNum) {
					if (arr[j] > arr[j + gapNum]) {
						int temp = arr[j];
						arr[j] = arr[j + gapNum];
						arr[j + gapNum] = temp;
					}
				}
			}
			gapNum = gapNum / items;
		}
	}

桶排序

int findMax(int a[],int n)//找最大值
{
	int max = a[0];
	for (int i = 1; i < n;i++)
	{
		if (a[i]>max)
		{
			max = a[i];
		}
	}
	return max;
}
void bucket(int a[],int n)//桶排序
{
	//建立一个数组并且清空它
	int max = findMax(a,n);
	int *bucket = new int[max+1];
	memset(bucket,0,sizeof(int)*(max+1));
	//把原数组的数据放到新建立的数组中
	for (int i = 0; i < n;i++)
	{
		bucket[a[i]]++;
	}
	//把桶里的数据由小到大输出出来
	int j = 0;
	for (int i = 0; i <= max;i++)
	{
		while (bucket[i]-->0)//易错
		{
			a[j++] = i;
		}
	}
}

归并排序

数据量较大且要求排序稳定

public static void merge(int[] arr, int start, int mid, int end) {
		int[] temp = new int[arr.length];
		int i = start, j = mid + 1, k = start;
		while (i <= mid && j <= end) {
			if (arr[i] <= arr[j])
				temp[k++] = arr[i++];
			else
				temp[k++] = arr[j++];
		}
		while (i <= mid)
			temp[k++] = arr[i++];
		while (j <= end)
			temp[k++] = arr[j++];
		for (int l = start; l <= end; l++)
			arr[l] = temp[l];
	}

	public static void mergesort(int[] arr, int start, int end) {
		if (start < end) {
			int mid = (start + end) / 2;
			mergesort(arr, start, mid);
			mergesort(arr, mid + 1, end);
			merge(arr, start, mid, end);
		}
	}

快速排序

快速排序适合处理大量数据排序时的场景

public static void quicksort(int[] arr, int start, int end) {
		if (start < end) {
			int index = partition(arr, start, end);
			quicksort(arr, start, index - 1);
			quicksort(arr, index + 1, end);
		}
	}

	private static int partition(int[] arr, int start, int end) {
		int flag = arr[start];
		int i = start, j = end;
		while (i < j) {
			while (i < j && arr[j] >= flag)
				j--;
			if (i < j)
				arr[i++] = arr[j];
			while (i < j && arr[i] <= flag)
				i++;
			if (i < j)
				arr[j--] = arr[i];
		}
		arr[i] = flag;
		return i;
	}

堆排序

堆排序适合处理数据量大的情况，数据呈流式输入时用堆排序也很方便

 /**
     * 创建堆，
     * @param arr 待排序列
     */
    private static void heapSort(int[] arr) {
        //创建堆
        for (int i = (arr.length/2)-1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr, i, arr.length);
        }

        //调整堆结构+交换堆顶元素与末尾元素
        for (int i = arr.length - 1; i > 0; i--) {
            //将堆顶元素与末尾元素进行交换
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;

            //重新对堆进行调整
            adjustHeap(arr, 0, i);
        }
    }

    /**
     * 调整堆
     * @param arr 待排序列
     * @param parent 父节点
     * @param length 待排序列尾元素索引
     */
    private static void adjustHeap(int[] arr, int parent, int length) {
        //将temp作为父节点
        int temp = arr[parent];
        //左孩子
        int lChild = 2 * parent + 1;

        while (lChild < length) {
            //右孩子
            int rChild = lChild + 1;
            // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
            if (rChild < length && arr[lChild] < arr[rChild]) {
                lChild++;
            }

            // 如果父结点的值已经大于孩子结点的值，则直接结束
            if (temp >= arr[lChild]) {
                break;
            }

            // 把孩子结点的值赋给父结点
            arr[parent] = arr[lChild];

            //选取孩子结点的左孩子结点,继续向下筛选
            parent = lChild;
            lChild = 2 * lChild + 1;
        }
        arr[parent] = temp;
    }