排序问题

最新推荐文章于 2023-08-09 16:34:11 发布
最新推荐文章于 2023-08-09 16:34:11 发布
阅读量288 收藏 1
点赞数
分类专栏： 算法 文章标签： 算法

reference
http://blog.csdn.net/acm_1361677193/article/details/48206603

这里写图片描述
思想/例子
【冒泡】一种交换排序1，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。http://blog.csdn.net/lemon_tree12138/article/details/50591859

这里写图片描述
这里写图片描述
【鸡尾酒 双向冒泡】
这里写图片描述
【插入】 常见的插入排序有插入排序（Insertion Sort），希尔排序（Shell Sort），二叉查找树排序（Tree Sort），图书馆排序（Library Sort），Patience排序（Patience Sort）

void SelectSort(int *a, int len)
{
    for (int i=0; i<len-1; i++)
    {
        int k = i;
        int key = a[i];
        for (int j=i+1; j<len; j++)
        {
            if (a[j]<key)
            {
                k = j;
                key = a[j];
            }
        }
        if (k!=i)
            swap(a[i], a[k]);
    }
}
//直接插入排序：将一个记录插入到已经排好序的有序表中，得到新的有序表

【归并】

#include <iostream>
using namespace std;

/*归并过程--将两个有序数组合并成一个有序数组*/
void merge(int array[],int tempArray[],int left,int right,int middle)
{
    int index1=left;
    int index2=middle+1;
    for(int i=left;(index1<=middle)&&(index2<=right);i++)
    {
        if(array[index1]<array[index2])
            tempArray[i]=array[index1++];
        else
            tempArray[i]=array[index2++];
    }
    while(index1<=middle)
        tempArray[i++]=array[index1++];
    while(index2<=right)
        tempArray[i++]=array[index2++];
    for(i=left;i<=right;i++)
        array[i]=tempArray[i];  
}

/*两路归并排序--array[]为待排数组，tempArray[]为临时数组，left和right分别是数组两端*/
void mergeSort(int array[],int tempArray[],int left,int right)
{
    if(left<right)
    {
        int middle=(left+right)/2;
        mergeSort(array,tempArray,left,middle);
        mergeSort(array,tempArray,middle+1,right);
        merge(array,tempArray,left,right,middle);
    }
}

int main()
{
    int array[8]={6,8,7,3,1,2,5,4};
    int tempArray[8];
    mergeSort(array,tempArray,0,7);
    for(int i=0;i<8;i++)
        cout<<array[i]<<"  ";
    cout<<endl;
    return 0;
}

【桶】

#include <iostream>
using namespace std;

/*归并过程--将两个有序数组合并成一个有序数组*/
void merge(int array[],int tempArray[],int left,int right,int middle)
{
    int index1=left;
    int index2=middle+1;
    for(int i=left;(index1<=middle)&&(index2<=right);i++)
    {
        if(array[index1]<array[index2])
            tempArray[i]=array[index1++];
        else
            tempArray[i]=array[index2++];
    }
    while(index1<=middle)
        tempArray[i++]=array[index1++];
    while(index2<=right)
        tempArray[i++]=array[index2++];
    for(i=left;i<=right;i++)
        array[i]=tempArray[i];  
}

/*两路归并排序--array[]为待排数组，tempArray[]为临时数组，left和right分别是数组两端*/
void mergeSort(int array[],int tempArray[],int left,int right)
{
    if(left<right)
    {
        int middle=(left+right)/2;
        mergeSort(array,tempArray,left,middle);
        mergeSort(array,tempArray,middle+1,right);
        merge(array,tempArray,left,right,middle);
    }
}

int main()
{
    int array[8]={6,8,7,3,1,2,5,4};
    int tempArray[8];
    mergeSort(array,tempArray,0,7);
    for(int i=0;i<8;i++)
        cout<<array[i]<<"  ";
    cout<<endl;
    return 0;
}

【基数】

/*
 * Get the spcific digit of given number.
 * For example, number 234, 
 *  the 0st digit is 4, 
 *  the 1st digit is 3,
 *  the 2nd digit is 2,
 *  the 3th digit is 0.
 */
