王道数据结构源码实战ch8排序

最新推荐文章于 2024-06-01 23:49:10 发布
最新推荐文章于 2024-06-01 23:49:10 发布
阅读量183 收藏
点赞数
分类专栏： 王道数据结构源码实战 文章标签： 数据结构 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45601540/article/details/125681631
版权

王道数据结构源码实战ch8排序

插入排序

在这里插入图片描述

直接插入排序

//直接插入排序
void InsertSort(Elemtype A[],int n)
{
    int j;
    for(int i=2; i<=n; i++)  //i=0处用来放哨兵
    {
        A[0]=A[i];
        for(j=i-1; A[0]<A[j]; j--) //不按下标来控制，只看元素大小
        {
            A[j+1]=A[j];
        }
        A[j+1]=A[0];
    }
}

折半插入排序

//折半插入排序
void HalfInsertSort(Elemtype A[],int n)
{
    int i,j,low,mid,high;
    for(int i=2; i<=n; i++)  //i=0处用来放哨兵
    {
        A[0]=A[i];
        low=1;
        high=i-1;
        while(low<=high)
        {
            mid=(low+high)/2;
            if(A[mid]>A[0])
                high=mid-1;
            else
                low=mid+1;
        }
//如果没有找到相等的元素，那么最后high会到low的左边或者low跑到high的右边，high的右边都是更大的元素，low的左边都是更小的元素
//如果找到了相等的元素，由于这里没有return，只会发生low跑到high的右边才会退出循环，此时high指向相等的元素，只有high+1右移，稳定性也能得到保证
        for(j=i-1; j>=high+1; j--) //high+1非常妙
        {
            A[j+1]=A[j];
        }
        A[j+1]=A[0];
    }
}

希尔排序

在这里插入图片描述

//希尔排序
//先写出插入排序，然后外面套一个缩减步长的循环，并且把所有的步长1换成dk
void ShellSort(Elemtype A[],int n)
{
    int j; //必须在外面定义，因为最后一步需要把哨兵放回j+dk位置
    for(int dk=n/2; dk>=1; dk/=2) //dk为步长  //步长为1时退化为插入排序
    {
        for(int i=dk+1; i<=n; i++) //以dk为步长进行插入排序
        {
            A[0]=A[i];  //设置哨兵
            for(j=i-dk; j>0&&A[0]<A[j]; j-=dk) //步长较大时，比较时可能会直接越界
                A[j+dk]=A[j];
            A[j+dk]=A[0];
        }
    }
}

交换排序

冒泡排序

在这里插入图片描述

//冒泡排序
//可以从后开始把小的元素前移，也可以从前开始把大的元素后移
void BubbleSort(Elemtype A[],int n)
{
    bool flag;   //用flag来观察一趟排序中有没有交换元素，如果没有，说明序列已经有序
    for(int i=0; i<n-1; i++) //第i轮表示已经有i个元素已经冒泡了,进行n-1轮，最后一个元素不用排了
    {
        flag=false;   //使用flag可以在序列有序时（在某一轮中，没有进行交换），提前结束程序
        for(int j=n-1; j>i; j--) //i=j不能取，因为后面会访问A[j-1],取了就越界了。代入i=0看一下就知道了（j-1最终冒到最上面=0，那么j最小=1）
            if(A[j-1]>A[j])
            {
                swap(A[j-1],A[j]);
                flag=true;
            }
        if(flag==false)
            return;  //某一轮中，没有一次交换，说明序列已经有序，可以提前结束
    }
}

快速排序

在这里插入图片描述

//挖坑法分割，只能low和high交替填坑（不能一边连续找两个大于或小于pivot的元素）
int Partition1(Elemtype A[],int low,int high)
{
    Elemtype pivot=A[low];
    while(low<high)
    {
        while(low<high&&A[high]>pivot)   //因为默认low为pivot，所以从high开始找元素填空
            high--;
        A[low]=A[high];
        while(low<high&&A[low]<pivot)   //为什么内层要重复判断low<high，因为在内层循环过程中，随时可能提前结束
            low++;
        A[high]=A[low];
    }
    A[low]=pivot;   //此时high=low,用哪个下标都行
    return low;  //把已经定位的元素小标传出来，用来划分下一轮子区间
}

