Java实现9种常见排序算法

常见的排序算法有冒泡排序、选择排序、插入排序、堆排序、归并排序、快速排序、希尔排序、基数排序、计数排序，下面通过Java实现这些排序

1、冒泡排序

package com.buaa;

import java.util.Arrays;

/**
* @ProjectName SortingAlgorithm
* @PackageName com.buaa
* @ClassName BubbleSort
* @Description 冒泡排序
* @Author 刘吉超
* @Date 2016-05-02 20:52:16
*/
public class BubbleSort {
	/*
	 * 时间复杂度为O(n2)
	 */
	public static void bubbleSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}

		for (int i = arr.length - 1; i >= 0; i--) {
			for (int j = 0; j < i; j++) {
				if (arr[j] > arr[j + 1]) {
					swap(arr, j, j + 1);
				}
			}
		}
	}

	// 元素交换
	public static void swap(int[] arr, int index1, int index2) {
		int tmp = arr[index1];
		arr[index1] = arr[index2];
		arr[index2] = tmp;
	}

	// 生成数组
	public static int[] generateArray(int len, int range) {
		if (len < 1) {
			return new int[0];
		}

		int[] arr = new int[len];

		for (int i = 0; i < len; i++) {
			arr[i] = (int) (Math.random() * range);
		}

		return arr;
	}

	// 是否已经排序好
	public static boolean isSorted(int[] arr) {
		if (arr == null || arr.length < 2) {
			return true;
		}

		for (int i = 1; i < arr.length; i++) {
			if (arr[i - 1] > arr[i]) {
				return false;
			}
		}

		return true;
	}

	public static void main(String[] args) {
		int len = 10;
		int range = 10;

		// 生成序列
		int[] arr = generateArray(len, range);

		System.out.println("排序前：" + Arrays.toString(arr));

		// 判断是否是有序的，如果无序，则进行排序
		if(!isSorted(arr)){
			bubbleSort(arr);
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}
}

2、选择排序

package com.buaa;

import java.util.Arrays;

/**
* @ProjectName SortingAlgorithm
* @PackageName com.buaa
* @ClassName SelectSort
* @Description 选择排序
* @Author 刘吉超
* @Date 2016-05-02 21:10:50
*/
public class SelectSort {
	/*
	 * 时间复杂度为O(n2)
	 */
	public static void selectSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}

		for(int i = arr.length - 1; i >= 0; i--){
			int max = i;
			for(int j = 0;j < i;j++){
				max = arr[j] > arr[max] ? j : max;
			}
			swap(arr, i, max);
		}
	}

	// 元素交换
	public static void swap(int[] arr, int index1, int index2) {
		int tmp = arr[index1];
		arr[index1] = arr[index2];
		arr[index2] = tmp;
	}

	// 生成序列
	public static int[] generateArray(int len, int range) {
		if (len < 1) {
			return null;
		}

		int[] arr = new int[len];
		for (int i = 0; i < len; i++) {
			arr[i] = (int) (Math.random() * range);
		}

		return arr;
	}

	// 判断序列是否有序
	public static boolean isSorted(int[] arr) {
		if (arr == null || arr.length < 2) {
			return true;
		}

		for (int i = 1; i < arr.length; i++) {
			if (arr[i - 1] > arr[i]) {
				return false;
			}
		}

		return true;
	}

	public static void main(String[] args) {
		int len = 10;
		int range = 10;

		// 生成序列
		int[] arr = generateArray(len, range);

		System.out.println("排序前：" + Arrays.toString(arr));

		// 判断是否是有序的，如果无序，则进行排序
		if(!isSorted(arr)){
			selectSort(arr);
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}
}

3、插入排序

package com.buaa;

import java.util.Arrays;

/**
 * @ProjectName SortingAlgorithm
 * @PackageName com.buaa
 * @ClassName InsertionSort
 * @Description 插入排序
 * @author 刘吉超
 * @date 2016-03-05 20:11:48
 */
