/*****/排序

最新推荐文章于 2021-11-27 16:54:12 发布
最新推荐文章于 2021-11-27 16:54:12 发布
阅读量404 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34967445/article/details/76834586
版权

直接插入排序

插入排序的基本思想是：
每次将一个待排的记录，按照其关键字的大小，插入到前面已经排好序的有序区中适当的位置，直到全部记录插入完毕为止。
假设待排序的记录存放在数组R[0..n]中，初始时R[0]是一个有序区，R[1..n]是无序区，从i=1开始，依次将R[i]插入到有序区R[0..i-1]中，生成一个包含n个记录的有序区。

这里写图片描述

Sort.h

#pragma once
void PrintArray(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i)
    {
        cout << a[i] << "";
    }
    cout << endl;//换行
}
void InsertSort(int *a, size_t n)
{
    assert(a);
    for (size_t i = 0; i < n - 1; ++i)
    {
        int end = i;
        int tmp = a[end + 1];
        while (end >= 0)
        {
            if (a[end]>tmp)
            {
                a[end + 1] = a[end];
                    --end;
            }
            else
            {
                break;
            }
        }
        a[end + 1] = tmp;
    }
}
void TestInsertSort()
{
    int a[] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    PrintArray(a, sizeof(a) / sizeof(a[0]));
    InsertSort(a, sizeof(a) / sizeof(a[0]));
    PrintArray(a, sizeof(a) / sizeof(a[0]));
}

Test.cpp

#include<iostream>
#include<assert.h>
using namespace std;
#include"Sort.h"
int main()
{
    TestInsertSort();
    return 0;
}

这里写图片描述

SHELL排序

希尔排序又称为缩小增量排序，它是插入排序的一种变形。

希尔排序：
设待排序元素有n个，首先取一个整数gap