int GetNDigit(int nNumber, int nIdx)
{
    for (int i = nIdx; i > 0; i--) {
        nNumber /= 10;
    }
    return nNumber % 10;
}
/*
 * Counting Sort the given array according to specific digit.
 * array: 待排序数组.
 * nLength: 待排序数组长度
 * nIdxDigit: 排序要依据的位. 0为最低位，高位依次加1.
 * nK: *nIdxDigit位上可能出现的最大数字(对10进制数排序则nK=9).
 */
void CountingSort_SpecificDigit(int array[], size_t nLength, int nIdxDigit, int nK=9)
{
    if (NULL == array || 0 == nLength || 0 == nK)
        return;

    int *digitNum = new int[nLength];
    memset(digitNum, 0, sizeof(int)*nLength);
    int *count = new int[nK+1];
    memset(count, 0, sizeof(int)*(nK+1));
    int *arrayResult = new int[nLength];
    memset(arrayResult, 0, sizeof(int)*nLength);

    // 数组digitNum[]，保存每个元素指定位上的数字，作为排序依据
    for (int idx = 0; idx<nLength; idx++)
        digitNum[idx] = GetNDigit(array[idx], nIdxDigit);

    // 先计数，count[idx]为值等于idx的元素的个数
    for (int idx = 0; idx<nLength; idx++)
        count[digitNum[idx]]++;
    // 再累加，count[idx]为小于等于idx的元素的个数
    for (int idx = 1; idx<nK+1; idx++)
        count[idx] = count[idx] + count[idx-1];

    // 从后向前循环(保证排序稳定), 根据指定位的数字大小
    // 将array[idx]排在所有小于等于array[idx]的数(共count[digitNum[idx]]个)的后面
    for (int idx=nLength-1; idx>=0; idx--)
        {
        arrayResult[count[digitNum[idx]]-1] = array[idx];
        count[digitNum[idx]]--;
        }

    // 把排序结果写回原数组
    memcpy(array, arrayResult, sizeof(int)*nLength);

    delete [] digitNum;
    delete [] count;
    delete [] arrayResult;
}
/*
 * 基数排序
 * array: 待排序数组
 * nLength: 待排序数组元素个数
 * nDigit: 所有元素的最大位数
 */
void RadixSort(int array[], size_t nLength, int nDigit)
{
    // 从最低位到最高位，依次调用计数排序
    for (int idx=0; idx<=nDigit; idx++) {
        CountingSort_SpecificDigit(array, nLength, idx);
    }
}

【二叉树】

#pragma once
#include<iostream>using namespace std;
//树节点定义，包含父节点指针（便于回溯前驱与后继）
typedef struct Node {
    int data;
    struct Node *leftchild;
    struct Node *rightchild;
    struct Node *parent;
}Node_t;
/*
二叉排序树类定义
*/
class BSearchTree{
 public:
    BSearchTree(void);  
    ~BSearchTree(void);

    inline Node_t* getRoot() const { return this->root;} 

    void createBSTree(int *dataset, int size); //建立二叉排序树
    bool insertNode(Node_t **root, int value); //插入新节点,需要传入二级指针（改变根指针的值）

    void inorderTraverse(Node_t *root) const;  //中序遍历
    void visitMiddleOrder() const;  //对上一函数继续封装

    Node_t* searchNode(Node_t *root,int value) const; //按值查找
    void searchByValue(int value) const; //对上一函数继续封装

    //最大与最小代码对称
    void getMax(Node_t *root) const; //获取最大值
    void getMin(Node_t *root) const; //获取最小值

    //前驱与后继代码对称
    void getPredecessor(Node_t *node); //获取节点前驱 
    void getSuccessor(Node_t *node); //获取节点后继

    int getHeight(Node_t *root) const; //返回树高

