排序

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

排序


排序是指将集合中的元素按照某种顺序排列的过程。

插入排序

插入排序，一般称为直接插入排序。直接插入排序的基本思想是顺序地把待排序的数据元素按其值的大小插入到已排序数据元素子集合的适当位置。插入排序的时间复杂度为 O(n2)，空间复杂度为 O(1)。

Python 实现插入排序：

def insertionSort(alist):
    for index in range(1, len(alist)):
        currentvalue = alist[index]
        position = index

        while position > 0 and alist[position-1] > currentvalue:
            alist[position] = alist[position-1]
            position = position - 1

        alist[position] = currentvalue
        
alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
insertionSort(alist)
print(alist)

执行结果：

[17, 20, 26, 31, 44, 54, 55, 77, 93]

C 实现插入排序：

#include <stdio.h>

typedef int KeyType;
typedef struct DataType
{
    KeyType key;
}DType;

void insertSort(DType list[], int n)
{
    int i, j;
    DType temp;
    for (int i = 1; i < n; i++)
    {
        temp = list[i];
        j = i;

        while (j > 0 && temp.key < list[j-1].key)
        {
            list[j] = list[j-1];
            j--;
        }
        list[j] = temp;
    }
    
}

int main(int argc, char argv[])
{
    DType alist[9] = {54, 26, 93, 17, 77, 31, 44, 55, 20};
    int i = 0;
    int n = 9;

    insertSort(alist, n);

    for (int i = 0; i < n; i++)
    {
        printf("%d ", alist[i].key);
    }
    printf("\n");
    
    return 0;
}

执行结果：

17 20 26 31 44 54 55 77 93

希尔排序

希尔排序也称递减增量排序（缩小增量排序），它对插入排序做了改进。希尔排序的基本思想是把待排序的数据元素分成若干小组，对同一小组内的数据元素用直接插入法排序；小组的个数逐次减少；当完成了所有数组元素都在一个组内的排序后，排序过程结束。小组并不是连续切分的，而是使用增量 i（有时称作步长）选取所有间隔为 i 的元素组成子小组。

Python 实现希尔排序：

def gapInsertionSort(alist, start, gap):
    for i in range(start+gap, len(alist), gap):
        currentvalue = alist[i]
        position = i

        while position >= gap and alist[position-gap] > currentvalue:
            alist[position] = alist[position-gap]
            position = position -  gap

        alist[position] = currentvalue

def shellSort(alist):
    sublistcount = len(alist) // 2
    while sublistcount > 0:
        for startposition in range(sublistcount):
            gapInsertionSort(alist, startposition, sublistcount)
            print("After increments of size ", sublistcount, "(", startposition, ")"," The list is ", alist)

        sublistcount = sublistcount // 2
        
alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print(alist)
shellSort(alist)

执行结果：

[54, 26, 93, 17, 77, 31, 44, 55, 20]
After increments of size  4 ( 0 )  The list is  [20, 26, 93, 17, 54, 31, 44, 55, 77]
After increments of size  4 ( 1 )  The list is  [20, 26, 93, 17, 54, 31, 44, 55, 77]
After increments of size  4 ( 2 )  The list is  [20, 26, 44, 17, 54, 31, 93, 55, 77]
After increments of size  4 ( 3 )  The list is  [20, 26, 44, 17, 54, 31, 93, 55, 77]
After increments of size  2 ( 0 )  The list is  [20, 26, 44, 17, 54, 31, 77, 55, 93]
After increments of size  2 ( 1 )  The list is  [20, 17, 44, 26, 54, 31, 77, 55, 93]
After increments of size  1 ( 0 )  The list is  [17, 20, 26, 31, 44, 54, 55, 77, 93]

上面的 Python 示例，先为 n/2 个子列表排序，接着为 n/4 个子列表排序。最终，整个列表由基本的插入排序散发排好序。希尔排序的时间复杂度介于 O(n) 和 O(n2) 之间，通过改变增量，比如采用，希尔排序的时间复杂度可以达到 ***O(n3/2)***。

C 语言实现希尔排序：

#include <stdio.h>

typedef int KeyType;
typedef struct DataType
{
    KeyType key;
}DType;

/**
 * 希尔排序
 * list     [IN]待排序数组          [OUT]完成排序后的数组 
 * n        [IN]待排序数组长度
 * d        [IN]希尔增量值数组
 * numOfD   [IN]希尔增量值数组长度
 */