#pragma once
void PrintArray(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i)
    {
        cout << a[i] << "";
    }
    cout << endl;//换行
}
void ShellSort(int *a, size_t n)
{
    assert(a);
    int gap = n;
    while (gap > 1)
    {
        gap = gap / 3 + 1;
        for (size_t i= 0; i < n - gap; ++i)
        {
            int end = i;
            int tmp = a[end + gap];
            while (end >= 0)
            {
                if (a[end]>tmp)
                {
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else
                    break;
            }
            a[end + gap] = tmp;

        }
    }

}
void TestShellSort()
{
    int a[] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    PrintArray(a, sizeof(a) / sizeof(a[0]));
    ShellSort(a, sizeof(a) / sizeof(a[0]));
    PrintArray(a, sizeof(a) / sizeof(a[0]));
}

Test.cpp

#include<iostream>
#include<assert.h>
using namespace std;
#include"Sort.h"
int main()
{
    TestShellSort();
    return 0;
}

这里写图片描述

选择排序

选择排序的基本思想：初始时，有序区为0，每一趟在无序区中选出一个关键字最小的元素，然后与无序区第一个元素交换，然后无序区减1，有序区加1，直到记录全部排完。
直接选择排序：第一趟排序在R[0..n]中选出一个关键字最小的与R[0]交换，第二趟在R[1..n]中选择一个最小的与R[1]进行交换，以此类推直到无序区的记录只剩一个时排序完成。

这里写图片描述

Sort.h

#pragma once
void PrintArray(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i)
    {
        cout << a[i] << "";
    }
    cout << endl;//换行
}
void SelectSort(int *a, size_t n)
{
    assert(a);
    size_t left = 0, right = n - 1;
    while (left < right)
    {
        size_t min = left, max = left;
        for (size_t i = left; i <= right; ++i)
        {
            if (a[min]>a[i])
                min = i;
            if (a[max] < a[i])
                max = i;
        }
        //修正
        swap(a[min], a[left]);
        if (max == left)
            max = min;
        swap(a[max], a[right]);
        ++left; --right;
    }

}
void TestSelectSort()
{
    int a[] = { 9, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    PrintArray(a, sizeof(a) / sizeof(a[0]));
    SelectSort(a, sizeof(a) / sizeof(a[0]));
    PrintArray(a, sizeof(a) / sizeof(a[0]));
}

Test.cpp

#include<iostream>
#include<assert.h>
using namespace std;
#include"Sort.h"
int main()
{
    TestSelectSort();
    return 0;
}

这里写图片描述

堆排序

时间复杂度： 第一次建堆的时间复杂度:O(N*lgN)。 每次调整的时间复杂度是O(lgN),总共有N次，即：O(N*lgN); 所以：
堆排序的时间复度：O(N*lgN)

Sort.h

#pragma once
void PrintArray(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i)
    {
        cout << a[i] << "";
    }
    cout << endl;//换行
}
void AdjustDown(int *a, size_t root, size_t n)
{
    size_t parent = root;
    size_t child = parent * 2 + 1;
    while (child < n)
    {
        if (child + 1 < n && a[child + 1] > a[child])
        {
            ++child;
        }
        if (a[child]>a[parent])
        {
            swap(a[child], a[parent]);
            parent = child;
            child = 2 * parent + 1;
        }
    }
}
void HeapSort(int *a,size_t n)
{
    assert(a);
    for (int i = (n - 2) / 2; i >= 0; --i)
    {
        AdjustDown(a, i, n);
    }
    size_t end = n - 1;
    while (end > 0)
    {
        swap(a[0], a[end]);
        AdjustDown(a, 0, end);
    }
}
void TestHeapSort()
{
    int a[] = { 9, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    PrintArray(a, sizeof(a) / sizeof(a[0]));
    HeapSort(a, sizeof(a) / sizeof(a[0]));
    PrintArray(a, sizeof(a) / sizeof(a[0]));
}

Test.cpp

#include<iostream>
#include<assert.h>
using namespace std;
#include"Sort.h"
int main()
{
    TestHeapSort();
    return 0;
}

冒泡排序
Sort.h

#pragma once
void PrintArray(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i)
    {
        cout << a[i] << "";
    }
    cout << endl;//换行
}
void BubbleSort(int *a, size_t n)
{
    assert(a);
    int end = n;
    while (end > 0)
    {
        bool exchange = false;
        for (int i = 1; i < end; ++i)
        {
            if (a[i - 1]>a[i])
            {
                swap(a[i - 1], a[i]);
                exchange = true;
            }
        }
        if (exchange == false)
        {
            break;
        }
        --end;
    }
}
void TestBubbleSort()
{
    int a[] = { 1,2,3,4,5,7,6 };
    PrintArray(a, sizeof(a) / sizeof(a[0]));
    BubbleSort(a, sizeof(a) / sizeof(a[0]));
    PrintArray(a, sizeof(a) / sizeof(a[0]));
}

Test.cpp

#include<iostream>
#include<assert.h>
using namespace std;
#include"Sort.h"
int main()
{
    TestBubbleSort();
    return 0;
}

这里写图片描述

快速排序是一种划分交换的方法，它采用分治法进行排序。其基本思想是取待排序元素序列中的某个元素作为基准值，按照这个元素的大小，将整个元素序列划分成两个左右两个子序列，使得左子序列的值都比这个元素小，右子序列中的值都比这个元素值要大于或等于，基准元素值则排在这两个序列中间，然后再对这两个子序列进行同样的方法，直到所有元素都排在相应的位置(即序列中只有一个元素或者没有元素的时候)。
这里写图片描述
快速排序方法一

左右指针法

Sort.h

#pragma once
void PrintArray(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i)
    {
        cout << a[i] << "";
    }
    cout << endl;//换行
}
//快速排序左右指针法
int PartSort1(int *a, int left, int right)
{
    int key = a[right];
    int begin = left;
    int end = right;
    while (begin < end)
    {
        while (begin < end && a[begin] <= key)
        {
            ++begin;
        }
        while (begin < end && a[end] >= key)
        {
            --end;
        }
        if (begin < end)
            swap(a[begin], a[end]);
    }
    swap(a[begin], a[right]);
        return begin;

}

