数据结构之排序

最新推荐文章于 2024-07-15 17:15:24 发布
最新推荐文章于 2024-07-15 17:15:24 发布
阅读量204 收藏 2
点赞数 2
分类专栏： 算法 文章标签： 数据结构 算法 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_32196893/article/details/119980963
版权

排序的介绍

排序也称排序算法，排序是将一组数据，依指定的顺序进行排列的过程。

排序的分类

在这里插入图片描述

  1. 内部排序：指需要处理的所有数据都加载到内存存储器中进行排序。
  2. 外部排序：由于数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。

算法的时间复杂度

时间频度

一个算法花费的时间与算法中语句的执行次数成正比，哪个算法中语句执行次数多，它花费的时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
随着n的变大，可以忽略：

  1. 常数项可以忽略。如 T(n) = 2n + 20 和 T(n) = 2n。
  2. 低次项可以忽略。如T(n) = n2+3n+10 和 T(n) = n2
  3. 系数可以忽略。如T(n) = 3n2 和 T(n) = 5n2
时间复杂度
  1. 一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示。若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n)/f(n)的极限为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n))为算法的渐进时间复杂度，简称时间复杂度。
  2. T(n)不同，当时间复杂度可能相同。如T(n)=n2+7n+6 与 T(n)=3n2+2n+2它们的T(n)不同 ，但时间复杂度相同，都为O(n2)
  3. 计算时间复杂度的方法：如 T(n)=3n2+2n+2
    1. 用常数1代替运行中的所有加法常数。T(n)=3n2+2n+2 => T(n)=3n2+2n+1
    2. 修改后的函数，只保留最高阶项。T(n)=3n2+2n+1 => T(n)=3n2
    3. 去除最高阶项的系数。T(n)=3n2 => T(n)=n2
常见的时间复杂度

在这里插入图片描述

  1. 常数阶O(1)
  2. 对数阶O(log2n)
  3. 线性阶O(n)
  4. 线性对数阶O(nlog2n)
  5. 平方阶O(n2)
  6. 立方阶O(n3)
  7. k次方阶O(nk)
  8. 指数阶O(2n)
算法的平均时间复杂度和最坏时间复杂度
  1. 平均时间复杂度是指所有可能的输入实例以等概率出现的情况下，该算法的运行时间。
  2. 最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度均是最坏情况下的时间复杂度。这样做的原因是：最坏情况下的时间复杂度是在算法在任何输入实例上运行时间的界限，这就保证了算法的运行时间不会比最坏情况更长。
  3. 平均时间复杂度和最坏时间复杂度是否一致，和算法相关。
排序发平均时间最差情形稳定度额外空间备注
冒泡排序O(n2)O(n2)稳定O(1)n小时，算法效率好
选择排序O(n2)O(n2)不稳定O(1)n小时，算法效率好
插入排序O(n2)O(n2)稳定O(1)大部分已经排好序时，算法效率好
基数排序O(logRB)O(logRB)稳定O(n)B为真数(0~9) R为基数(个十百)
希尔排序O(nlogn)O(ns)(1<s<2)不稳定O(1)n是所选分组
快速排序O(nlogn)O(n2)不稳定O(nlogn)n大时，算法效率较好
归并排序O(nlogn)O(nlogn)稳定O(1)n大时，算法效率较好
堆排序O(nlogn)O(nlogn)不稳定O(1)n大时，算法效率较好

算法空间复杂度

类似于时间复杂度，一个算法的空间复杂度定义 为该算法所耗费的存储空间，它也是问题规模n的函数。

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的度量。有点算法需要占用的临时工作单元与解决问题的规模n有关，它随着n的增大而增大。当n较大时，将占用较多的存储单元。例如快速拍下下和归并排序。

在做算法分析时，主要讨论算法的时间复杂度。从用户体验的角度来看，更看重程序执行的速度。一些缓存产品（redis、memcache）和算法（基数排序）本质上都是空间换时间。

排序算法介绍

冒泡排序
基本介绍

在这里插入图片描述

冒泡排序（Bubble Sorting）的基本思想是：通过从前向后（从下表较小的元素开始）对待排序序列，依次比较相邻元素的值。若发现逆序则交换，使值较大的元素逐渐从前向后移动。就像水底下的气泡一样逐渐向上冒。
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行交换。从而减少不必要的比较。