void shellSort(DType list[], int n, int d[], int numOfD)
{
    int i, j, k, m, span;
    DType temp;

    for (m = 0; m < numOfD; m++)
    {
        span = d[m];
        for (k = 0; k < span; k++)
        {
            for ( i = k; i < n-span; i = i+span)
            {
                temp = list[i+span];
                j = i;
                while (j > -1 && temp.key <= list[j].key)
                {
                    list[j+span] = list[j];
                    j = j - span;
                }
                list[j+span] = temp;
            }
        }
    }
    
}

int main(int argc, char argv[])
{
    DType alist[9] = {54, 26, 93, 17, 77, 31, 44, 55, 20};
    int d[3] = {6, 3, 1};
    int i = 0;
    int n = 9;
    int numOfD = 3;

    shellSort(alist, n, d, numOfD);

    for (int i = 0; i < n; i++)
    {
        printf("%d ", alist[i].key);
    }
    printf("\n");

    return 0;
}

执行结果：

17 20 26 31 44 54 55 77 93

希尔算法的空间复杂度为 ***O(1)***。

冒泡排序

利用交换数据元素的位置进行排序的方法称为交换排序。常用的交换排序方法有冒泡排序法和快速排序法（快速排序法是一种分区交换排序方法）。

冒泡排序需要多次遍历列表，它比较相邻的元素，将不合顺序的交换。每一轮遍历都将下一个最大值放到正确的位置上。如果列表有 n 个元素，那么第一轮遍历要比较 n-1 对。第二轮遍历开始时，最大值已经在正确位置上，还剩 n-1 个元素需要排列，也就是要比较 n-2 对。依次类推，给含有 n 个元素的列表排序需要遍历 n-1 论，总的比较次数是前 n-1 个整数之和，即：
f ( n ) = 1 + 2 + 3 + . . . + ( n − 1 ) = ( n − 1 ) 2 + ( n − 1 ) 2 = n 2 − n 2 f(n) = 1 + 2 + 3 + ... + (n-1) = \frac{(n-1)^2+(n-1)}{2} = \frac{n^2-n}{2} f(n)=1+2+3+...+(n−1)=2(n−1)2+(n−1)​=2n2−n​
所以，冒泡算法的时间复杂度是 ***O(n2)***。

Python 实现冒泡算法：

def bubbleSort(alist):
    for passnum in range(len(alist)-1, 0, -1):
        for i in range(passnum):
            if alist[i] > alist[i+1]:
                temp = alist[i]
                alist[i] = alist[i+1]
                alist[i+1] = temp

短冒泡

冒泡排序要遍历列表中未排序的部分，但如果在一轮遍历中没有发生元素交换，证明序列已经有序，可以提前终止排序，这种排序被称作短冒泡。

Python 实现短冒泡算法：

def shortBubbleSort(alist):
    exchanges = True
    passnum = len(alist) - 1
    while passnum > 0 and exchanges:
        exchanges = False
        for i in range(passnum):
            if alist[i] > alist[i+1]:
                exchanges = True
                temp = alist[i]
                alist[i] = alist[i+1]
                alist[i+1] = temp
        passnum = passnum - 1

C 语言实现冒泡算法：

#include <stdio.h>

typedef int KeyType;
typedef struct DataType
{
    KeyType key;
}DType;

void bubbleSort(DType list[], int n)
{
    int i, j, flag = 1;
    DType temp;
    for (i = 0; i < n && flag == 1; i++)
    {
        flag = 0;
        for (j = 0; j < n-1; j++)
        {
            if (list[j].key > list[j+1].key)
            {
                flag = 1;
                temp = list[j];
                list[j] = list[j+1];
                list[j+1] = temp;
            }
        }
    }
}

int main(int argc, char argv[])
{
    DType alist[9] = {54, 26, 93, 17, 77, 31, 44, 55, 20};
    int i = 0;
    int n = 9;

    bubbleSort(alist, n);

    for (int i = 0; i < n; i++)
    {
        printf("%d ", alist[i].key);
    }
    printf("\n");
    
    return 0;
}

执行结果：

17 20 26 31 44 54 55 77 93

冒泡算法的空间复杂度为 ***O(1)***。

选择排序

选择排序在冒泡排序的基础上做了改进，每次遍历元素集合时只做一次交换。选择排序在每次遍历时寻找最大值（或最小值），并在遍历完成之后将它放到正确的位置上。和冒泡排序一样第一次遍历之后，最大（或最小）元素就位，依次类推。和冒泡排序类似，选择排序的时间复杂度也为 O(n2)，空间复杂度为 O(1)。