//遍历法分割，比较简单(以最右边元素为pivot)
int Partition2(Elemtype A[],int low,int high)
{
    int left=low;   //只用来指向小于pivot的元素
    for(int i=low; i<high; i++) //遍历pivot后面所有元素
    {
        if(A[i]<A[high])   //i始终比left走的快，所以不会产生left和i指向两个小于pivot的元素，导致小的元素遗留在右边
        {
            swap(A[i],A[left]);    //每找到一个小于pivot的元素，与left处交换（可以保证left前面所有元素都是小于pivot的，left和i之间所有元素都是大于pivot的）
            left++;
        }
    }
    swap(A[left],A[high]);   //最后，把pivot放到应该在的位置
    return left;
}


//快速排序主函数
void QuickSort(Elemtype A[],int low,int high)
{
    if(low<high) //分割到子区间只有一个元素为止
    {
        Elemtype pivot=Partition2(A,low,high);
        QuickSort(A,low,pivot-1);
        QuickSort(A,pivot+1,high);
    }
}

选择排序

简单选择排序

在这里插入图片描述

//简单选择排序
void SelectSort(Elemtype A[],int n)
{
    for(int i=0; i<n-1; i++) //执行完n-1轮，最大的元素已经在最后一个位置
    {
        int min=A[i];           //假设第i个元素为当前轮的最小元素
        int index=i;
        for(int j=i+1; j<n; j++)
        {
            if(A[j]<min)
            {
                min=A[j];
                index=j;
            }
        }
        if(A[i]!=A[index])
            swap(A[i],A[index]);
    }
}

堆排序

在这里插入图片描述

//调整一个元素为根的子树为大根堆
void HeadAdjust(int A[],int k,int n)
{
    A[0]=A[k];  //暂存根节点
    for(int i=2*k; i<=n; i*=2) //寻找子树中最大的节点
    {
        if(i<n&&A[i]<A[i+1])  //如果当前节点有右孩子，且右孩子比左孩子大，选择右孩子向上
            i++;
        if(A[0]>=A[i])   //当前节点是最大的，不需要调整
            break;
        else             //当前节点不是最大的，A[i]向上调整
        {
            A[k]=A[i];
            k=i;           //为了进入下一轮循环，检查被调整上来的节点是否满足大根堆要求
        }
    }
    A[k]=A[0];   //最后的下坠位置
}

//建立大根堆
void BuildMaxHeap(int A[],int n)  //时间复杂度O(n)
{
    for(int i=n/2; i>0; i--)        //想下往上处理非叶子节点
        HeadAdjust(A,i,n);          //而对于每个子树，小元素从上往下下坠
}

//堆排序主函数，每趟把堆顶元素与待排序序列最后一个元素交换
void HeapSort(int A[],int n)
{
    BuildMaxHeap(A,n);
    for(int i=n; i>1; i--)
    {
        swap(A[i],A[1]);  //把堆顶元素和堆底元素交换（逻辑上把当前最大的元素排除在堆外）
        HeadAdjust(A,1,i-1); //恢复剩余元素为大根堆，（1号元素为根，i-1个元素）
    }
}

归并排序

在这里插入图片描述

//二路归并过程
int *B=new Elemtype[50]; //辅助空间
void Merge(Elemtype A[],int low,int mid,int high)  //[low,mid]和[mid+1,high]内部是有序的，把这两个区间进行二路归并
{
    int i,j,k;
    for(k=low; k<=high; k++) //把A数组复制一份到B
        B[k]=A[k];
    for(i=low,j=mid+1,k=i; i<=mid&&j<=high; k++) //只有有一个区间元素走完，跳出循环
    {
        if(B[i]<=B[j])
            A[k]=B[i++];
        else
            A[k]=B[j++];
    }
    while(i<=mid)
        A[k++]=B[i++];
    while(j<=high)
        A[k++]=B[j++];
}