代码实现
import java.util.Scanner;

public class BubbleSort {

    public static void main(String[] args) {

        int n;
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) {
            arr[i] = scanner.nextInt();
        }
        bbubbleSort(arr);
        print(arr);
    }

    public static void bbubbleSort(int[] arr) {
        boolean flag = false;
        for (int i = 1; i < arr.length; ++i) {
            for (int j = 0; j < arr.length -i; ++j) {
                if (arr[j] < arr[j+1]) {
                    flag = true;
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if (!flag) {
                break;
            }
            flag = false;
        }
    }

    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; ++i) {
            System.out.printf("%d ", arr[i]);
        }
        System.out.println();
    }
}
选择排序
基本介绍

在这里插入图片描述
选择排序也属于内部排序，是从欲排序的数据中，按照指定规则选出来某一元素，再依规定交换位置后达到排序的目的。

选择排序思想

选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：

  1. 第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换；
  2. 第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换；
  3. 第i次从arr[i-1]~arr[n-1]中选择最小值，与arr[i-1]交换；
  4. 直到第n-1次，arr[n-2]~arr[n-1]中选择最小值，与arr[n-2]交换；
  5. 总共经过n-1次，得到一个排序
代码实现
import java.util.Scanner;

public class SelectSort {

    public static void main(String[] args) {

        int n;
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) {
            arr[i] = scanner.nextInt();
        }
        selectSort(arr);
        print(arr);
    }

    public static void selectSort(int[] arr) {

        for (int i =0 ; i < arr.length - 1; ++i) {
            int min = arr[i], k = i;
            for (int j = i + 1; j < arr.length; ++j) {
                if (min > arr[j]) {
                    min = arr[j];
                    k = j;
                }
            }
            if(k != i) {
                arr[k] = arr[i];
                arr[i] = min;
            }
            //print(arr);
        }
    }

    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; ++i) {
            System.out.printf("%d ", arr[i]);
        }
        System.out.println();
    }
}
插入排序
基本介绍

在这里插入图片描述

插入式排序属于内部排序法，是对欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。

插入排序思想

插入排序（Insertion Sorting）的基本思想是：

  1. 把n各待排序的元素看成一个有序表和一个无序表。
  2. 开始时，有序表中只有一个元素，无需表中有n-1个元素。
  3. 排序过程中，每次从无需表中取一个元素，把它放在排序码依次与有序表的排序码进行比较，将它插入到有序表的适当位置，使之成为新的有序表。
代码实现
import java.util.Scanner;

public class InsertionSort {

    public static void main(String[] args) {

        int n;
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) {
            arr[i] = scanner.nextInt();
        }
        insertSort(arr);
        print(arr);
    }

    public static void insertSort(int[] arr) {
        int tmp;
        for(int i = 1; i < arr.length; ++i) {// 外层循环为无序列表
            
            for (int j = i-1; j>=0; j--) { // 内层循环为有序列表
                if (arr[j+1] < arr[j]) {
                    tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                } else {
                    break;
                }
            }
        }
    }

    public static void insertSort2(int[] arr) {

        for(int i = 1; i < arr.length; ++i) {// 外层循环为无序列表
            int insertValue = arr[i];
            int insertIndex = i - 1; // 有序列表的最后一个索引
            while(insertIndex>=0 && insertValue < arr[insertIndex]) {
                arr[insertIndex+1] = arr[insertIndex];
                insertIndex --;
            }
            arr[insertIndex +1] = insertValue;
            // print(arr);
        }
    }

    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; ++i) {
            System.out.printf("%d ", arr[i]);
        }
        System.out.println();
    }
}
希尔排序
基本介绍

在这里插入图片描述

希尔排序时希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序。它是简单插入排序经过改进后的一个更高效的版本，也成为缩小增量排序。

基本思想

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法进行排序；随着增量逐渐减少，每组包含的关键词越来越多。当增量减至1时，整个文件恰好被分成一组，算法便终止。

代码实现
import java.util.Scanner;