Python 实现选择排序：

def selectionSort(alist):
    for fillslot in range(len(alist)-1, 0, -1):
        positionOfMax = 0
        for location in range(1, fillslot+1):
            if alist[location] > alist[positionOfMax]:
                positionOfMax = location

            temp = alist[fillslot]
            alist[fillslot] = alist[positionOfMax]
            alist[positionOfMax] = temp

C 实现选择排序：

#include <stdio.h>

typedef int KeyType;
typedef struct DataType
{
    KeyType key;
}DType;

void selectionSort(DType alist[], int n)
{
    int i, j, small;
    DType temp;

    for (i = 0; i < n-1; i++)
    {
        small = i;
        for (j = 0; j < n; j++)
        {
            if (alist[j].key < alist[small].key)
            {
                small = j;
            }
            
            if (small != i)
            {
                temp = alist[i];
                alist[i] = alist[small];
                alist[small] = temp;
            }
        }
    }
}

int main(int argc, char *argv[])
{
    DType alist[9] = {54, 26, 93, 17, 77, 31, 44, 55, 20};
    int i = 0;
    int n = 9;

    selectionSort(alist, n);

    for (int i = 0; i < n; i++)
    {
        printf("%d ", alist[i].key);
    }
    printf("\n");

    return 0; 
}

执行结果：

93 77 55 54 44 31 26 17 20

归并排序

归并排序每次将一个集合一分为二，如果子集合为空或只有一个元素，那么从定义上来说它就是有序的。如果集合不止一个元素，就将集合一分为二，并对两部分都递归调用归并排序。当两部分都有序后，就进行归并（将两个较小的有序列表归并为一个有序列表的过程）这一基础操作。

Python 实现归并排序：

def mergeSort(alist):
    print("Splitting ", alist)
    if len(alist) > 1:
        mid = len(alist) // 2
        lefthaff = alist[:mid]
        righthalf = alist[mid:]

        mergeSort(lefthaff)
        mergeSort(righthalf)

        i = 0
        j = 0
        k = 0
        while i < len(lefthaff) and j < len(righthalf):
            if lefthaff[i] < righthalf[j]:
                alist[k] = lefthaff[i]
                i = i + 1
            else:
                alist[k] = righthalf[j]
                j = j + 1
            k = k + 1
        
        while i < len(lefthaff):
            alist[k] = lefthaff[i]
            i = i + 1
            k = k + 1
        
        while j < len(righthalf):
            alist[k] = righthalf[j]
            j = j + 1
            k = k + 1
        
    print("Merging ", alist)

alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
mergeSort(alist)

执行结果：

Splitting  [54, 26, 93, 17, 77, 31, 44, 55, 20]
Splitting  [54, 26, 93, 17]
Splitting  [54, 26]
Splitting  [54]
Merging  [54]
Splitting  [26]
Merging  [26]
Merging  [26, 54]
Splitting  [93, 17]
Splitting  [93]
Merging  [93]
Splitting  [17]
Merging  [17]
Merging  [17, 93]
Merging  [17, 26, 54, 93]
Splitting  [77, 31, 44, 55, 20]
Splitting  [77, 31]
Splitting  [77]
Merging  [77]
Splitting  [31]
Merging  [31]
Merging  [31, 77]
Splitting  [44, 55, 20]
Splitting  [44]
Merging  [44]
Splitting  [55, 20]
Splitting  [55]
Merging  [55]
Splitting  [20]
Merging  [20]
Merging  [20, 55]
Merging  [20, 44, 55]
Merging  [20, 31, 44, 55, 77]
Merging  [17, 20, 26, 31, 44, 54, 55, 77, 93]

C 语言实现归并排序：

#include <stdio.h>
#include <stdlib.h>

typedef int KeyType;
typedef struct DataType
{
    KeyType key;
}DType;

void merge(DType alist[], int n, DType swap[], int k)
{
    int m = 0;
    int u1, l2, i, j, u2;
    int l1 = 0;

    while (l1+k <= n-1)
    {
        l2 = l1 + k;
        u1 = l2 - 1;
        u2 = (l2+k-1 <= n-1)?l2+k-1:n-1;
        for (i = l1, j = l2; i <= u1 && j <= u2; m++)
        {
            if (alist[i].key <= alist[j].key)
            {
                swap[m] = alist[i];
                i++;
            }
            else
            {
                swap[m] = alist[j];
                j++;
            }
        }
        
        while (i <= u1)
        {
            swap[m] = alist[i];
            m++;
            i++;
        }
        
         while (j <= u2)
        {
            swap[m] = alist[j];
            m++;
            j++;
        }

        l1 = u2 + 1;
    }
    
    for (i = l1; i < n; i++, m++)
    {
        swap[m] = alist[i];
    }
}