//归并排序主函数
void MergeSort(int A[],int low,int high)
{
    if(low<high)
    {
        int mid=(low+high)/2;
        MergeSort(A,low,mid);
        MergeSort(A,mid+1,high);
        Merge(A,low,mid,high);   //起到排序作用的是Merge函数
    }
}

基数排序

在这里插入图片描述

外部排序

在这里插入图片描述

算法性能比较和其他

算法最好平均最差空间复杂度稳定性
直接插入排序O(n)O(n2)O(n2)O(1)稳定
冒泡排序O(n)O(n2)O(n2)O(1)稳定
简单选择排序O(n2)O(n2)O(n2)O(1)不稳定
希尔排序O(n1.3) -O(n2)O(n2)O(1)不稳定
快速排序O( n l o g 2 n nlog_2n nlog2​n)O( n l o g 2 n nlog_2n nlog2​n)O( n 2 n^2 n2)O( l o g 2 n log_2n log2​n)不稳定
堆排序O( n l o g 2 n nlog_2n nlog2​n)O( n l o g 2 n nlog_2n nlog2​n)O( n l o g 2 n nlog_2n nlog2​n)O(1)不稳定
二路归并排序O( n l o g 2 n nlog_2n nlog2​n)O( n l o g 2 n nlog_2n nlog2​n)O( n l o g 2 n nlog_2n nlog2​n)O(n)稳定
基数排序O(d(n+r))O(d(n+r))O(d(n+r))O( r )稳定

Python中封装的接口是归并
C++封装的接口是快拍
Java封装的接口是快排&&堆排

完整代码

#include<bits/stdc++.h>
using namespace std;
typedef int Elemtype;
typedef struct SSTable
{
    Elemtype *elem;  //线性表起始位置
    int TableLen; //元素个数
} SSTable;

//随机生成线性表用来测试
void ST_init(SSTable &ST,int len)
{
    ST.TableLen=len;
    ST.elem=(Elemtype*)malloc(sizeof(Elemtype)*ST.TableLen);
    srand(time(NULL));  //随机生成0-99的元素
    for(int i=0; i<ST.TableLen; i++)
        ST.elem[i]=rand()%100;
}

//打印下标从0开始的数组
void ST_print(SSTable ST)
{
    for(int i=0; i<ST.TableLen; i++)
        cout<<ST.elem[i]<<" ";
    cout<<endl;
}

//打印带哨兵的数组(从下标1开始)
void ST_print2(SSTable ST)
{
    for(int i=1; i<=ST.TableLen; i++)
        cout<<ST.elem[i]<<" ";
    cout<<endl;
}

//交换两个元素
void swap(Elemtype &a,Elemtype &b)
{
    Elemtype temp;
    temp=a;
    a=b;
    b=temp;
}


//直接插入排序
void InsertSort(Elemtype A[],int n)
{
    int j;
    for(int i=2; i<=n; i++)  //i=0处用来放哨兵
    {
        A[0]=A[i];
        for(j=i-1; A[0]<A[j]; j--) //不按下标来控制，只看元素大小
        {
            A[j+1]=A[j];
        }
        A[j+1]=A[0];
    }
}

//折半插入排序
void HalfInsertSort(Elemtype A[],int n)
{
    int i,j,low,mid,high;
    for(int i=2; i<=n; i++)  //i=0处用来放哨兵
    {
        A[0]=A[i];
        low=1;
        high=i-1;
        while(low<=high)
        {
            mid=(low+high)/2;
            if(A[mid]>A[0])
                high=mid-1;
            else
                low=mid+1;
        }
//如果没有找到相等的元素，那么最后high会到low的左边或者low跑到high的右边，high的右边都是更大的元素，low的左边都是更小的元素
//如果找到了相等的元素，由于这里没有return，只会发生low跑到high的右边才会退出循环，此时high指向相等的元素，只有high+1右移，稳定性也能得到保证
        for(j=i-1; j>=high+1; j--) //high+1非常妙
        {
            A[j+1]=A[j];
        }
        A[j+1]=A[0];
    }
}

