数据结构(一)反转链表、排序算法

1.反转链表

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
    if(pHead == nullptr){
        return nullptr;
    }
    ListNode* cur = pHead;
    ListNode* pre = nullptr;
    while(cur != nullptr){
        ListNode* temp = cur->next;
        cur->next = pre;
        pre = cur;
        cur = temp;
    }
    return pre;
    }
};

2.给定数组升序排列

①冒泡排序        时间复杂度O(n^2)   空间复杂度O(1)  稳定

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型vector 待排序的数组
     * @return int整型vector
     */
    
    void BubbleSort(vector<int>& a){
        for(int i = 0; i < a.size(); ++i){
            for(int j = 1; j < a.size() - i; ++j){
                if(a[j - 1] > a[j]){
                    swap(a[j - 1], a[j]);
                }
            }
        }
    }
    vector<int> MySort(vector<int>& arr) {
        BubbleSort(arr);
        return arr;
    }
};

②选择排序        时间复杂度O(n^2)   空间复杂度O(1)  稳定

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型vector 待排序的数组
     * @return int整型vector
     */
    
    void BubbleSort(vector<int>& a){
        for(int i = 0; i < a.size(); ++i){
            int min = i;
            for(int j = i; j < a.size(); j++){
                if(a[j] < a[min]){
                    min = j;
                }
            }
            swap(a[i], a[min]);
        }
    }
       
    vector<int> MySort(vector<int>& arr) {
        BubbleSort(arr);
        return arr;
    }
};

③快速排序        时间复杂度O(nlogn)   空间复杂度O(logn)  不稳定

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型vector 待排序的数组
     * @return int整型vector
     */
    void QuickSort(vector<int>& a, int l, int r){
        if(l > r){
            return;
        }
        int i = l, j = r, temp = a[i];
        while(i < j){
            while(l < r && a[j] >= temp){//直到找到比基准值小的
                j--;
            }
            if(i < j){
                a[i] = a[j];//交换到右边位置
                i++;
            }
            while(i < j && a[i] < temp){/直到找到比基准值小的
                i++;
            }
            if(i < j){
                a[j] = a[i];//交换到左边边位置
                j--;
            }
        }
        a[i] = temp;//中值成为基准值
        QuickSort(a, l, i- 1);//递归
        QuickSort(a, i + 1, r);//递归
    }
    vector<int> MySort(vector<int>& arr){
        QuickSort(arr, 0, arr.size() - 1);
        return arr;
    }
};

④插入排序        时间复杂度O(n^2)   空间复杂度O(1)  稳定

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型vector 待排序的数组
     * @return int整型vector
     */
    void InsertSort(vector<int>& a){
        for(int i = 1; i < a.size(); ++i){
            if(a[i] < a[i - 1]){
                int tmp = a[i];
                int j = i;//为了不改变i
                while(tmp < a[j - 1]){//如果值小于前面的
                   a[j] = a[j - 1];//将后面前移一位
                    j--;
                }
                a[j] = tmp;//直到不满足小于前面的数，放到它的后面
            }
        } 
    }
    vector<int> MySort(vector<int>& arr){
        InsertSort(arr);
        return arr;
    }
};