void mergeSort(DType alist[], int n)
{
    int i;
    int k = 1;
    DType *swap;

    swap = (DType *)malloc(sizeof(DType)*n);
    while (k < n)
    {
        merge(alist, n, swap, k);
        for (i = 0; i < n; i++)
            alist[i] = swap[i];
        k = 2 * k;
    }
    free(swap);
}

int main(int argc, char argv[])
{
    DType alist[9] = {54, 26, 93, 17, 77, 31, 44, 55, 20};
    int i = 0;
    int n = 9;
    
    mergeSort(alist, n);
    
    for (int i = 0; i < n; i++)
    {
        printf("%d ", alist[i].key);
    }
    printf("\n");

    return 0;
}

执行结果：

17 20 26 31 44 54 55 77 93

归并算法的时间复杂度为 O(nlogn)，空间复杂度为 O(n)。

快速排序

快速排序也称为基数排序，其基本思想是：设元素集合 list 中存放了 n 个数据元素，low 为 list 的低端下标，height 为 list 的高端下标，从 list 中任取一个元素（通常为集合的第一个元素 list[low]）作为基准值，然后调整 list 中各个元素的位置，使排在标准值前面元素的值均小于标准值，排在标准值后面元素的值均大于或等于标准元值（再最终的有序集合中，基准值的位置通常被称作分割点，算法在分割点切分集合，以进行对快速排序的子调用）。在这样一次过程结束后，以标准值元素为中心，分为两个子集合。然后再对这两部分递归调用快速排序。递归算法的结束条件是 height ⩽ low，即上界下标小于或等于下界下标。

Python 实现快速排序：

def partition(alist, first, last):
    pivotvalue = alist[first]

    leftmask = first + 1
    rightmask = last
    done = False

    while not done:
        while leftmask <= rightmask and alist[leftmask] <= pivotvalue:
            leftmask = leftmask + 1

        while alist[rightmask] >= pivotvalue and rightmask >= leftmask:
            rightmask = rightmask - 1

        if rightmask < leftmask:
            done = True
        else:
            temp = alist[leftmask]
            alist[leftmask] = alist[rightmask]
            alist[rightmask] = temp

    temp = alist[first]
    alist[first] = alist[rightmask]
    alist[rightmask] = temp

    return rightmask

def quickSortHelper(alist, first, last):
    if first < last:
        splitpoint = partition(alist, first, last)
        
        quickSortHelper(alist, first, splitpoint-1)
        quickSortHelper(alist, splitpoint+1, last)

def quickSort(alist):
    quickSortHelper(alist, 0, len(alist)-1)

Python 快速排序示例：

alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
quickSort(alist)
print(alist)

执行结果：

[17, 20, 26, 31, 44, 54, 55, 77, 93]

C 语言实现快速排序：

#include <stdio.h>
#include <stdlib.h>

typedef int KeyType;
typedef struct DataType
{
    KeyType key;
}DType;

void quickSort(DType alist[], int low, int high)
{
    int i = low, j = high;
    DType temp = alist[low];

    while (i < j)
    {
        while (i < j && temp.key <= alist[j].key)
        {
            j--;
        }

        if (i < j)
        {
            alist[i] = alist[j];
            i++;
        }
            
        while (i < j && alist[i].key < temp.key)
        {
            i++;
        }
                
        if (i < j)
        {
            alist[j] = alist[i];
            j--;
        }
    }
    alist[i] = temp;
    if (low < i)
        quickSort(alist, low, i-1);
    if (i < high)
        quickSort(alist, j+1, high);
}

int main(int argc, char argv[])
{
    DType alist[9] = {54, 26, 93, 17, 77, 31, 44, 55, 20};
    int i = 0;
    int n = 9;
    int low = 0;
    int high = 8;
    
    quickSort(alist, low, high);
    
    for (int i = 0; i < n; i++)
    {
        printf("%d ", alist[i].key);
    }
    printf("\n");

    return 0;
}

执行结果：

17 20 26 31 44 54 55 77 93

