zoukankan      html  css  js  c++  java
  • c++各种排序的简单实现

    /*
    直插排序
     */
    void InsertSort(vector<int> &arr){
        for(int i = 1;i < arr.size();++i){
            for(int j = i;j > 0;--j){
                if(arr[j] < arr[j - 1]){
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
                else break;
            }
        }
    }    
    
    /*
    冒泡排序
     */
    void BubbleSort1(vector<int> &arr){
        for (int i = 0; i < arr.size() - 1; i++) {
        	bool flag=true;
            for (int j = 0; j < arr.size() - i - 1; j++) { //经过第1趟可以找出最大的数
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag=false;
                }
            }
            if(flag) return;
        }
    }
    
    void BubbleSort2(vector<int> &arr){
        for (int i = 0; i < arr.size() - 1; i++) {
        	bool flag=true;
            for (int j = arr.size()-1; j > i; j--) {
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag=false;
                }
            }
            if(flag) return;
        }
    }
    
    /*
    快速排序
     */
    void quicksort(vector<int> &arr, int left, int right)
    {
        if(left >= right) return ;
        int i = left;
        int j = right;
        int key = arr[left]; //比较的是第一个数
        while(i < j)                             
        {
            while(i < j && key <= a[j])
            {
                j--;
            }
            arr[i] = arr[j];      
            while(i < j && key >= a[i])
            {
                i++;
            }
            arr[j] = arr[i];
        }
        arr[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/
        quicksort(arr, left, i - 1);
        quicksort(arr, i + 1, right);               
    }
    
    
    /*
    归并排序
     */
    
    void Merge(int& arr[], int reg[], int start, int end) {
        if (start >= end) return;
        int mid = (end + start) >> 1;
        //分成两部分
        int start1 = start, end1 = mid;
        int start2 = mid + 1, end2 = end;
        //然后合并
        Merge(arr, reg, start1, end1);
        Merge(arr, reg, start2, end2);
    
        int k = start;
        //两个序列一一比较,哪的序列的元素小就放进reg序列里面,然后位置+1再与另一个序列原来位置的元素比较
        //如此反复,可以把两个有序的序列合并成一个有序的序列
        while (start1 <= end1 && start2 <= end2)
            reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    
        //然后这里是分情况,如果arr2序列的已经全部都放进reg序列了然后跳出了循环
        //那就表示arr序列还有更大的元素(一个或多个)没有放进reg序列,所以这一步就是接着放
        while (start1 <= end1)
            reg[k++] = arr[start1++];
    
        //这一步和上面一样
        while (start2 <= end2)
            reg[k++] = arr[start2++];
        //把已经有序的reg序列放回arr序列中
        for (k = start; k <= end; k++)
            arr[k] = reg[k];
    }
    
    void MergeSort(int& arr[], const int len) {
        //创建一个同样长度的序列,用于临时存放
        int reg[len];
        Merge(arr, reg, 0, len - 1);
    }
    
    
    //折半插入排序  O(nlog2(n)) 稳定 
    int low,high,middle;
    void BinaryInsertSort(int a[], int len){
       for(int i=0;i<len;i++){
          int temp=a[i];
          low=0;high=i-1;
          while(low<=high){
             middle=(low+high)/2;
             if(temp<a[middle]){
                high=middle-1;
             }
             else{
                low=middle+1;
             }
          }
          for(int k=i;k>low;k--){
             a[k]=a[k-1];
          }
          a[low]=temp;
       }
    }
    
     
    /**************************************/
    //希尔排序  速度很难定量 但是效率挺高的 不稳定的算法 
    void Shellsort(int a[], int len){
       int gap=len-1;  //初始增量 
       bool flag=0;
       while(gap>=1){
          if(gap==1) flag=1;
          for(int i=0;i<len;i++){
             if(i+gap<len){
                if(a[i]>a[i+gap]){
                   int temp=a[i];
                   a[i]=a[i+gap];
                   a[i+gap]=temp;
                }           
             }
             else break;
          }
          gap=gap/3+1; //增量计算公式
          if(flag) break;
       }
    } 
    
    
    //堆排序
    void HeapSort(int arr[],int len){
        int i;
        //初始化堆,从最后一个父节点开始
        for(i = len/2 - 1; i >= 0; --i){
            Heapify(arr,i,len);
        }
        //从堆中的取出最大的元素再调整堆
        for(i = len - 1;i > 0;--i){
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            //调整成堆
            Heapify(arr,0,i);
        }
    }
    //再看 调整成堆的函数
    
    void Heapify(int arr[], int first, int end){
        int father = first;
        int son = father * 2 + 1;
        while(son < end){
            if(son + 1 < end && arr[son] < arr[son+1]) ++son;
            //如果父节点大于子节点则表示调整完毕
            if(arr[father] > arr[son]) break;
            else {
             //不然就交换父节点和子节点的元素
                int temp = arr[father];
                arr[father] = arr[son];
                arr[son] = temp;
                //父和子节点变成下一个要比较的位置
                father = son;
                son = 2 * father + 1;
            }
        }
    }
    

      

  • 相关阅读:
    安卓手机批量导入通讯录 Vcard文件和excel
    关于vue项目中文件上传,复现,模版下载常见用法(el-upload)
    用scrollTop实现固定定位
    自己对闭包的理解(保证能看懂)
    el-progress组件使用:自动计算percentage,format自定义显示文字
    css背景图片位置:background的position
    2018款Mac mini通过外置移动硬盘安装windows10系统
    TypeError: Constructor parameter should be str
    aiohttp使用方法
    json解析出错:json.decoder.JSONDecodeError: Invalid escape:
  • 原文地址:https://www.cnblogs.com/zhang-qc/p/9344702.html
Copyright © 2011-2022 走看看