public class InsertionSort {
	/*
	时间复杂度
		当数据正序时，执行效率最好，每次插入都不用移动前面的元素，时间复杂度为O(N)。
		当数据反序时，执行效率最差，每次插入都要前面的元素后移，时间复杂度为O(N2)。
		所以，数据越接近正序，直接插入排序的算法性能越好。
	空间复杂度
		由插入排序算法可知，我们在排序过程中，需要一个临时变量存储要插入的值，所以空间复杂度为1 。
	算法稳定性
		插入排序的过程中，不需要改变相等数值元素的位置，所以它是稳定的算法。
	 */
	public static void insertionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}

		for (int i = 1; i < arr.length; i++) {
			for (int j = i - 1; j >= 0; j--) {
				if (arr[j] > arr[j + 1]) {
					swap(arr,j,j+1);
				}
			}
		}
	}

        // 元素交换
	public static void swap(int[] arr, int index1, int index2) {
		int tmp = arr[index1];
		arr[index1] = arr[index2];
		arr[index2] = tmp;
	}

	// 生成序列
	public static int[] generateArray(int len, int range) {
		if (len < 1) {
			return new int[0];
		}

		int[] arr = new int[len];

		for (int i = 0; i < len; i++) {
			arr[i] = (int) (Math.random() * range);
		}

		return arr;
	}

	// 判断序列是否有序
	public static boolean isSorted(int[] arr) {
		if (arr == null || arr.length < 2) {
			return true;
		}
		for (int i = 1; i < arr.length; i++) {
			if (arr[i - 1] > arr[i]) {
				return false;
			}
		}
		return true;
	}

	public static void main(String[] args) {
		int len = 10;
		int range = 10;

		// 生成序列
		int[] arr = generateArray(len, range);

		System.out.println("排序前：" + Arrays.toString(arr));

		// 判断是否是有序的，如果无序，则进行排序
		if (!isSorted(arr)) {
			insertionSort(arr);
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}
}

4、堆排序

package com.buaa;

import java.util.Arrays;

/**
* @ProjectName SortingAlgorithm
* @PackageName com.buaa
* @ClassName HeapSort
* @Description 堆排序
* @Author 刘吉超
* @Date 2016-05-03 22:34:47
*/
public class HeapSort {
	// 堆排序
	public static void heapSort(int[] arr){
		// 数组长度
		int length = arr.length;
		// 初始化堆
		int[] heap = Arrays.copyOf(arr, length);

		// 对堆进行调整
		for(int i = (length -1)/2; i >=0; i--){
			process(heap,length,i);
		}

		int index = 0;
		// 输出堆
		while(length > 0){
			// 将排好序的元素弹出
			arr[index++] = heap[0];
			// 末尾元素添加到首部
			heap[0] = heap[length-1];
			// 总个数减一
			length--;
			// 对堆进行调整
			process(heap,length,0);
		}
	}

	/*
	 * 对节点k进行调整
	 * h：堆数据；n：堆数据有效个数；k：待调整节点
	 */
	public static void process(int[] h,int n,int k){
		int k1 = 2*k+1;
		int k2 = 2*k+2;

		// 已经是叶子节点
		if(k1 >= n && k2 >= n)
			return; 

		// 左节点
		int n1 = h[k1];
		// 右节点
		int n2 = k2 < n ? h[k2]:Integer.MAX_VALUE;

		// 已经符合堆的要求
		if(h[k] <= n1 && h[k] < n2)
			return ;

		if(n1 < n2){
			swap(h,k,k1);
			process(h,n,k1);
		}else {
			swap(h,k,k2);
			process(h,n,k2);
		}
	}

	// 元素交换
	public static void swap(int[] arr, int index1, int index2) {
    	int tmp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = tmp;
	}

	// 生成序列
	public static int[] generateArray(int len, int range) {
    	if (len < 1) {
        	return null;
        }

        int[] arr = new int[len];
        for (int i = 0; i < len; i++) {
        	arr[i] = (int) (Math.random() * range);
        }

        return arr;
	}

	// 判断序列是否有序
	public static boolean isSorted(int[] arr) {
    	if (arr == null || arr.length < 2) {
        	return true;
        }

        for (int i = 1; i < arr.length; i++) {
        	if (arr[i - 1] > arr[i]) {
            	return false;
            }
        }

        return true;
	}