 private:
     Node_t *root; //根节点
};
成员函数的实现：
#include "BSearchTree.h"
BSearchTree::BSearchTree(void)
{    root = NULL;
}
BSearchTree::~BSearchTree(void)
{
    //to do sth
}
//建立二叉排序树（导入数组内元素，逐一插入）void BSearchTree:: createBSTree(int *dataset, int size) {
    for ( int i=0; i<size; i++ ) {
        insertNode(&root,dataset[i]);
    }
}
//插入新节点//注意因为要修改root根指针的值，所以需要传入二级指针bool BSearchTree:: insertNode(Node_t **root, int value) {
    //初始化将插入的新节点
    Node_t *new_node = new Node_t;
    if ( new_node == NULL ) {
        return false;   
    }
    new_node->data = value;
    new_node->leftchild = new_node->rightchild = new_node->parent = NULL; 

    //空树时，直接让根指针指向新节点
    if( (*root) == NULL ) {
        *root = new_node;
        return true;
    }

     //插入到当前结点（*root）的左孩子  
    if ((*root)->leftchild == NULL && (*root)->data > value ) {
        new_node->parent = (*root);
        (*root)->leftchild = new_node;
        return true;
    }

     //插入到当前结点（*root）的右孩子  
    if((*root)->rightchild == NULL && (*root)->data < value){  
        new_node->parent = (*root);  
        (*root)->rightchild = new_node;  
        return true;  
    }  

    //递归法插入新节点
    if ( (*root)->data > value ) {  //新节点的值小于根节点，递归寻找左边空位
        insertNode( &(*root)->leftchild,value);  //关键点

    }
    else if ( (*root)->data < value ) {  //新节点的值大于根节点，递归寻找右边空位
        insertNode( &(*root)->rightchild,value); 

    } else {
        return true;
    }
}
//中序遍历void BSearchTree:: inorderTraverse(Node_t *root) const {
    //递归出口
    if ( root == NULL ) {
        return;
    }
    inorderTraverse( root->leftchild );
    cout<< root->data <<" ";
    inorderTraverse( root->rightchild );
}void BSearchTree::visitMiddleOrder() const {
    inorderTraverse(this->root);
}
//按值查找,返回节点的地址
Node_t* BSearchTree:: searchNode(Node_t *root,int value) const {
    if ( root == NULL ) {
        return NULL;
    }

    if ( root->data > value ) {
        searchNode( root->leftchild,value);

    }
    else if ( root->data < value ) {
        searchNode( root->rightchild,value);

    } else {
        return root;
    }
}void BSearchTree:: searchByValue(int value) const{
    Node_t *p_findnode = this->searchNode(root,value);
    if ( p_findnode == NULL ) {
        cout<<"没有找到该节点"<<endl;
    } else {
        cout<< "该节点存在" <<endl;
    }
}
//获取最大值void BSearchTree:: getMax(Node_t *root) const {
    while( root->rightchild ) {
        root = root->rightchild;
    }
    cout<<root->data<<endl;
}
//获取最小值void BSearchTree:: getMin(Node_t *root) const {
    while( root->leftchild ) {
        root = root->leftchild;
    }
    cout<<root->data<<endl;
}
//获取节点前驱void BSearchTree:: getPredecessor(Node_t *node) {
    //节点如果有左子树，则其前驱节点是左子树的最大值
    if ( node->leftchild != NULL ) {
        return getMax( node->leftchild );
    } else {
        cout<<"(该点无左子树，开始回溯祖先...)"<<endl;
    }

    //如果没有右子树，则向上回溯，最顶层的祖先节点则是后继
    Node_t *y = node->parent; //y首先指向该节点的父节点
    while( y != NULL && node == y->leftchild ) {
        node = y;
        y = y->parent;
    }
    cout<<y->data;
}
//获取节点后继void BSearchTree:: getSuccessor(Node_t *node) {
    //节点如果有右子树，则其后继节点是右子树的最小值
    if ( node->rightchild != NULL ) {
        return getMin( node->rightchild );
    } else {
        cout<<"(该点无右子树，开始回溯祖先...)"<<endl;
    }

    //如果没有右子树，则向上回溯，最顶层的祖先节点则是后继
    Node_t *y = node->parent;
    while( y != NULL && node == y->rightchild ) { //遇到第一个“拐角”回溯结束
        node = y;  //节点向上爬一层
        y = y->parent; //y也向上逐层回溯祖先
    }
    cout<<y->data;
}
//返回树高,树通用写法//ps：算法导论认为只有一个根节点时树高为0，我们常认为1int BSearchTree::getHeight(Node_t *root) const {
    return root ?  max(getHeight(root->leftchild),getHeight(root->rightchild))+1 : -1;
}

【图书馆】

【选择】