//希尔排序
//先写出插入排序，然后外面套一个缩减步长的循环，并且把所有的步长1换成dk
void ShellSort(Elemtype A[],int n)
{
    int j; //必须在外面定义，因为最后一步需要把哨兵放回j+dk位置
    for(int dk=n/2; dk>=1; dk/=2) //dk为步长  //步长为1时退化为插入排序
    {
        for(int i=dk+1; i<=n; i++) //以dk为步长进行插入排序
        {
            A[0]=A[i];  //设置哨兵
            for(j=i-dk; j>0&&A[0]<A[j]; j-=dk) //步长较大时，比较时可能会直接越界
                A[j+dk]=A[j];
            A[j+dk]=A[0];
        }
    }
}

//冒泡排序
//可以从后开始把小的元素前移，也可以从前开始把大的元素后移
void BubbleSort(Elemtype A[],int n)
{
    bool flag;   //用flag来观察一趟排序中有没有交换元素，如果没有，说明序列已经有序
    for(int i=0; i<n-1; i++) //第i轮表示已经有i个元素已经冒泡了,进行n-1轮，最后一个元素不用排了
    {
        flag=false;   //使用flag可以在序列有序时（在某一轮中，没有进行交换），提前结束程序
        for(int j=n-1; j>i; j--) //i=j不能取，因为后面会访问A[j-1],取了就越界了。代入i=0看一下就知道了（j-1最终冒到最上面=0，那么j最小=1）
            if(A[j-1]>A[j])
            {
                swap(A[j-1],A[j]);
                flag=true;
            }
        if(flag==false)
            return;  //某一轮中，没有一次交换，说明序列已经有序，可以提前结束
    }
}

//以下三个函数均为快速排序的组成部分
//挖坑法分割，只能low和high交替填坑（不能一边连续找两个大于或小于pivot的元素）
int Partition1(Elemtype A[],int low,int high)
{
    Elemtype pivot=A[low];
    while(low<high)
    {
        while(low<high&&A[high]>pivot)   //因为默认low为pivot，所以从high开始找元素填空
            high--;
        A[low]=A[high];
        while(low<high&&A[low]<pivot)   //为什么内层要重复判断low<high，因为在内层循环过程中，随时可能提前结束
            low++;
        A[high]=A[low];
    }
    A[low]=pivot;   //此时high=low,用哪个下标都行
    return low;  //把已经定位的元素小标传出来，用来划分下一轮子区间
}

//遍历法分割，比较简单(以最右边元素为pivot)
int Partition2(Elemtype A[],int low,int high)
{
    int left=low;   //只用来指向小于pivot的元素
    for(int i=low; i<high; i++) //遍历pivot后面所有元素
    {
        if(A[i]<A[high])   //i始终比left走的快，所以不会产生left和i指向两个小于pivot的元素，导致小的元素遗留在右边
        {
            swap(A[i],A[left]);    //每找到一个小于pivot的元素，与left处交换（可以保证left前面所有元素都是小于pivot的，left和i之间所有元素都是大于pivot的）
            left++;
        }
    }
    swap(A[left],A[high]);   //最后，把pivot放到应该在的位置
    return left;
}

//快速排序主函数
void QuickSort(Elemtype A[],int low,int high)
{
    if(low<high) //分割到子区间只有一个元素为止
    {
        Elemtype pivot=Partition2(A,low,high);
        QuickSort(A,low,pivot-1);
        QuickSort(A,pivot+1,high);
    }
}