	public static void main(String[] args) {
    	int len = 10;
		int range = 10;

		// 生成序列
		int[] arr = generateArray(len, range);

		System.out.println("排序前：" + Arrays.toString(arr));

		// 判断是否是有序的，如果无序，则进行排序
		if(!isSorted(arr)){
			heapSort(arr);
		}

		System.out.print("排序后：" + Arrays.toString(arr));
	}
}

5、归并排序

package com.buaa;

import java.util.Arrays;

/**
* @ProjectName SortingAlgorithm
* @PackageName com.buaa
* @ClassName MergeSort
* @Description 归并排序
* @Author 刘吉超
* @Date 2016-05-02 21:53:54
*/
public class MergeSort {
	// 归并排序
	public static void mergeSort(int[] arr){
		if(arr == null || arr.length < 2){
			return ;
		}

		process(arr,0,arr.length - 1);
	}

	public static void process(int[] arr, int left, int right) {
		if (left == right) {
			return;
		}

		int mid = (left + right) / 2;
		// 左边
		process(arr, left, mid);
		// 右边
		process(arr, mid + 1, right);
		// 归并
		merge(arr, left, mid, right);
	}

	public static void merge(int[] arr, int left, int mid, int right) {
		int[] help = new int[right - left + 1];

		int l = left,r = mid + 1,index = 0;

		while (l <= mid && r <= right) {
			if (arr[l] <= arr[r]) {
				help[index++] = arr[l++];
			} else {
				help[index++] = arr[r++];
			}
		}

		while (l <= mid) {
			help[index++] = arr[l++];
		}

		while (r <= right) {
			help[index++] = arr[r++];
		}

		for (int i = 0; i < help.length; i++) {
			arr[left + i] = help[i];
		}
	}

	// 生成序列
    public static int[] generateArray(int len, int range) {
        if (len < 1) {
            return null;
        }

        int[] arr = new int[len];

        for (int i = 0; i < len; i++) {
        	arr[i] = (int) (Math.random() * range);
        }

        return arr;
	}

	// 判断序列是否有序
	public static boolean isSorted(int[] arr) {
    	if (arr == null || arr.length < 2) {
        	return true;
        }

        for (int i = 1; i < arr.length; i++) {
        	if (arr[i - 1] > arr[i]) {
            	return false;
            }
        }

        return true;
	}

	public static void main(String[] args) {
		int len = 10;
		int range = 10;

		// 生成序列
		int[] arr = generateArray(len, range);

		System.out.println("排序前：" + Arrays.toString(arr));

		// 判断是否是有序的，如果无序，则进行排序
		if (!isSorted(arr)) {
			mergeSort(arr);
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}
}

6、快速排序

package com.buaa;

import java.util.Arrays;

/**
* @ProjectName SortingAlgorithm
* @PackageName com.buaa
* @ClassName QuickSort
* @Description 快速排序
* @Author 刘吉超
* @Date 2016-05-02 22:09:32
*/
public class QuickSort {
	// 快速排序
    public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

        process(arr, 0, arr.length - 1);
    }

    public static void process(int[] arr, int left, int right) {
        if (left < right) {
            int random = left + (int) (Math.random() * (right - left + 1));

            swap(arr, random, right);

            int mid = partition(arr, left, right);
            // 左分区
            process(arr, left, mid - 1);
            // 右分区
            process(arr, mid + 1, right);
        }
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = left - 1;
        int index = left;
        while (index <= right) {
            if (arr[index] <= arr[right]) {
                swap(arr, ++pivot, index);
            }
            index++;
        }
        return pivot;
    }

    // 元素交换
    public static void swap(int[] arr, int index1, int index2) {
        int tmp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = tmp;
    }

	// 生成序列
    public static int[] generateArray(int len, int range) {
        if (len < 1) {
            return null;
        }

        int[] arr = new int[len];
        for (int i = 0; i < len; i++) {
            arr[i] = (int) (Math.random() * range);
        }

        return arr;
    }

