排序相关代码(数据结构笔试复测Leecode牛客)

Posted 小葵花幼儿园园长

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了排序相关代码(数据结构笔试复测Leecode牛客)相关的知识,希望对你有一定的参考价值。

排序

基础概念


基础排序

插入类排序

直接插入排序、折半插入排序、希尔排序

直接插入

基本思想:每趟将一个待排序的关键字按照大小插入到已排好的部分有序序列的适当位置中

时间复杂度 O ( n 2 ) O(n^2) O(n2)
空间复杂度 O ( 1 ) O(1) O(1)

vector<int> MySort(vector<int>& arr) 
        // write code here
        int i, j;
        int t;
        for(i = 1; i< arr.size();i++)
            t = arr[i];
            j = i-1;
            while(j>=0 && arr[j] > t)
            
                arr[j+1] = arr[j];
                j--;
            
            arr[j+1] = t;
            
        
        return arr;
    

折半插入

基本思想:采用折半查找法来查找插入位置
序列已经有序,查找插入位置

时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)
空间复杂度 O ( 1 ) O(1) O(1)

 // 折半插入
    vector<int> MySort(vector<int>& arr) 
        // write code here
        int i, j, t;
        int low, mid, high;
        for(i = 1; i< arr.size();i++)
            t = arr[i];
            low = 0;
            high = i-1;
            // 折半查找
            while(low <= high)
            
                mid = (low+high)/2;
                if(arr[mid]>t)
                    high = mid-1;
                else
                    low = mid+1;
            
            for(j=i-1; j>=high+1; j--)
            
                arr[j+1] = arr[j];
            
            arr[high+1] = t;
            
            
        
        return arr;
    

希尔排序

基本思想:缩小增量排序+直接插入排序

时间复杂度 O ( n 2 ) O(n^2) O(n2)
空间复杂度 O ( 1 ) O(1) O(1)

        // 希尔排序
    vector<int> MySort(vector<int>& arr) 
        // write code here
        int gap;//增量
        int i,j;
        int n = arr.size();
        for(gap = n/2; gap>0; gap=gap/2)
            for(i=0; i<gap; i++)
                for(j=i+gap; j < n; j+=gap)
                
                    if(arr[j] < arr[j-gap])
                    
                        int t = arr[j];
                        int k = j-gap;
                        while(k>=0 && arr[k] >=t)
                        
                            arr[k+gap] = arr[k];
                            k -= gap;
                        
                        arr[k+gap] = t;
                    
                
            
        
        return arr;
    

交换类排序

冒泡排序、快速排序

冒泡排序

    //冒泡排序
    vector<int> MySort(vector<int>& arr) 
        // write code here
        int i, j, t;
        int flag;//标记是否发生了变化
        int n = arr.size();
        for(i=n-1; i>=1; --i)
        
            flag = 0;
            for(j=0; j<i; j++)
            
                if(arr[j+1]<arr[j])
                
                    t = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = t;
                    flag = 1;
                
                
            
            if(flag == 0)
                return arr;
        
        return arr;
    

快速排序

通过多次划分操作实现排序
每一趟选择当前所有子序列中的一个关键字(第一个)作为轴,将比轴小的放在前面,大的放在后面

     //快速排序
    vector<int> MySort(vector<int>& arr) 
        // write code here
        srand(0);
        QuickSort(arr, 0, arr.size()-1);
        return arr;
    
    void QuickSort(vector<int>& arr, int low, int high) 
        // write code here
        int n = arr.size();
        int i = low, j = high;
        int t;
        if(low<high)
        
            t = arr[low];
            while(i<j)
            
                while(j>i && arr[j] >= t)
                    j--;
                if(i<j)
                
                    arr[i] = arr[j];
                    i++;
                
                while(i<j && arr[i] <= t)
                    i++;
                if(i<j)
                
                    arr[j] = arr[i];
                    j--;
                
            
            arr[i] = t;
            QuickSort(arr, low, i-1);
            QuickSort(arr, i+1, high);
        
        
    

选择类排序

简单选择排序、堆排序

简单选择排序

从头到尾顺序扫描序列,找到最小的一个关键字和第一个关键字交换

    // 简单选择排序
         //快速排序
    vector<int> MySort(vector<int>& arr) 
        // write code here
        int i,j,k;
        int t;
        for(i = 0; i<arr.size(); i++)
        
            k = i;
            for(j = i+1; j<arr.size(); j++)
            
                if(arr[j]<arr[k])
                    k = j;
            
            t = arr[i];
            arr[i] = arr[k];
            arr[k] = t;
        
        return arr;
    

堆排序

  • 堆是一种数据结构,可以把堆看成一棵完全二叉树
  • 完全二叉树满足:任何一个非叶结点的值都不大于(或不小于)其左右孩子结点的值。
  • 若父亲大孩子小,则这样的堆叫作大顶堆;
  • 若父亲小孩子大,则这样的堆叫作小顶堆。

将序列调整为堆

    //堆排序
    vector<int> MySort(vector<int>& arr) 
        // write code here
        if(arr.empty())
            return arr;
        
        HeapSort(arr, arr.size());
        return arr;
    
    
    // 在数组arr[low]到arr[high]对位置low上的结点进行调整
    void Sift(vector<int>& arr, int low, int high)
        int i = low, j = 2*i; //arr[j]为arr[i]的左孩子结点
        int t = arr[i];
        while(j<=high)
        
            if(j<high && arr[j]<arr[j+1]) //右孩子大,指向右孩子
                ++j;
            if(t < arr[j])
            
                arr[i] = arr[j];
                i = j;
                j = 2*i;
            
            else
                break;
        
        arr[i] = t;
    
    
    void HeapSort(vector<int>& arr, int n)
        int i;
        int t;
        for(i = n/2; i>=0; --i) //初始堆,找到最大的节点
            Sift(arr, i, n-1);
        
        for(i = n-1; i>=1; --i)
        
        	//将最大的节点放在最后面
            t = arr[0];
            arr[0] = arr[i];
            arr[i] = t;
            Sift(arr, 0, i-1);
        
        return;
    

归并类排序

二路归并排序

进阶应用

以上是关于排序相关代码(数据结构笔试复测Leecode牛客)的主要内容,如果未能解决你的问题,请参考以下文章

数据结构栈队列相关代码(数据结构笔试复测Leecode牛客)

数据结构数组相关代码(数据结构笔试复测Leecode牛客)

数据结构字符串相关代码(数据结构笔试复测Leecode牛客)

基础算法(数据结构笔试复测Leecode牛客)

数据结构树相关代码(数据结构笔试复测Leecode牛客)

动态规划(数据结构笔试复测Leecode牛客)