void QuickSort(int *a, int left, int right)
{
    assert(a);
    if (left < right)
    {
        int div = PartSort1(a, left, right);
        QuickSort(a, left, div - 1);
        QuickSort(a, div + 1, right);
    }
}
void TestQuickSort()
{
    int a[] = { 5,0,4,9,3,6,5,7,1,5};
    PrintArray(a, sizeof(a) / sizeof(a[0]));
    QuickSort(a,0, sizeof(a) / sizeof(a[0]) - 1);
    PrintArray(a, sizeof(a) / sizeof(a[0]));
}

Test.cpp

#include<iostream>
#include<assert.h>
using namespace std;
#include"Sort.h"
int main()
{
    TestQuickSort();
    return 0;
}

这里写图片描述

换个测试用例试试：
这里写图片描述

快速排序方法二

挖坑法

Sort.h

#pragma once
void PrintArray(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i)
    {
        cout << a[i] << "";
    }
    cout << endl;//换行
}
//快速排序之挖坑法
int PartSort2(int *a, int left, int right)
{
    int key = a[right];
    while (left < right)
    {
        //找大
        while (left < right && a[left] <= key)
        {
            ++left;
        }
        //找到比key大的数放到右边的坑里，左边形成新的坑
        a[right] = a[left];
        while (left < right && a[right] >= key)
        {
            --right;
        }
        a[left] = a[right];
    }
    a[left] = key;
    return left;
}

void QuickSort(int *a, int left, int right)
{
    assert(a);
    if (left < right)
    {
        int div = PartSort2(a, left, right);
        QuickSort(a, left, div - 1);
        QuickSort(a, div + 1, right);
    }
}
void TestQuickSort()
{
    int a[] = { 5,0,4,9,3,6,5,7,1,5};
    PrintArray(a, sizeof(a) / sizeof(a[0]));
    QuickSort(a,0, sizeof(a) / sizeof(a[0]) - 1);
    PrintArray(a, sizeof(a) / sizeof(a[0]));
}

Test.cpp

#include<iostream>
#include<assert.h>
using namespace std;
#include"Sort.h"
int main()
{
    TestQuickSort();
    return 0;
}

这里写图片描述

快速排序方法三

前后指针法
Sort.h

#pragma once
void PrintArray(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i)
    {
        cout << a[i] << "";
    }
    cout << endl;//换行
}
//快速排序之前后指针法
int PartSort3(int *a, int left, int right)
{
    int prev = left - 1;
    int cur = left;
    int key = a[right];
    while (cur < right)
    {
        if (a[cur] < key &&  ++prev != cur)
        {
            swap(a[prev], a[cur]);
        }
        ++cur;
    }
    swap(a[++prev], a[right]);
    return prev;
}

void QuickSort(int *a, int left, int right)
{
    assert(a);
    if (left < right)
    {
        int div = PartSort3(a, left, right);
        QuickSort(a, left, div - 1);
        QuickSort(a, div + 1, right);
    }
}
void TestQuickSort()
{
    int a[] = { 5,0,4,9,3,6,5,7,1,5};
    PrintArray(a, sizeof(a) / sizeof(a[0]));
    QuickSort(a,0, sizeof(a) / sizeof(a[0]) - 1);
    PrintArray(a, sizeof(a) / sizeof(a[0]));
}

Test.cpp

#include<iostream>
#include<assert.h>
using namespace std;
#include"Sort.h"
int main()
{
    TestQuickSort();
    return 0;
}

这里写图片描述

快排的最坏情况：有序 （解决：三数取中）
用第一种方法示例：
Sort.h