//简单选择排序
void SelectSort(Elemtype A[],int n)
{
    for(int i=0; i<n-1; i++) //执行完n-1轮，最大的元素已经在最后一个位置
    {
        int min=A[i];           //假设第i个元素为当前轮的最小元素
        int index=i;
        for(int j=i+1; j<n; j++)
        {
            if(A[j]<min)
            {
                min=A[j];
                index=j;
            }
        }
        if(A[i]!=A[index])
            swap(A[i],A[index]);
    }
}

//以下三个函数为堆排序的组成部分
//调整一个元素为根的子树为大根堆
void HeadAdjust(int A[],int k,int n)
{
    A[0]=A[k];  //暂存根节点
    for(int i=2*k; i<=n; i*=2) //寻找子树中最大的节点
    {
        if(i<n&&A[i]<A[i+1])  //如果当前节点有右孩子，且右孩子比左孩子大，选择右孩子向上
            i++;
        if(A[0]>=A[i])   //当前节点是最大的，不需要调整
            break;
        else             //当前节点不是最大的，A[i]向上调整
        {
            A[k]=A[i];
            k=i;           //为了进入下一轮循环，检查被调整上来的节点是否满足大根堆要求
        }
    }
    A[k]=A[0];   //最后的下坠位置
}

//建立大根堆
void BuildMaxHeap(int A[],int n)  //时间复杂度O(n)
{
    for(int i=n/2; i>0; i--)        //想下往上处理非叶子节点
        HeadAdjust(A,i,n);          //而对于每个子树，小元素从上往下下坠
}

//堆排序主函数，每趟把堆顶元素与待排序序列最后一个元素交换
void HeapSort(int A[],int n)
{
    BuildMaxHeap(A,n);
    for(int i=n; i>1; i--)
    {
        swap(A[i],A[1]);  //把堆顶元素和堆底元素交换（逻辑上把当前最大的元素排除在堆外）
        HeadAdjust(A,1,i-1); //恢复剩余元素为大根堆，（1号元素为根，i-1个元素）
    }
}

//以下两个函数为归并排序的组成部分
//二路归并过程
int *B=new Elemtype[50]; //辅助空间
void Merge(Elemtype A[],int low,int mid,int high)  //[low,mid]和[mid+1,high]内部是有序的，把这两个区间进行二路归并
{
    int i,j,k;
    for(k=low; k<=high; k++) //把A数组复制一份到B
        B[k]=A[k];
    for(i=low,j=mid+1,k=i; i<=mid&&j<=high; k++) //只有有一个区间元素走完，跳出循环
    {
        if(B[i]<=B[j])
            A[k]=B[i++];
        else
            A[k]=B[j++];
    }
    while(i<=mid)
        A[k++]=B[i++];
    while(j<=high)
        A[k++]=B[j++];
}
//归并排序
void MergeSort(int A[],int low,int high)
{
    if(low<high)
    {
        int mid=(low+high)/2;
        MergeSort(A,low,mid);
        MergeSort(A,mid+1,high);
        Merge(A,low,mid,high);   //起到排序作用的是Merge函数
    }
}


