数据结构算法

冒泡排序

void BubbleSort(vector<int> &arr)
{   int n=arr.size();
    for(int i = 0; i < n - 1; i++)
    {
        for(int j = 0; j < n - i - 1; j++)
        {
            if(arr[j] > arr[j+1])
                std::swap(arr[j],arr[j+1]);
        }
    }
}
int main(){
    vector<int> nums={1,2,3,2,2,2,5,4,2};
    BubbleSort(nums);

}

选择排序

void SelectSort( vector<int> & a)
{   
    int length=a.size();
    //对数组a排序,length是数组元素数量
    for( int i = 0; i < length; i++ ) {
        // 找到从i开始到最后一个元素中最小的元素,k存储最小元素的下标.
        int min = a[i];
        for( int j = i + 1; j < length; j++ ) {
            if( a[j] < min )swap(a[j],min);
        }
    }
}
int main(){
    vector<int> nums={1,2,3,2,2,2,5,4,2};
    SelectSort(nums);

}

插入排序

void insertSort(vector<int>  &arr)
{   
    int length=arr.size();
	for (int i = 1; i < length; i++)
	{
		for (int j = i - 1; j >= 0 && arr[j + 1] < arr[j]; j--)
		{
			swap(arr[j], arr[j + 1]);
		}
	}
}
int main(){
    vector<int> nums={1,2,3,2,2,2,5,4,2};
    insertSort(nums);
    int cc=1;
}

快速排序

#include<cstring>
#include<iostream>
#include<vector>
#include<unordered_map>
#include<algorithm>
#include<stack>
#include<queue>
#include<set>
#include<map>
using namespace std;
class Solution{
public:
    void quickSort(vector<int> & nums,int left ,int right){
        if(left<right){
            int key=partition(nums,left,right);
            quickSort(nums,left,key-1);
            quickSort(nums,key+1,right);
        }
    }
private:
    int partition(vector<int> &nums,int left,int right){
        int k=left,key=nums[right];
        for(int i=left;i<right;i++){
            if(nums[i]<=key){
                swap(nums[i],nums[k++]);
            }
        }
        swap(nums[k],nums[right]);
        return k;
    }
};

int main(){
    Solution sol;
    vector<int>nums={3,5,7,9,2,3,1,0,7,5,4};
    sol.quickSort(nums,0,10);
    int cc=1;
}

堆排序

参考

#include<cstring>
#include<iostream>
#include<vector>
#include<unordered_map>
#include<algorithm>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<memory>
using namespace std;
struct  Solution{
public:
// 递归方式构建大根堆(len是arr的长度，index是第一个非叶子节点的下标)
    void adjust(vector<int> & array ,int len,int idx){
        int left=2*idx+1;
        int right=2*idx+2;
        int maxIdx=idx;
        if(left<len && array[left]>array[maxIdx]){
            maxIdx=left;
        }
        if(right<len && array[right]>array[maxIdx]){
            maxIdx=right;
        }
        if(maxIdx!=idx){
            swap(array[maxIdx],array[idx]);
            adjust(array,len,maxIdx);
        }
    }
    void heapSort(vector<int> &array,int size){
         // 构建大根堆（从最后一个非叶子节点向上）
        for(int i=size/2-1;i>=0;i--){
            adjust(array,size,i);
        }
        for (int i=size-1;i>=1;i--){
            swap(array[0],array[i]);
            adjust(array,i,0);
        }
    }
private:
};

int main(){
    Solution sol;
    vector<int> arr={4,6,8,5,9};
    sol.heapSort(arr,arr.size());
    int cc=1;
}

插入排序

#include<cstring>
#include<iostream>
#include<vector>
#include<unordered_map>
#include<algorithm>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<memory>
#include<list>
using namespace std;
struct Solution{
    public:
        void insertSort(vector<int> & nums){
            for(int i=1;i<nums.size();i++){
                int key=nums[i];
                int j=i-1;
                while(j>=0 && key<nums[j]){
                    nums[j+1]=nums[j];
                    j--;
                }
                nums[j+1]=key;
            }
        }
};
int main(){
    Solution sol;
    vector<int> nums={4,7,3,8,1,9,10};
    sol.insertSort(nums);
    int cc=1;
}

希尔排序

思路：参考

#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<list>
#include<queue>
#include<map>
#include<unordered_map>
using namespace std;
struct Solution{
    public:
        void xierSort(vector<int> & nums){
            int gap=0;
            int N=nums.size();
            for(gap=N/2;gap>0;gap/=2){
                //插入排序
                for(int i=gap;i<N;i++){
                    int j=i;
                    while(j-gap>=0 && nums[j-gap]>nums[j]){
                        swap(nums[j-gap],nums[j]);
                        j=j-gap;
                    }
                }
            }
        }
};

int main(){
    Solution sol;
    vector<int> nums={8,9,1,7,2,3,5,4,6,0,10};
    sol.xierSort(nums);
    int cc=1;
}

归并排序

思路：参考

#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<list>
#include<queue>
#include<map>
#include<unordered_map>
using namespace std;
struct Solution{
    public:
        void Merge(vector<int>& nums,int low ,int mid,int high){
            int i=low,j=mid+1,k=0;
            vector<int> temp(high-low+1);
            while(i<=mid && j<=high){
                if(nums[i]<=nums[j]){
                    temp[k++]=nums[i++];
                }
                else{
                    temp[k++]=nums[j++];
                }
            }
            while(i<=mid){
                temp[k++]=nums[i++];
            }
            while(j<=high){
                temp[k++]=nums[j++];
            }
            for(int i=low,k=0;i<=high;i++,k++){
                nums[i]=temp[k];
            }
        }
        void MergeSort(vector<int> & nums,int low,int high){
            if(low <high){
                int mid=(low+high)/2;
                MergeSort(nums,low,mid);
                MergeSort(nums,mid+1,high);
                Merge(nums,low ,mid,high);
            }
        
        }
};
int main(){
    Solution sol;
    vector<int> nums={5,1,9,3,7,4,8,6,2,0};
    //减1 对应的最后一个元素的位置
    sol.MergeSort(nums,0,nums.size()-1);
    int cc=1;
}