#pragma once
void PrintArray(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i)
    {
        cout << a[i] << "";
    }
    cout << endl;//换行
}
int GetMidIndex(int*a, int left, int right)
{
    int mid = left + (right - left) / 2;
    //left mid right
    if (a[left] < a[mid])
    {
        if (a[mid] < a[right])
        {
            return mid;
        }
        else if (a[left]>a[right])
        {
            return left;
        }
        else
        {
            return right;
        }
    }

    else //left>min right
    {
        if (a[mid] > a[right])
            return mid;
        else
        if (a[left] < a[right])
            return left;
        else
            return right;
    }


}

int PartSort1(int *a, int left, int right)
{
    //三数取中
    int mid = GetMidIndex(a, left, right);
    swap(a[mid], a[right]);
    int key = a[right];
    int begin = left;
    int end = right; //防止有序排成无序
    while (begin < end)
    {
        while (begin < end && a[begin] <= key)
        {
            ++begin;
        }
        while (begin < end && a[end] >= key)
        {
            --end;
        }
        if (begin < end)
            swap(a[begin], a[end]);
    }
    swap(a[begin], a[right]);
    return begin;

}
void QuickSort(int *a, int left, int right)
{
    assert(a);
    if (left < right)
    {
        int div = PartSort1(a, left, right);
        QuickSort(a, left, div - 1);
        QuickSort(a, div + 1, right);
    }
}
void TestQuickSort()
{
    int a[] = { 5,0,4,9,3,6,5,7,1,5};
    PrintArray(a, sizeof(a) / sizeof(a[0]));
    QuickSort(a,0, sizeof(a) / sizeof(a[0]) - 1);
    PrintArray(a, sizeof(a) / sizeof(a[0]));
}

Test.cpp

#include<iostream>
#include<assert.h>
using namespace std;
#include"Sort.h"
int main()
{
    TestQuickSort();
    return 0;
}

快速排序非递归

//快速排序非递归
#include<stack>
void QuickSortNonR(int *a, int left, int right)
{
    assert(a);
    stack<int> s;
    if (left < right)
    {
        s.push(right);
        s.push(left);
    }
    while (!s.empty())
    {
        int begin = s.top();
        s.pop();
        int end = s.top();
        s.pop();

        int div = PartSort1(a, begin, end);
        //begin div-1
        //div+1 end
        if (begin < div - 1)
        {
            s.push(div - 1);
            s.push(begin);
        }
        if (div + 1 < end)
        {
            s.push(end);
            s.push(div + 1);
        }
    }
}

归并排序

归并排序是一种基于分治法的一种排序方法。它将要排序的序列分成两个长度相等的子序列，为每一个子序列进行排序，然后再将子序列合并成一个有序的序列。

这里写图片描述

void _MergeSort(int *a,int begin,int end,int *tmp)  
{  
       int mid = ((begin^end) >> 1) + (begin&end);  
       if (mid > begin)  
              _MergeSort(a,begin,mid,tmp);  
       if (mid + 1 < end)  
              _MergeSort(a,mid+1,end,tmp);  
       int begin1 = begin;  
       int end1 = mid;  
       int begin2 = mid + 1;  
       int end2 = end;  
       int index = begin;  
       while(begin1<=end1&&begin2<=end2)             //先将归并时的元素放到辅助数组中，如果放到原数组的话有可能会覆盖掉其他元素产生错误  
       {  
              if (a[begin1] < a[begin2])  
              {  
                     tmp[index++] = a[begin1++];  
              }  
              else  
              {  
                     tmp[index++] = a[begin2++];  
              }  
       }  
       while(begin1 <= end1)  
       {  
              tmp[index++] = a[begin1++];  
       }  
       while (begin2 <= end2)  
       {  
              tmp[index++] = a[begin2++];  
       }  
       while (begin <= end)                                     //将辅助数组中的元素再拷贝到原数组中  
       {  
              a[begin] = tmp[begin++];  
       }  
}  
void MergeSort(int *a,int begin,int end)  
{  
       assert(a);  
       int *tmp = new int[end-begin+1];  
       _MergeSort(a,begin,end,tmp);  
       delete[] tmp;  
}