public class ShellSort {
    public static void main(String[] args) {

        int n;
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) {
            arr[i] = (int)(Math.random() * 800000);
        }
        long start = System.currentTimeMillis();
         print(arr);
        shellSort(arr);
        System.out.println(System.currentTimeMillis() - start);
        print(arr);
    }

    // 希尔排序　交换法
    public static void shellSort(int[] arr) {

        int gap = arr.length/2;

        while (gap > 0) {
            for (int i = gap; i < arr.length; ++i) {
                for (int j = i - gap; j >= 0; j-=gap) {
                    if (arr[j] > arr[j + gap]) {
                        int temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
            gap = gap/2;
            //print(arr);
        }
    }

    // 希尔排序　移动法
    public static void shellSort2(int[] arr) {
        int gap = arr.length / 2;
        while (gap > 0) {
            for (int i = gap; i < arr.length; ++i) {
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]) {
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    arr[j] = temp;
                }
            }
            gap /= 2;
        }
    }

    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; ++i) {
            System.out.printf("%d ", arr[i]);
        }
        System.out.println();
    }
}
快速排序
基本介绍

在这里插入图片描述
快速排序（QuickSort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割称独立的两部分。其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

代码实现
import java.util.Scanner;

public class QuickSort {

    public static void main(String[] args) {

        int n;
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) {
            arr[i] = (int)(Math.random()*800);
        }
        print(arr);
        quickSort(arr, 0, arr.length-1);
        print(arr);
    }

    public static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int key = arr[left];
            int l = left;
            int r = right;
            while (l < r) {
                while (l < r && arr[r] > key) {
                    r--;
                }
                if (l < r) {
                    arr[l] = arr[r];
                    l++;
                }
                while (l < r && arr[l] < key) {
                    l++;
                }
                if (l < r) {
                    arr[r] = arr[l];
                    r--;
                }
            }
            arr[l] = key;
            quickSort(arr, left, l -1);
            quickSort(arr, l+1, right);
        }

    }

    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; ++i) {
            System.out.printf("%d ", arr[i]);
        }
        System.out.println();
    }
}
归并排序
基本介绍

在这里插入图片描述
归并排序（MergeSort）是利用归并的思想实现的排序方法。该算法采用经典的分治策略（分治法将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的答案“修补”在一起，即分而治之）。

代码实现
import java.util.Scanner;

public class MergeSort {

    public static void main(String[] args) {

        int n;
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) {
            arr[i] = (int)(Math.random()*800);
        }
        print(arr);
        int[] temp = new int[n];
        mergeSort(arr, 0, arr.length-1, temp);
        print(arr);
    }

    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right)/2;
            mergeSort(arr, left, mid, temp);
            mergeSort(arr, mid +1, right, temp);
            merge(arr, left, mid, right, temp);
//            System.out.println(left + " " + mid + " " + right);
//            print(arr);
        }

    }
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int l = left;
        int r = mid+1;
        int t = 0;
        while (l <= mid && r <= right) {
            if (arr[l] <= arr[r]) {
                temp[t++] = arr[l++];
            } else {
                temp[t++] = arr[r++];
            }
        }
        while (l <= mid) {
            temp[t++] = arr[l++];
        }
        while (r <= right) {
            temp[t++] = arr[r++];
        }
        t = 0;
        while (left <= right) {
            arr[left++] = temp[t++];
        }
    }
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; ++i) {
            System.out.printf("%d ", arr[i]);
        }
        System.out.println();
    }
}
基数排序
基本介绍

在这里插入图片描述

  1. 基数排序属于“分配式排序”，又称为“桶子法”或 bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用。
  2. 基数排序法是属于稳定性的排序，基数排序法是高效且稳定的排序算法。
  3. 基数排序是桶排序的扩展。
  4. 基数排序是赫尔曼·何乐礼在1887年发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。
基本思想

将所有待比较的数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成后，数列就变成了一个有序序列。

代码实现
import java.util.Scanner;

public class RadixSort {