最好的情况下，快速排序的时间复杂度为 O(nlogn)，最坏的情况（分割点不在列表中部，而是偏向某一端）下时间复杂度为 O(n2)。最坏的情况下，快速排序的空间复杂度为 O(n)。

为了避免最坏的情况，可以使用三数取中法避免切分不均匀，即在选择基准值时考虑集合的头元素、中间元素与尾元素，然后取它们的中间值。比如：alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]中先选取 54、77 和 20，然后取中间值 54。

二流人物
关注
专栏目录
堆排序详细图解（通俗易懂）
oorik的博客
02-17 24万+
什么是堆 堆是一种叫做完全二叉树的数据结构，可以分为大根堆，小根堆，而堆排序就是基于这种结构而产生的一种程序算法。 堆的分类 大根堆:每个节点的值都大于或者等于他的左右孩子节点的值 小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值 两种结构映射到数组为: 大根堆: 小根堆: //父-->子:i--->左孩子:2*i+1, 右孩子:2*i+2; //子-->父:i--->(i-1)*2;(i为下标元素) 排序思想 1.首先将待排序的数...
冒泡排序（超详细）
hcz666的博客
06-11 38万+
1、什么是冒泡排序？ 冒泡排序的英文Bubble Sort，是一种最基础的交换排序。之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。 冒泡排序的原理： 每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，第二趟只能将倒数第 2 位上的数归位，依次类推下去。如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。 而 “每一趟 ” 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面
排序——排序的基本概念
05-25 1843
1，排序的一般定义： 1，排序是计算机内经常进行的一种操作，其目的是将一组“无序”的数据元素调整为“有序”的数据元素； 2，无序到有序就是排序； 2，排序的数学定义： 1，假设含 n 个数据元素序列为{R1, R2, ..., Rn}，其相应的关键字序列为{K1, K2, ..., Kn}，这些关键字相互之间可以进行比...
排序的定义
amf12345的博客
08-23 1552
排序，就是重新排列表中的元素，使表中的元素满足按关键字递增或递减的过程。为了查找方便，通常要求计算机中的表是按关键字有序的。排序的确切定义如下： 输入：n个记录R1 R2……Rn，对应的关键字为K1 K2……Kn。 输出：输入序列的一个重排：R1‘R2’……Rn‘，使得K1'<=K2'<=……<=Kn'，（其中，“<="可以换算成其他的比较大小的符号） 算法的稳定...
排序 —— 排序的基本概念
starter_____的博客
06-26 1369
什么是排序？ 将一组杂乱无章的数据按一定的规律顺次排列起来。排序的目的是便于查找。 排序算法的好坏如何衡量？ 时间效率： 排序速度（即排序所花费的全部比较次数） 空间效率： 占内存辅助空间的大小 稳定性： 若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称此排序算法是稳定的。 内部排序和外部排序 内部排序： 若待排序记录都在内存中，称为内部排序。 内部排序基本操作有两种： ...
考研复习之数据结构笔记（十六）排序（上）（基本概念与概述、插入排序、交换排序）
欢迎交流！
07-22 625
每次将一个待排序的记录，按关键字的大小插入到已排好序的子序列中的适当位置，直到全部记录插入完毕为止。希尔排序可提高排序速度，因为关键字较小的记录跳跃式前移，在进行最后一趟dt=1的插入排序时，序列已基本有序。两两比较待排序记录的关键值，交换不满足顺序要求的记录，直到全部满足顺序要求为止。（1）排序定义将一个数据元素(或记录)的任意序列，重新排列成一个按关键字有序的序列。子序列的构成不是简单的“逐段分割”，而是将相隔某个增量的记录组成一个子序列。图2.3-1希尔排序算法演示。......
关于排序的问题
m0_58181298的博客
08-25 90
冒泡排序 public static void bubbleSort(int[] array) { //冒泡排序 //按照每次找最小进行排序（从后往前交换） for (int bound=0;bound< array.length;bound++){ //[0,bound)已排序区间；[bound,size)已排序区间 for (int cur= array.length-1;cur>bo
快速排序法（详解）
热门推荐
小白的博客
07-01 58万+
假设对以下10个数进行快速排序： 6 1 2 7 9 3 4 5 10 8 我们先模拟快速排序的过程：首先，在这个序列中随便找一个数作为基准数，通常为了方便，以第一个数作为基准数。 6 1 2 7 9 3 4 5 10 8 在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位...
python数组排序方法详解（sort， sorted，argsort）
什么都干的派森
09-27 7万+
这三个排序方法应对日常工作基本够用 先说一下三者的区别 sort， sorted 是用在 list 数据类型中的排序方法 argsort 是用在 numpy 数据类型中的排序方法（ numpy 里也有一个 sort 方法，下面会讲） sort 和 sorted 的区别如下???? 先看两个简单的升序排序，分别使用 sorted 和 sort 方法 # sorted num_list = [1, 8, 2, 3, 10, 4, 5] ordered_list = sorted(num_list) print
插入排序、归并排序、堆排序和快速排序的稳定性分析
最新发布
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-28 2011
在计算机科学中，排序是将一组数据按照特定顺序进行排列的过程。排序算法的效率和稳定性是评价其优劣的两个重要指标。稳定性指的是在排序过程中，相等的元素在排序后保持原有的相对顺序。本文将详细分析插入排序、归并排序、堆排序和快速排序这四种常见排序算法的稳定性，并通过浅显易懂的语言进行解释。
排序算法详解
qq_43185543的博客
07-19 420
一.冒泡排序 冒泡排序的基本思想是：通过对待排序序列从前向后(从下标较小的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大大元素逐渐从前一移向后部，就像水底的气泡向上冒着。 import java.util.Arrays; public class BubbleSort1 { public static void main(String[] args) { // 正冒 int[]...
排序学习
anRanKong的博客
03-23 120
文章目录归并排序快速排序 分治：把一个任务，分成形式和原任务相同，但规模更小的几个部分任务，分别完成。 归并排序 数组排序任务可如下完成： 把前一半排序 把后一半排序 把两个归并到一个新的有序数组，然后再拷贝回原数组 #include<iostream> using namespace std; void Merge(int a[], int s, int m, int e, int tmp[]) {// 将数组a的局部a[s,m]和a[m+1,e]合并到tmp，并保证tmp有序，然后再拷
排序算法详细介绍
qq_42003546的博客
08-01 209
1排序算法 1.0排序算法说明 排序的定义 对一序列对象根据某个关键字进行排序 术语说明 稳定 ：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定 ：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后- 面； 内排序 ：所有排序操作都在内存中完成； 外排序 ：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行； 时间复杂度 ： 一个算法执行所耗费的时间。 空间复杂度 ：运行完一个程序所需内存的大小。 各种算法的通俗理解！ 贪心算法： 从左到右，两两互换，
基本排序算法
qq_35809292的博客
10-23 239
排序（sorting）是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列重新排序成一个按关键字有序的序列。再待排序的文件中，若存在多个关键字相同的记录，经排序后，这些具有相同关键字的记录之间的相对次序保持不变，该排序方法是稳定的；若具有相同关键字的记录之间的相对次序发生变化，则称这种排序方法是不稳定的。 查找（searching）根据给定的某个值，在查找表（一个数据集合）中确定一个其关键字等于给定值的记录或数据元素。 一、基本排序算法 1.1 ...
实现集合List中的元素进行排序
小哥的专栏
06-14 26万+
Collections对List集合中的数据进行排序 有时候需要对集合中的元素按照一定的规则进行排序，这就需要用到 Java中提供的对集合进行操作的工具类Collections，其中的sort方法 先看一个简单的例子： public static void main(String[] args) { List nums = new ArrayList(); nums.
如何对List集合中的元素进行排序？
海粟先生
01-04 1万+
Collections对List集合中的数据进行排序
数据结构复习（排序）
努力的程序员
06-02 5377
选择题 在具有n个元素的序列中进行查找，平均查找长度为O(n)的方法是( )。 A 顺序查找方法 B 散列查找方法 C 分块查找方法 D 树形查找方法 顺序查找方法的优点之一是( )。 A 对于被查找对象几乎没有限制 B 适合排序连续顺序文件的查找 C 适合链接顺序文件的查找 D 查找时间效率高 对线性表采用折半查找，该线性表必须( )。 A 元素按值有序排列 B 采用顺序结构 C 元素按值有序排列，并且采用顺序存储结构 D 元素按值有序排列，并且采用链式存储结构 冒泡排序某一趟移动记录次数很少，说明( )
排序算法详解：内部排序与外部排序
"这篇文档详细介绍了各种排序算法，包括排序的定义、稳定性和不同类型的排序方法，如插入排序、交换排序、选择排序、归并排序、分配排序以及外部排序等。文档强调了排序的基本思想、性能分析以及各种排序算法的特点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

二流人物

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值