计数排序主要思想：
给定一组要排序的序列，找出这组序列中的最大值，然后开辟一个最大值加1大小的数组，将这个数组里面的元素全部置零，然后用这个数组统计出要排序的序列中各个元素出现的次数。等到统计完成的时候，排序就已经完成了。

基数排序的主要思想：
基数排序又称”桶子法”，他从低位开始将待排序的数按照这一位的值放到相应的编号为0到9的桶中。等到低位排完之后得到一个序列，再将这个序列按照次低位的大小进入相应的桶中。以此类推，直到将所有的位都排完之后，这组数就已经有序了。

夏天的呆子
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android开发之Compose基础学习-图标、图片资源基本用法 Icon只能使用矢量图片 Image可以显示png等图片
xiayiye5的博客
08-08 1307
代码】Android开发之Compose基础学习-图标、图片资源基本用法 Icon只能使用矢量图片 Image可以显示png等图片。
java中 // /* */ /** */三种注释的区别
huo_wa的博客
05-18 4281
java中`// /* */ /** */`三种注释的区别： 1、`//` 单行注释； 2、`/* */` 多行注释； 3、`/** */` 多行注释；生成javadoc时，这样的注释会被生成标准的javaapi注释；在调用类或方法时会提示，提示内容就是你写的注释；
win7FTP服务器配置以及访问
热门推荐
弹指天下
07-30 4万+
也可以参考百度的教程win7下FTP服务器安装 一、FTP服务器功能打开 1、打开【控制面板】→【程序】→【打开或关闭Windows功能】→出现以下界面： 2、一定要将树形目录【Internet信息腐乳】展开，然后将【FTP服务】目录展开（注意的是所有其他配置在这里都要一层层展开才可以勾选住子目录），勾选中红色框的部分。 3、点击确定按钮，此时FTP服务器安装完毕。 二、配置FTP服
运算符JAVA
lizihai520的博客
07-20 273
## 运算符号 ### JAVA运算符 算术运算符：+, - , *, /, %（取于），++ ,-- 赋值运算符 = 关系运算符：>, <,>= ,<=, == ,!= instanceof 关系运算符返回结果: 正确（true） 错误(false)，布尔值表示 逻辑运算符:&& || ,! （与或非） 位运算符：&，|,^, ~ >>,<<,>>> 套件运算符？: 扩展赋值运算符:...
/ /* /**的区别
qq_44761854的博客
11-27 4328
1、/不会拦截页面，只会拦截路径 当请求为/user/login的时候可以被拦截，当为/page/login.html页面的时候不拦截 2、/* 会拦截路径和页面 当请求为/user/login的时候可以被拦截，当为/page/login.html页面的时候也会被拦截 3、/* 和 /** /* 是拦截所有的文件夹，不包含子文件夹 /** 是拦截所有的文件夹及里面的子文件夹 如请求/usr/add/a，/*不会进行拦截，/**会拦截 而请求/usr/add，/*会进行拦截，/**也会拦截， 相当于/
c代码-2.给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。 示例 1: 输入: 1->1->2 输出: 1->2 示例 2: 输入: 1->1->2->3->3 输出: 1->2->3 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode*
07-14
c代码-2.给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。 示例 1: 输入: 1->1->2 输出: 1->2 ... */ struct ListNode* deleteDuplicates(struct ListNode* head){ }
A*算法C/C++代码
07-30
的VS2013实现A*算法，包含2个工程，一个采用C++自带优先队函数实现OPEN表的插入删除及排序，一个用单链表实现。
java算法——基数排序/桶排序
07-15
基数排序/桶排序 *统计将数组中的数字分配到桶中后，各个桶中的数字个数 *数组中每个数的每一位数根据大小分配到对应大小为0~9的桶 *将各个桶中的数字个数，转化成各个桶中最后一个数字的下标索引
/*1.编写完整的堆排序程序*/
01-06
/*1.编写完整的堆排序程序*/ /*1.编写完整的堆排序程序*/
Java注释/*和/**的区别
雪落南城的博客
03-05 1万+
Java注释的三种类型 1、单选注释：符号是：// 2、块注释： 符号是： /* */ 可以跨多行 3、javadoc注释： 符号是： /** */ 可以跨多行， 生成javadoc时，这样的注释会被生成标准的javaapi注释。 /** */注释的话，你在调用类和方法的时候会出现提示，内容就是你写的注释。 而/* */就没有了。/* */就是//的多行版 ...
/**和/*区别
LeoSong121的博客
08-13 2万+
Spring MVC中的路径匹配要比标准的web.xml要灵活的多。默认的策略实现了 org.springframework.util.AntPathMatcher，就像名字提示的那样，路径模式是使用了Apache Ant的样式路径，Apache Ant样式的路径有三种通配符匹配方法（在下面的表格中列出)这些可以组合出很多种灵活的路径模式   Wildcard    Description  ...
Java中 /** */注释和 /* */注释 的区别
太匆匆
12-09 7654
/**......*/ 注释若干行，并写入javadoc文档。每个文档注释都会被置于注释定界符  注释文档将用来生成HTML格式的代码报告，所以注释文  档必须书写在类、域、构造函数、方法，以及字段(field)定义之前。注释文档由两部分组成——描述、块标记。 你再调用类和方法的时候会出现提示，内容就是你写的注释。就好像文档帮助一样。类似"字符串".toString()，鼠标放在toStri
java中“/**/”与“/***/”的区别
u011218378的博客
11-03 6462
java中“/**/”与“/***/”的区别
VS1003调试例程
yi_tianchou的博客
03-07 2343
开发工具 IAR 芯片:MSP430F5438 音频模块:VS1003B/VS1053 首先拿到之后，就像这到网上找一个别人做好的驱动直接用，(拿来主义) 找了一天无果，能找到的只是片段，或者芯片型号不对，中间也看了n多的文章介绍VS1003调试例程的，也看了几个驱动. 大概了解.代码不多.不是很复杂. 好 既然网上没有可以，那就拿别人的开始移植.一顿查VS手册，看别人项目的注释，开...
关于Fegin超时问题（feign.RetryableException: Read timed out executing GET http://*****）
ALin_Think的博客
12-12 3362
关于Fegin超时问题 把时间调久一点久可以了 在yml配置文件添加下图相应的配置即可 ribbon: ReadTimeout: 60000 ConnectTimeout: 60000
/***/二叉树经典面试题之判断一棵二叉树是否是完全二叉树
火锅——博客
05-15 1508
什么是完全二叉树呢 如果一颗二叉树的只有最后两层结点的度能小于2，其余结点的度都等于2。且最后一层的结点从最左边依次排列。 如果一颗二叉树中的每一个结点都与编号从1到n的满二叉树中的结点一一对应，则称这棵二叉树为完全二叉树。 我们可以根据完全二叉树的定义，按照层序遍历一颗树，当遇到空结点时如果这棵树已经遍历完毕，则这棵树就是完全二叉树，如果遇到空结点的后面还有元素则这
栈帧&栈&递归
火锅——博客
05-15 670
一般函数的调用栈帧 递归函数调用栈帧 函数栈帧调用&数据结构栈–栈实现将递归程序转换为非递归程序
/** * 排序规则 */
最新发布
06-21
在Python中，`sort()`和`sorted()`函数可以用来对列表进行排序，它们都可以接受一个可选的`key`参数，用于指定排序规则。这个参数可以是一个函数，该函数会被应用到列表的每个元素上，返回值作为排序依据。 例如，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值