    public static void main(String[] args) {

        int n;
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) {
            arr[i] = (int)(Math.random()*80000);
        }
        print(arr);
        // long start = System.currentTimeMillis();
        radixSort(arr);
        // System.out.println(System.currentTimeMillis() - start);
        print(arr);
    }

    public static void radixSort(int[] arr) {

        int max = 0;
        for (int i = 0; i < arr.length; ++i) {
            if (max < Math.abs(arr[i])) {
                max = Math.abs(arr[i]);
            }
        }
        int length = 0;
        do {
            length ++;
            max /= 10;
        }while (max > 0);
        // 定义一个二位数据
        int[][] bucket = new int[10][arr.length];
        int[] bucketCounts = new int[10];

        // 根据尾数，将数据放入相应的桶中
        for (int i = 0, n = 1; i < length; ++i, n*=10) {
            for (int j = 0; j < arr.length; j++) {
                int digtal = arr[j] / n %10;
                bucket[digtal][bucketCounts[digtal]++] = arr[j];
            }
            // 将数据从桶中取出，放入原数组中
            int index = 0;
            for (int j = 0; j < bucketCounts.length; j++) {
                if (bucketCounts[j] != 0) {
                    for (int l = 0; l < bucketCounts[j]; l++) {
                        arr[index++] = bucket[j][l];
                    }
                }
                bucketCounts[j] = 0; // 将桶中记录的元素个数置为0
            }
        }
    }

    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; ++i) {
            System.out.printf("%d ", arr[i]);
        }
        System.out.println();
    }
}
基数排序说明
  1. 基数排序是对传统桶排序的扩展，速度快。
  2. 基数排序是经典的空间换时间的方式，占用内存很大，当对海量数据排序时，容易造成OutOfMemoryError
  3. 基数排序时稳定的排序算法。
堆排序
基本介绍

在这里插入图片描述

  1. 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏、最好、平均时间复杂度都是O(nlogn)，它是不稳定的排序算法。
  2. 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆。注意：没有要求结点的左孩子的值和右孩子的值的大小关系。
  3. 每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。
基本思想
  1. 将待排序的序列构造成一个大顶堆。
  2. 此时，整个序列的最大值就是堆顶的根结点。
  3. 将其与末尾元素进行交互，此时末尾的就为最大值。
  4. 让后将剩余n-1个元素重新构造成一个堆，这样就会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
代码实现
import java.util.Scanner;

public class HeapSort {

