数据结构-常见算法整理

最新推荐文章于 2024-07-25 22:14:03 发布

chkm12

最新推荐文章于 2024-07-25 22:14:03 发布

阅读量213

点赞数 2

文章标签：数据结构算法

本文链接：https://blog.csdn.net/chkm12/article/details/136822595

版权

一、线性数据结构。

1.反转链表

#include <iostream>
 
// 定义链表节点结构体
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};
 
// 反转链表的函数
ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr; // 初始化前一个节点为nullptr
    ListNode* curr = head; // 当前节点初始化为头节点
 
    while (curr) {
        ListNode* nextTemp = curr->next; // 临时节点，用于保存下一个节点的地址
        curr->next = prev; // 将当前节点指向它的前一个节点
        prev = curr; // 前一个节点更新为当前节点
        curr = nextTemp; // 当前节点更新为下一个节点
    }
 
    return prev; // 返回反转后链表的头节点，即原链表的尾节点
}

2.快速排序

#include <iostream>  
#include <vector>  
  
using namespace std;  
  
// 快速排序的分区函数  
int partition(vector<int>& nums, int left, int right) {  
    int pivot = nums[right];  
    int i = left;  
    for (int j = left; j < right; j++) {  
        if (nums[j] <= pivot) {  
            swap(nums[i], nums[j]);  
            i++;  
        }  
    }  
    swap(nums[i], nums[right]);  
    return i;  
}  
  
// 快速排序的递归函数  
void quickSort(vector<int>& nums, int left, int right) {  
    if (left < right) {  
        int pivotIndex = partition(nums, left, right);  
        quickSort(nums, left, pivotIndex - 1);  
        quickSort(nums, pivotIndex + 1, right);  
    }  
}

3.归并排序

#include <iostream>  
#include <vector>  
  
using namespace std;  
  
// 归并排序的合并函数  
void merge(vector<int>& nums, int left, int mid, int right) {  
    int n1 = mid - left + 1;  
    int n2 = right - mid;  
  
    // 创建临时数组  
    vector<int> leftArr(n1);  
    vector<int> rightArr(n2);  
  
    // 拷贝数据到临时数组  
    for (int i = 0; i < n1; i++) {  
        leftArr[i] = nums[left + i];  
    }  
    for (int j = 0; j < n2; j++) {  
        rightArr[j] = nums[mid + 1 + j];  
    }  
  
    // 合并临时数组  
    int i = 0, j = 0, k = left;  
    while (i < n1 && j < n2) {  
        if (leftArr[i] <= rightArr[j]) {  
            nums[k] = leftArr[i];  
            i++;  
        } else {  
            nums[k] = rightArr[j];  
            j++;  
        }  
        k++;  
    }  
  
    // 拷贝剩余元素  
    while (i < n1) {  
        nums[k] = leftArr[i];  
        i++;  
        k++;  
    }  
    while (j < n2) {  
        nums[k] = rightArr[j];  
        j++;  
        k++;  
    }  
}  
  
// 归并排序的递归函数  
void mergeSort(vector<int>& nums, int left, int right) {  
    if (left < right) {  
        int mid = left + (right - left) / 2;  
  
        // 递归排序左右两部分  
        mergeSort(nums, left, mid);  
        mergeSort(nums, mid + 1, right);  
  
        // 合并两个有序数组  
        merge(nums, left, mid, right);  
    }  
}