void SelectSort(int *a, int len)
{
    for (int i=0; i<len-1; i++)
    {
        int k = i;
        int key = a[i];
        for (int j=i+1; j<len; j++)
        {
            if (a[j]<key)
            {
                k = j;
                key = a[j];
            }
        }
        if (k!=i)
            swap(a[i], a[k]);
    }
}

【希尔】
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
【堆】

// 最大堆调整
void MaxHeapify(int *a, int i, int heapSize)
{
    int l = (i+1)*2-1;
    int r = (i+1)*2;
    int largest;

    if (l<=heapSize && a[l]>a[i])
        largest = l;
    else
        largest = i;

    if (r<=heapSize && a[r]>a[largest])
        largest = r;

    if (largest!=i)
    {
        swap(a[i], a[largest]);
        MaxHeapify(a, largest, heapSize);
    }
}

// 创建最大堆
void BuildMaxHeap(int *a, int len)
{
    for (int i=len/2-1; i>=0; i--)
    {
        MaxHeapify(a, i, len-1);
    }
}

// 堆排序
void HeapSort(int *a, int len)
{
    BuildMaxHeap(a, len);
    for (int i=len-1; i>0; i--)
    {
        swap(a[0], a[i]);
        MaxHeapify(a, 0, i-1);
    }
}