    public static void main(String[] args) {

        int n;
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) {
            arr[i] = scanner.nextInt();
        }
        heapSort(arr);
        print(arr);
    }

    public static void heapSort(int[] arr) {
        for (int i = arr.length/2 - 1; i >= 0; i--) { // 调整非叶子节点
            adjustHeap(arr, i, arr.length);
        }

        for (int j = arr.length-1; j > 0; j--) {
            swap(arr, 0, j); // 堆顶元素，和当前元素进行交换
            adjustHeap(arr, 0, j);
        }
    }

    public static void adjustHeap(int[] arr, int i, int length) {

        int temp = arr[i]; // 先取出当前元素

        for (int k = i * 2 + 1; k < length; k = k * 2 +1) { // 从i节点的左子节点开始，也就是2i+1处

            if (k + 1 < length && arr[k] < arr[k+1]) { // 如果左子节点小于右子节点，那么k指向右子节点
                k ++; // k指向的是左右子节点中，值较大的那个节点
            }
            if (arr[k] > temp) { // 如果子节点大于父节点，将子节点值赋给父节点
                arr[i] = arr[k];
                i = k;
            } else {
                break;
            }
        }
        arr[i] = temp; // 将temp值，放到最终位置
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; ++i) {
            System.out.printf("%d ", arr[i]);
        }
        System.out.println();
    }
}
~Rookie~Newbie~Noob~
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode || Sort List
布衣不舍的专栏
03-16 1万+
Sort List  Sort a linked list in O(n log n) time using constant space complexity.         对一个链表进行排序，且时间复杂度要求为 O(n log n) ，空间复杂度为常量。一看到 O(n log n) 的排序，首先应该想到归并排序和快速排序，但是通常我们使用这两种排序方法时都是针对数组的，现在是链
【冷门算法】不增加额外空间，将不带头结点链表递增排序
CS GO
12-12 526
有点点复杂
算法小记（一）
沫_沫的博客
07-23 428
时间复杂度 这里面包含一个时间频度的概念，何为时间频度呢？就是一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。...
算法
渴鱼y. . 。.
07-31 1730
前言 程序 = 数据结构 + 算法 -----> 程序 = 数据结构 + 算法 + 程序设计方法 + 语言和环境 算法是灵魂，来解决“做什么”和“怎么做”的问题 数据结构是加工对象 语言是工具 编程需要采用合适的方法 计算机算法可分为两大类： 数值运算算法：用于求解数值 非数值运算算法：用于事务管理领域 算法是一个从具体到抽象的过程；算法要求能够解决一类问题，而不是一个问...
算法的时间复杂度和空间复杂度-总结
热门推荐
zolalad的专栏
09-20 33万+
算法的时间复杂度和空间复杂度 1、时间复杂度 （1）时间频度 一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(
数据结构之排序及应用（实验）
12-14
数据结构之排序及应用（实验） 一、 排序算法介绍 排序算法是数据结构中非常重要的一部分，它们可以将无序的数据元素转换为有序的数据元素，从而提高数据的存储和检索效率。常见的排序算法有冒泡排序、选择排序、...
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
数据结构之排序课件(与“排序”有关文档共83张).pptx
11-30
数据结构中的排序是计算机科学中一个基础且重要的概念，它涉及到如何有效地组织和处理大量数据。排序算法的主要目标是将一组无序的数据按照特定规则（通常为升序或降序）进行排列。在这个课件中，主要介绍了几种常见...
数据结构排序.docx
04-16
数据结构上机：题目: 排序 输人10个整数，分别用希尔排序、快速排序、直接选择排序和归并排序实现由小到大排序并输出排序结果。
合并排序 数据结构 排序算法
12-22
合并排序 数据结构 排序算法
排序算法（二）希尔排序+归并排序+快速排序+堆排序--O(nlogn)的排序
bob_man的博客
03-15 270
文章目录希尔排序归并排序快速排序堆排序 希尔排序 排序思想：希尔排序可以说是插入排序的一种变种。无论是插入排序还是冒泡排序，如果数组的最大值刚好是在第一位，要将它挪到正确的位置就需要 n - 1 次移动。当原数组的一个元素如果距离它正确的位置很远的话，需要与相邻元素交换多次才能到达正确的位置，这样效率较低。希尔排序就是插入排序排序的一种简单改进，交换不相邻的元素以对数组的局部进行排序，以此来提升...
算法的时间复杂度
cyhgogogo的博客
09-04 1万+
时间复杂度 时间频率  一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为时间频度。记为T(n)。 时间复杂度   在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。 一般情况下，算法中基本操作重复执行的次...
深入浅出了解 时间复杂度，时间频度，空间复杂度
weixin_45829957的博客
07-28 1844
时间频度：一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n) 时间复杂度 1)一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。 .
数据结构与算法：冒泡排序、插入排序、选择排序
天亮了的博客
10-07 1845
排序算法太多了，有很多可能你连名字都没听说过，比如猴子排序、睡眠排序、面条排序等。我只讲众多排序算法中的一小撮，也是最经典的、最常用的：冒泡排序、插入排序、选择排序、归并排序、快速排序、计数排序、基数排序、桶排序。按照时间复杂度把它们分成了三类,本文先分析冒泡、插入、选择三种排序算法 排序算法 时间复杂度 是否基于比较 冒泡、插入、选择 O(n²) √ 快排、归并 O(nlongn) √ 桶、计数、基数 O(n) × 带着问题去学习，是最有效的学习方法。所以按照惯例，我还是先给你
算法题 Day1 时间复杂度
weixin_43332432的博客
01-02 168
转自于 https://zhidao.baidu.com/question/10758328.html 1、时间复杂度 （1）时间频度 一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花...
【算法】算法的时间复杂度计算
墨染百城
06-14 2180
计量单位为了便于比较同一个问题的不同算法，通常的做法是，从算法中选取一种对于所研究的问题（或算法类型）来说是基本操作的原操作，以该基本操作的重复执行的次数作为算法的时间量度。时间频度一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。时间复杂度在刚才提到的时间频度中，n称为问题的规模，当n不断变化时
数据结构--二叉树遍历
最新发布
binhyun的博客
07-15 652
（1）前序遍历 （2）定义结构体 （3）前序遍历实现 （4）中序遍历实现 （5）二叉树的节点个数 （6）二叉树树叶节点个数 （7）二叉树的高度 （8）二叉树节点的开辟 （9）建立一个测试二叉树 （10）测试二叉树相关函数的功能 （11）第k层的数据个数 （12）二叉树里面查找节点
数据结构与排序算法详解
"该资源是一份关于数据结构中排序算法的课件，主要涵盖了内部排序的各种方法，包括插入排序、快速排序、堆排序、归并排序、基数排序，并对各种排序方法进行了综合比较。此外，还讲解了排序的定义、内部排序与外部...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值