常见算法
Posted shmilychan
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了常见算法相关的知识，希望对你有一定的参考价值。
常用排序算法的时间复杂度和空间复杂度
| 排序法 | 最差时间分析 | 平均时间复杂度 | 稳定度 | 空间复杂度 |
|---|---|---|---|---|
| 冒泡排序 | O(n2) | O(n2) | 稳定 | O(1) |
| 快速排序 | O(n2) | O(n∗log2n) | 不稳定 | O(log2n) ~ O(n) |
| 选择排序 | O(n2) | O(n2) | 稳定 | O(1) |
| 归并排序 | O(nlog(n)) | O(nlog(n)) | 看情况 | O(n) |
| 插入排序 | O(n2) | O(n2) | 稳定 | O(1) |
| 堆排序 | O(n∗log2n) | O(n∗log2n) | 不稳定 | O(1) |
| 希尔排序 | 0 | 不稳定 | O(1) | |
| 基数排序 | O(d(n+r)) | O(d(n+r)) | 稳定 | O(n+r) |
备注：在基数排序中，r为基数，d为位数
1.冒泡排序
冒泡排序（Bubble Sort）是先从数组第一个元素开始，依次比较相邻两个数，若前者比后者大，就将两者交换位置，然后比较下一对，不断扫描数组，知道完成排序。
package com.czl.Algorithm;
public class BubbleSort {
static void bubble_sort(int[] unsorted){
int count = 0;//使用count计数，循环次数
//外层循环，数组下标从0开始，length-1
for (int i = 0; i < unsorted.length-1; i++){
//内层循环,实现两两比较，把较大的放在前面
for (int j = 0; j < unsorted.length-1-i; j++){
if (unsorted[j] > unsorted[j+1]){
int temp = unsorted[j];
unsorted[j] = unsorted[j+1];
unsorted[j+1] = temp;
}
count++;
}
}
System.out.println(count);
}
public static void main(String[] args){
int[] x={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,
99,98,54,56,17,18,23,34,15,35,25,53,51};
bubble_sort(x);
for (int i = 0; i < x.length; i++) {
System.out.print(x[i]+" ");
}
}
}2.快速排序
快速排序是随机挑选一个元素，对数组进行分割，以将所有比它小的元素排在前面，比它大的元素排在后面。具体分割操作见下面代码 。
算法步骤：
1 从数列中挑出一个元素，称为 “基准”（pivot）。
2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
package com.czl.Algorithm;
public class QuickSort {
static void quickSort(int[] arr,int left,int right){
int index = partition(arr, left, right);
if (left < index - 1) {//排序左半部分
quickSort(arr, left, index - 1);
}
if (index < right) {//排序右半部分
quickSort(arr, index, right);
}
}
static int partition(int[] arr,int left,int right){
int pivot = arr[(left + right)/2];//找到一个基准点
while (left <= right) {
//找到左边中应被放到右边的元素
while(arr[left] < pivot){
left++;
}
//找到右边中应被放到左边的元素
while (arr[right] > pivot) {
right--;
}
//交换元素，同时调整左右索引值
if (left <= right) {
//交换元素
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
return left;
}
public static void main(String[] args) {
int[] x = {49,38,65,97,76,13,27,49,78,34,12,64,5,4,
62,99,98,54,56,17,18,23,34,15,35,25,53,51};
quickSort(x, 0, x.length-1);
for (int i = 0; i < x.length; i++) {
System.out.print(x[i]+" ");
}
}
}
3.选择排序
选择排序（Slection Sort），简单而低效，线性逐一扫描数组元素，从而找到最小的元素，将它移到首位，如此循环操作，直到完成排序。
package com.czl.Algorithm;
public class SlectionSort {
public static void selectSort(int[]a){
int minIndex=0;
int temp=0;
if((a==null)||(a.length==0)){
return;
}
for(int i=0;i<a.length-1;i++){
minIndex=i;//无序区的最小数据数组下标
for(int j=i+1;j<a.length;j++){
//在无序区中找到最小数据并保存其数组下标
if(a[j]<a[minIndex]){
minIndex=j;
}
}
if(minIndex!=i){
//如果不是无序区的最小值位置不是默认的第一个数据，则交换之。
temp=a[i];
a[i]=a[minIndex];
a[minIndex]=temp;
}
System.out.print(a[i]+" ");
}
}
public static void main(String[] args) {
int[] x={49,38,65,97,76,13,27,49,78,34,12,64,
5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
selectSort(x);
}
}
4.归并排序
归并排序是将数组分成两半，这两半分别排序后，再归并在一起。排序某一半时，继续沿用同样的算法，最终，归并两个只含一个元素的数组。这个算法的重点是归并。
算法步骤：
1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针达到序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾
package com.czl.Algorithm;
import java.util.Arrays;
public class MergeSort {
static void mergesort(int[] arr,int low,int high){
if (low < high) {
int middle = (low + high)/2;
mergesort(arr, low, middle);//排序左半部分
mergesort(arr, middle + 1, high);//排序右半部分
merge(arr, low, middle, high);//归并
}
}
static void merge(int[] arr,int low,int middle,int high){
int[] temp = new int[arr.length];
//将数组左右两半拷贝到temp数组中去
for (int i = low; i <= high; i++) {
temp[i] = arr[i];
}
int tempLeft = low;
int tempRight = middle + 1;
int current = low;
/*
* 迭代访问temp数组。比较左右两半的元素，
* 并将比较小的元素复制到原来的数组中。
*/
while (tempLeft <= middle && tempRight <= high) {
if (temp[tempLeft] < temp[tempRight]) {
arr[current++] = temp[tempLeft++];
}else {//如果右边的元素小于左边的元素
arr[current++] = temp[tempRight++];
}
}
/*
* 将数组左半部分剩余元素复制到目标数组中
*/
int remaining = middle - tempLeft;
for (int i = 0; i <= remaining; i++) {
arr[current + i] = temp[tempLeft + i];
}
}
public static void main(String[] args) {
int[] x={49,38,65,97,76,13,27,49,78,34,12,64,5,4};
MergeSort.mergesort(x, 0, x.length-1);
System.out.println(Arrays.toString(x));
}
}
5.直接插入排序
插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。
package com.czl.Algorithm;
public class InsertSort {
public static void insertSort(int[] list) {
// 打印第一个元素
System.out.format("i = %d:\\t", 0);
printPart(list, 0, 0);
// 第1个数肯定是有序的，从第2个数开始遍历，依次插入有序序列
for (int i = 1; i < list.length; i++) {
int j = 0;
int temp = list[i]; // 取出第i个数，和前i-1个数比较后，插入合适位置
// 因为前i-1个数都是从小到大的有序序列，所以只要当前比较的数(list[j])比temp大，就把这个数后移一位
for (j = i - 1; j >= 0 && temp < list[j]; j--) {
list[j + 1] = list[j];
}
list[j + 1] = temp;
System.out.format("i = %d:\\t", i);
printPart(list, 0, i);
}
}
// 打印序列
public static void printPart(int[] list, int begin, int end) {
for (int i = 0; i < begin; i++) {
System.out.print("\\t");
}
for (int i = begin; i <= end; i++) {
System.out.print(list[i] + "\\t");
}
System.out.println();
}
public static void main(String[] args) {
int[] x={49,38,65,97,76,13,27,49,78,34,12,64,
5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
InsertSort.insertSort(x);
for (int i = 0; i < x.length; i++) {
System.out.print(x[i] + " ");
}
}
}6.堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
堆排序的平均时间复杂度为Ο(nlogn) 。
算法步骤：
创建一个堆H[0..n-1]
把堆首（最大值）和堆尾互换
3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置
4. 重复步骤2，直到堆的尺寸为1
package com.czl.Algorithm;
public class HeapSort {
private static int[] sort = { 49,38,65,97,76,13,27,49,78,34,12,
64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
public static void main(String[] args) {
buildMaxHeapify(sort);
heapSort(sort);
print(sort);
}
private 以上是关于常见算法的主要内容，如果未能解决你的问题，请参考以下文章