    // 判断序列是否有序
    public static boolean isSorted(int[] arr) {
        if (arr == null || arr.length < 2) {
            return true;
        }

        for (int i = 1; i < arr.length; i++) {
            if (arr[i - 1] > arr[i]) {
                return false;
            }
        }

        return true;
    }

    public static void main(String[] args) {
		int len = 10;
		int range = 10;

		// 生成序列
		int[] arr = generateArray(len, range);

		System.out.println("排序前：" + Arrays.toString(arr));

		// 判断是否是有序的，如果无序，则进行排序
		if(!isSorted(arr)){
			quickSort(arr);
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}
}

7、希尔排序

package com.buaa;

import java.util.Arrays;

/**
* @ProjectName SortingAlgorithm
* @PackageName com.buaa
* @ClassName ShellSort
* @Description 希尔排序
* @author 刘吉超
* @date 2016-03-11 11:13:55
*/
public class ShellSort {
	public static void shellSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

        int feet = arr.length / 2;
        int index = 0;

        while (feet > 0) {
            for (int i = feet; i < arr.length; i++) {
                index = i;
                while (index >= feet) {
                    if (arr[index - feet] > arr[index]) {
                        swap(arr, index - feet, index);
                        index -= feet;
                    } else {
                        break;
                    }
                }
            }
            feet /= 2;
        }
    }

    // 元素交换
    public static void swap(int[] arr, int index1, int index2) {
        int tmp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = tmp;
    }

    // 生成序列
    public static int[] generateArray(int len, int range) {
        if (len < 1) {
            return null;
        }

        int[] arr = new int[len];
        for (int i = 0; i < len; i++) {
            arr[i] = (int) (Math.random() * range);
        }

        return arr;
    }

    // 判断序列是否有序
    public static boolean isSorted(int[] arr) {
        if (arr == null || arr.length < 2) {
            return true;
        }

        for (int i = 1; i < arr.length; i++) {
            if (arr[i - 1] > arr[i]) {
                return false;
            }
        }

        return true;
    }

    public static void main(String[] args) {
		int len = 10;
		int range = 10;

		// 生成序列
		int[] arr = generateArray(len, range);

		System.out.println("排序前：" + Arrays.toString(arr));

		// 判断是否是有序的，如果无序，则进行排序
		if(!isSorted(arr)){
			shellSort(arr);
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}
}

8、基数排序

package com.buaa;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

/**
* @ProjectName SortingAlgorithm
* @PackageName com.buaa
* @ClassName RadixSort
* @Description 基数排序
* @Author 刘吉超
* @Date 2016-05-02 22:19:31
*/
public class RadixSort {
	public static void radixSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

        // 负数特殊处理
        int negNum = 0;
        for (int i = 0; i < arr.length; i++) {
            negNum += arr[i] < 0 ? 1 : 0;
        }

        // 负数
        int[] negArr = new int[negNum];
        // 正数
        int[] posArr = new int[arr.length - negNum];