int main()
{
    SSTable ST;
    Elemtype A[10]= {64,94,95,79,69,84,18,22,12,78}; //使用固定数据
    Elemtype B[11]= {0,64,94,95,79,69,84,18,22,12,78}; //使用固定数据(有哨兵的情况使用）
    memcpy(ST.elem,A,sizeof(A));  //整型和浮点型不能用strcpy,strcpy遇0会结束，而memcpy可以按内存大小来复制
    ST.TableLen=10;
    //ST_init(ST,10);   //使用随机生成数据

    cout<<"原始序列："<<endl;
    ST_print(ST);

    cout<<"冒泡排序结果："<<endl;
    BubbleSort(A,10);
    memcpy(ST.elem,A,sizeof(A));
    ST_print(ST);

    cout<<"快速排序结果："<<endl;
    QuickSort(A,0,9);
    memcpy(ST.elem,A,sizeof(A));
    ST_print(ST);

    cout<<"插入排序结果："<<endl;
    InsertSort(B,10);
    memcpy(ST.elem,B,sizeof(B));
    ST_print2(ST);

    cout<<"折半插入排序结果："<<endl;
    HalfInsertSort(B,10);
    memcpy(ST.elem,B,sizeof(B));
    ST_print2(ST);

    cout<<"希尔排序结果："<<endl;
    ShellSort(B,10);
    memcpy(ST.elem,B,sizeof(B));
    ST_print2(ST);

    cout<<"简单选择排序结果："<<endl;
    SelectSort(A,10);
    memcpy(ST.elem,A,sizeof(A));
    ST_print(ST);

    cout<<"堆排序结果："<<endl;
    HeapSort(B,10);
    memcpy(ST.elem,B,sizeof(B));
    ST_print2(ST);

    cout<<"归并序结果："<<endl;
    MergeSort(A,0,9);
    memcpy(ST.elem,A,sizeof(A));
    ST_print(ST);
    return 0;
}
WYF19999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
考研王道数据结构代码.zip
11-26
里面是2020王道数据结构课后习题可执行代码。https://blog.csdn.net/qq_40285036 可以参考这个博客一起学习。
王道考研数据结构PPT
01-12
王道考研数据结构PPT
王道数据结构.zip
05-13
王道考研数据结构2019、2020pdf，无水印
2024 王道数据结构 代码习题部分 第八章 排序
weixin_56638583的博客
09-19 175
必须注意的是，表中所有待排序的关键码互不相同，计数排序算法针对表中的每个记录，扫描待排序的表一趟，统计表中有多少个记录的关键码比该记录的关键码小，假设针对某个记录统计出的计数值为c，则这个记录在新有序表中的合适存放位置即为c。7.[2016]已知由n(n>=2)个正整数构成的集合A={ak|0<=k<n}，将其划分为两个不相交的子集A1和A2，元素个数分别是n1和n2，A1和A2中的元素之和分别为S1和S2。现要求将Kn放在将元素排序后的正确位置上，试编写实现该功能的算法，要求比较关键字的次数不超过n。
【王道数据结构】排序算法代码完整版
致力于成为一名data scientist 的奋斗者
07-27 687
【代码】【王道数据结构】排序算法代码完整版。
数据结构-王道-排序
weixin_34290352的博客
09-26 805
排序 关于排序算法的视频演示 直接插入排序 从上面的插入排序思想中，不难得到一种简单直接的插入排序算法。假设待排序表在某次过程中属于这种情况。 |有序序列\(L[1\ldots i-1]\)|L(i)|无序序列\(L[i+1\ldots n]\)| |:-|:-| 为了实现将元素\(L(i)\)插入到已有序的子序列\(L[1\ldots i-1]\)中，我们需要执行...
王道数据结构源码实战自学-栈（c++版）
希望可以给你点帮助
07-10 329
王道数据结构源码实战自学-栈（c++版） 适合有一定语言基础的数据结构初学者
王道数据结构【查找排序】部分代码实现（C语言）
年少的勇气已经用完，剩下的就是三思而后行
07-27 738
王道数据结构【查找排序】部分代码实现（C语言）
王道数据结构代码实现（C++）
lljjhh001的博客
09-01 3706
数据结构-线性表【顺序表+单链表+双链表】C++代码+详细程序流程图
王道数据结构与算法代码（与书本伪代码统一）有思维导图逐句注解 持续更新
个人博客地址https://sun98k.github.io/
08-03 3421
本文以王道23版本数据结构与算法书本伪代码为基础进行编写 内容仅供参考，配有个人编写代码辅助思维导图，有部分地方为个人理解，如果发现理解有偏差或者有误欢迎评论区指正，谢谢大家。 ...
王道考研——数据结构PPT.zip
08-21
王道考研——数据结构PPT.zip
王道数据结构课后选填汇总
02-19
数据结构复习使用，方便二刷数据结构选填使用
【王道数据结构课后习题代码练习完整版】顺序表
致力于成为一名data scientist 的奋斗者
05-06 1170
设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置交换，若找不到，则将其插入表中并使表中元素仍递增有序。,am）和(b1,b2,…2.2.3-3 对长度为n的顺序表L，编写一个时间复杂度为o(n),空间复杂度为o(1)的算法，该算法删除线性表中所有值为x的元素。2.2.3-4 从有序顺序表中删除其值在s与t之间（s
【数据结构】-排序-折半插入排序
vector的博客
06-29 1105
直接插入排序的序列特点是：有序序列+待插入元素+无序序列 分为两个步骤：1，查找插入位置。2，排序 既然是在有序序列中查找插入位置，因此可以想到用折半查找来寻找插入位置来减少数据比较的次数。 注意： 1.并不是在任何情况下，折半插入排序都比直接插入排序的比较次数要少，在序列已经有序的情况下，直接插入排序只要比较一次即可，而折半插入要比较多次。 2.虽然降低了比较的次数，但是移动的次数并没有发生改变，而带来时间复杂度的主要因素还是移动，因此，这般插入排序的实际按复杂度依然和直接插入排序的时间复杂度相
基本排序算法
fine_ape的博客
05-31 403
文章目录插入排序直接插入排序折半插入排序希尔排序交换排序冒泡排序快速排序选择排序简单选择排序堆排序构造初始堆输出堆顶元素并调整堆归并排序和基数排序归并排序基数排序外部排序多路平衡归并与败者树置换-选择排序最佳归并树 插入排序 插入排序的思想是：每次将一个待排序的记录按其关键字大小，插入前面已经排好的子序列，直到全部记录插入完成。 由插入排序的思想可以引申出三个排序算法： 直接插入排序 折半插入排序 希尔排序 直接插入排序 假设在排序过程中，待排序表L[1…n]在某次排序过程中的某一时刻状态如下：
【王道数据结构课后练习完整代码】第七章 查找----二叉排序树
致力于成为一名data scientist 的奋斗者
07-23 177
7.3.4-10 设计一个算法，从大到小输出二叉排序树中所有值不小于k的关键字。7.3.4-8 利用二叉树遍历的思想编写一个判别二叉树是否是平衡二叉树的算法。7.3.4-9 设计一个算法，求出给定二叉排序树中最小和最大的关键字。
二叉树及其在C语言中的实现A
最新发布
2301_79642159的博客
06-01 129
本文介绍了二叉树的基本概念、特性以及在C语言中的实现方式。通过定义二叉树节点的结构体，我们可以轻松地实现二叉树的插入、遍历等操作。二叉树作为数据结构的重要组成部分，对于理解树形结构、递归算法等方面都有着重要意义。更多实现在另一篇文章,希望能够帮助读者更好地掌握二叉树的相关知识。
《征服数据结构》队列和循环队列
数据结构和算法
05-31 318
摘要：1，队列的介绍2，队列的数组实现3，队列的链表实现4，循环队列的介绍1，队列的介绍队列（queue）是一种先进先出（FIFO, First-In-First-Out）的数据结构，就像大家排队买票一样，先来的先买。队列只允许在后端（rear）插入，在前端（front）删除。队列是一种非常简单的数据结构，在考试和面试中遇到的也比较多，队列的实现方式一般有两种方式，一种是通过数组实现，一种是通过链...
数据结构-哈希表
weixin_42035282的博客
06-01 158
哈希表是一种高效的数据结构，它可以提供快速的插入、删除和查找操作。哈希表的基本思想是将键通过一个哈希函数映射到一个连续的地址空间上，然后在这个地址空间上进行查找、插入和删除操作。下面将详细介绍哈希表的相关概念和实现方法。
王道数据结构课后习题排序
08-18
在王道数据结构课后习题中，有一个关于排序的题目。根据引用的思路，我们可以使用排序后查找的方法来解决这个问题。具体步骤如下： 1. 首先，对给定的数据进行排序，可以使用快速排序、归并排序等常见的排序算法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

WYF19999

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

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

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

打赏作者

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

抵扣说明：

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

余额充值