【快速】
(http://blog.csdn.net/acm_1361677193/article/details/48206603)
http://blog.sina.com.cn/s/blog_5c5bc9070100y4zv.html

void SelectSort(int *a, int len)
{
    for (int i=0; i<len-1; i++)
    {
        int k = i;
        int key = a[i];
        for (int j=i+1; j<len; j++)
        {
            if (a[j]<key)
            {
                k = j;
                key = a[j];
            }
        }
        if (k!=i)
            swap(a[i], a[k]);
    }
}
#include <thrust/host_vector.h>
#include <thrust/device_vector.h>
#include <thrust/generate.h>
#include <thrust/sort.h>
#include <thrust/copy.h>
#include <cstdlib>

#define NUM_ELEM (1024 * 1024)

int main(void)
{
    thrust::host_vector<int> host_array(NUM_ELEM);

    thrust::generate(host_array.begin(), host_array.end(), rand);
    thrust::device_vector<int> device_array = host_array;

    thrust::sort(device_array.begin(), device_array.end());
    thrust::sort(host_array.begin(), host_array.end());

    thrust::host_vector<int> host_array_sorted = device_array;
    return 0;
}
niefengNF
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见算法：C语言中的排序算法--冒泡排序，选择排序，希尔排序
iwm_NeXT的专栏
04-11 1万+
冒泡排序（Bubble Sort，台湾译为：泡沫排序或气泡排序）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端 维基百科：点击打开链接 /* 用选择法对10个数进行排序 */ #include
C语言排序问题
c03s315的专栏
05-07 1000
先前对C语言有一定的的入门知识，但是由于
【C语言数据结构】排序问题
qq_57123434的博客
11-19 1585
本文中我们介绍几种常见的排序方式。 这里以递增为例。 1.直接插入排序 首先说思路：我们假设要将一个数字插入一个有序数组。我们先用这个数字与数组的最右端的元素（最大值）相比较，如果这个元素比他大，那么就将这个最大值向右移动一个单位，并用次大值再与这个数字比较，以此类推。直到这个数字比当前的元素大，那么就用这个数字插在原有的两个元素之间。因为这个元素的下一位已经移动，所以不用担心元素覆盖数据丢失。但是如果走到头也没有比他小的元素时，就要把他放在第一位，充当新有序数组的最小值。 void InsertSort(
排序及问题（c）
liyuqian199695的博客
10-20 365
#include #include #include int main11() { int i=0,j=0;                    int tmp=0; int a[7]={33,645,3,455,6,77,4}; printf("排序前\n"); for(i=0;i { printf("%d\n",a[i]); } //排序 //外层循
C语言训练-1196-排序问题
任万万万
11-11 2138
Problem Description 输入10个整数，将它们从小到大排序后输出，并给出现在每个元素在原来序列中的位置。 Input 输入数据有一行，包含10个整数，用空格分开。 Output 输出数据有两行，第一行为排序后的序列，第二行为排序后各个元素在原来序列中的位置。 Sample Input 1 2 3 5 4 6 8 9 10 7 Sample Output 1 2 3 4 5 6 7 ...
蓝桥杯Python模拟赛题之排序问题.zip
最新发布
04-22
在“蓝桥杯Python模拟赛题之排序问题.zip”这个压缩包中，我们可以推测它包含的是与蓝桥杯竞赛相关的Python编程题目，重点是解决排序算法的问题。蓝桥杯是一项面向全国大学生的IT技术竞赛，旨在提升学生的编程技能和...
帆软：排序问题（通过帆软设置或者sql排序）
02-26
本篇将详细介绍如何在帆软中处理排序问题，以及如何结合SQL进行排序。 一、帆软报表界面设置排序 1. **单元格属性排序**：在设计报表时，选定需要排序的单元格，右键点击选择“单元格属性”，在弹出的对话框中找到...
浅谈JsonObject中的key-value数据解析排序问题
10-18
下面小编就为大家分享一篇浅谈JsonObject中的key-value数据解析排序问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
排序问题C++MFC
06-22
在IT领域，尤其是在软件开发中，排序问题是一个基础但至关重要的概念。本主题将深入探讨在C++中，特别是结合Microsoft Foundation Classes (MFC)框架下如何解决排序问题。MFC是微软为Windows应用程序开发提供的一套...
几种排序问题
06-11
1)对起泡排序、直接排序、简单选择排序、快速排序、希尔排序、堆排序算法进行比较； (2)待排序表的表长不小于100，表中数据随机产生，至少用5组不同数据作比较，比较指标有：关键字参加比较次数和关键字的移动次数...
九大排序算法-C语言实现及详解
zhangjikuan的专栏
10-13 6万+
概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。          当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。    快速排序：是目前基于比较的内部排序中被认为是最好的方法，
常见的几大排序问题
Lee贤的博客
08-09 1355
本文主要讲解了八个排序算法的原理及其实现和部分应用
三种基本排序方法(C语言实现)
热门推荐
qq2071114140的博客
05-24 14万+
三种基本排序(以升序为例) 1.冒泡排序 思想:每次相邻两个数比较,若升序,则将大的数放到后面,一次循环过后，就会将最大的数放在最后. 如图9 3 2 5 8 4 7 6是输入的待排序的数列,经过第一次排序,将最大的9放在最后,第二次排序,将剩下的2 3 5 4 7 6 8进行冒泡,将当前最大的8放在倒数第二的位置,以此类推 接下来上代码 #include &lt;stdio.h&...
C/C++ 八大排序算法
司马懿的西山居
07-27 5656
转自 http://blog.csdn.net/hguisu/article/details/7776068 目录(?)[+] 概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。          当n
C语言|排序问题
qq_53893431的博客
10-14 4117
这篇文章主要和大家分享三种基础的排序算法——冒泡排序、选择排序、快速排序 一、排序问题 1.冒泡排序 冒泡排序的主要思想是通过两两相邻的元素进行比较，通过元素的大小决定是否交换。一趟冒泡排序的结果是一定有一个最大数会排到最后一个元素；因此对n个数进行排序，需要进行n-1躺冒泡排序。 void bubble_sort(int arr[],int x)//注意形参arr传递的是地址 int i=0; for(i=0;i<sz-1;i++)//冒泡排序的趟数 { int j=0; i
C 排序问题 SDUT
zhangzhaolin12的博客
12-20 1831
Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 输入10个整数，将它们从小到大排序后输出，并给出现在每个元素在原来序列中的位置。 Input 输入数据有一行，包含10个整数，用空格分开。 Output 输出数据有两行，第一行为排序后的序列，第二行为排序后各个元素在原来序列中的位置。 Sample Input 1...
c语言字符串排序问题
geshengtong的博客
10-21 1万+
字符串排序 Time Limit: 3000ms, Memory Limit: 10000KB , Accepted: 2572, Total Submissions: 3767 Description 在主函数中输入10个等长的字符串（每个字符串最多10个字符），用另一个函数对它们进行由小到大排序，然后在主函数中输出这10个已排好序的字符串。 Input 输入10个等长的字符串，用空
ElasticSearch 排序问题
08-16
在Elasticsearch中，排序问题可能出现在聚合操作中。根据引用的描述，Elasticsearch在排序操作时，会先对每个分片进行排序，然后将每个分片的前17名结果进行再次聚合和排序，最终返回排序后的前5条记录作为结果。这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值