        int negi = 0;
        int posi = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < 0) {
                negArr[negi++] = -arr[i];
            } else {
                posArr[posi++] = arr[i];
            }
        }

        // 负数排序
        radixSortForPositive(negArr);
        // 正数排序
        radixSortForPositive(posArr);

        int index = 0;
        for (int i = negArr.length - 1; i >= 0; i--) {
            arr[index++] = -negArr[i];
        }
        for (int i = 0; i < posArr.length; i++) {
            arr[index++] = posArr[i];
        }
    }

	// 排序
    public static void radixSortForPositive(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

        // 初始化
        List<LinkedList<Integer>> qArr1 = new ArrayList<LinkedList<Integer>>();
        List<LinkedList<Integer>> qArr2 = new ArrayList<LinkedList<Integer>>();
        for (int i = 0; i < 10; i++) {
            qArr1.add(new LinkedList<Integer>());
            qArr2.add(new LinkedList<Integer>());
        }

        // 个位
        for (int i = 0; i < arr.length; i++) {
            qArr1.get(arr[i] % 10).offer(arr[i]);
        }

        // 十位、百位、千位等
        long radix = 10;
        // 用来做计数的,避免无效循环
        int countFlag = 0;

        while (countFlag < arr.length && radix <= Integer.MAX_VALUE) {
        	// 每次执行前，先重置该变量的值为0
        	countFlag = 0;

            for (int i = 0; i < 10; i++) {
                LinkedList<Integer> queue = qArr1.get(i);
                while (!queue.isEmpty()) {
                    int value = queue.poll();
                    int radixValue = (int)(value / radix) % 10;

                    qArr2.get(radixValue).offer(value);

                    // 计数,避免无效循环
                    if(radixValue == 0){
                    	countFlag++;
                    }
                }
            }

            List<LinkedList<Integer>> temp = qArr1;
            qArr1 = qArr2;
            qArr2 = temp;

            radix *= 10;
        }

        // 弹出栈
        int index = 0;
        for (int i = 0; i < 10; i++) {
            LinkedList<Integer> queue = qArr1.get(i);
            while (!queue.isEmpty()) {
                arr[index++] = queue.poll();
            }
        }
    }

    // 生成序列
    public static int[] generateArray(int len, int range) {
        if (len < 1) {
            return null;
        }

        int[] arr = new int[len];
        for (int i = 0; i < len; i++) {
            arr[i] = (int) (Math.random() * range);
        }

        return arr;
    }

    // 判断序列是否有序
    public static boolean isSorted(int[] arr) {
        if (arr == null || arr.length < 2) {
            return true;
        }

        for (int i = 1; i < arr.length; i++) {
            if (arr[i - 1] > arr[i]) {
                return false;
            }
        }

        return true;
    }

    public static void main(String[] args) {
		int len = 10;
		int range = 100;

		// 生成序列
		int[] arr = generateArray(len, range);

		System.out.println("排序前：" + Arrays.toString(arr));

		// 判断是否是有序的，如果无序，则进行排序
		if(!isSorted(arr)){
			radixSort(arr);
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}
}

9、计数排序

package com.buaa;

import java.util.Arrays;

/**
* @ProjectName SortingAlgorithm
* @PackageName com.buaa
* @ClassName CountSort
* @Description 计数排序
* @Author 刘吉超
* @Date 2016-05-02 22:17:22
*/
public class CountSort {
	// 计数排序
	public static void countSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

        // 最大值、最小值
        int min = arr[0],max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            min = Math.min(arr[i], min);
            max = Math.max(arr[i], max);
        }

        // 定义数组
        int[] countArr = new int[max - min + 1];

        for (int i = 0; i < arr.length; i++) {
            countArr[arr[i] - min]++;
        }

        int index = 0;
        for (int i = 0; i < countArr.length; i++) {
            while (countArr[i]-- > 0) {
                arr[index++] = i + min;
            }
        }
    }

	// 元素交换
    public static void swap(int[] arr, int index1, int index2) {
        int tmp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = tmp;
    }

    // 生成序列
    public static int[] generateArray(int len, int range) {
        if (len < 1) {
            return null;
        }

        int[] arr = new int[len];
        for (int i = 0; i < len; i++) {
            arr[i] = (int) (Math.random() * range);
        }

        return arr;
    }

    // 判断序列是否有序
    public static boolean isSorted(int[] arr) {
        if (arr == null || arr.length < 2) {
            return true;
        }

        for (int i = 1; i < arr.length; i++) {
            if (arr[i - 1] > arr[i]) {
                return false;
            }
        }

        return true;
    }

    public static void main(String[] args) {
		int len = 10;
		int range = 10;

		// 生成序列
		int[] arr = generateArray(len, range);

		System.out.println("排序前：" + Arrays.toString(arr));

		// 判断是否是有序的，如果无序，则进行排序
		if(!isSorted(arr)){
			countSort(arr);
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}
}

本文版权归作者和csdn共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

实现代码：下载

时间： 2024-10-12 20:57:38

Java实现9种常见排序算法的相关文章

Java中几种常见排序算法

日常操作中常见的排序方法有:冒泡排序.快速排序.选择排序.插入排序.希尔排序等. 冒泡排序是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端. * 冒泡法排序 * 比较相邻的元素.如果第一个比第二个大,就交换他们两个. * 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应

几种常见排序算法

几种常见排序算法几种常见排序算法写在前面基础介绍初级排序算法 selection sort选择排序 insertion sort插入排序 ShellSort希尔排序 shuffing不是排序算法 merge sort归并排序 Abstract in-place merge原地归并的抽象方法 Top-down mergesort自顶向下的归并排序 Bottom-up mergesort自底向上的归并排序 quicksort 三向切分的快速排序 Heapsort堆排序总结和比较命题本文

JavaScript版几种常见排序算法

今天发现一篇文章讲“JavaScript版几种常见排序算法”,看着不错,推荐一下原文:http://www.w3cfuns.com/blog-5456021-5404137.html 算法描述: * 冒泡排序:最简单,也最慢,貌似长度小于7最优* 插入排序: 比冒泡快,比快速排序和希尔排序慢,较小数据有优势* 快速排序:这是一个非常快的排序方式,V8的sort方法就使用快速排序和插入排序的结合* 希尔排序:在非chrome下数组长度小于1000,希尔排序比快速更快* 系统方法:在forfox下系

Java实现几种常见排序方法

转自:http://www.cnblogs.com/sevenyuan/archive/2009/12/04/1616897.html 日常操作中常见的排序方法有:冒泡排序.快速排序.选择排序.插入排序.希尔排序,甚至还有基数排序.鸡尾酒排序.桶排序.鸽巢排序.归并排序等. 冒泡排序是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经

【转】Java实现几种常见排序方法

http://www.cnblogs.com/sevenyuan/archive/2009/12/04/1616897.html 日常操作中常见的排序方法有:冒泡排序.快速排序.选择排序.插入排序.希尔排序,甚至还有基数排序.鸡尾酒排序.桶排序.鸽巢排序.归并排序等. 冒泡排序是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换

java的几种经典排序算法

排序算法大致有直接插入排序.折半插入排序.Shell排序.归并排序.直接选择排序.堆排序.冒泡排序.快速排序.桶式排序.基数排序等这些种,各个算法都有其优异性,大家不妨自己看看.下面贴上每个算法的简单讲解和实现: 1.直接选择排序(DirectSelectSort):其关键就是对n个数据要进行n-1趟比较,每趟比较的目的就是选择出本趟比较中最小的数据,并将选择出的数据放在本趟中的第一位.实现如下: [java] view plaincopy <span style="font-size:1

几种常见排序算法的总结

下面总结几种常见的排序算法,包括插入排序.选择排序.快速排序.归并排序和堆排序. 时间复杂度: 插入排序选择排序快速排序归并排序堆排序 Ο(n2) Ο(n2) Ο(nlog(n)) Ο(nlog(n)) Ο(nlog(n)) 算法概述: 插入排序:每次从未排好序的数据堆中拿出一个数,插入到已排好序的数据队列的正确位置. 选择排序:每次从未排好序的数据堆中找到最小的数,插入到已排好序的数据队列的头部. 快速排序:以数据堆中的一个数为标准,将数据堆分为小于等于和大于该数的两堆,对于分割后的两

几种常见排序算法的基本介绍,性能分析,和c语言实现

本文介绍7种常见的排序算法,以及他们的原理,性能分析和c语言实现: 为了能够条理清楚,本文所有的算法和解释全部按照升序排序进行首先准备一个元素无序的数组arr[],数组的长度为length,一个交换函数swap, 在main函数中实现排序函数的调用,并输出排序结果: void swap(int*x , int*y) { int temp = *x; *x = *y; *y = temp; } int main() { int arr[] = { 1,8,5,7,4,6,2,3}; int le

php几种常见排序算法

<?php //从时间上来看,快速排序和归并排序在时间上比较有优势,//但是也比不上sort排序,归并排序比较占用内存! $arr = [4,6,1,2,3,89,56,34,56,23,65];/** * 冒泡排序 * 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来. * 走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成 */function BubbleSortq($arr) { $len = count($arr); //设置一个空