计算机考研数据结构——八大排序代码实现（C++， 含代码测试）

已于 2024-06-26 11:13:55 修改
阅读量682 收藏 9
点赞数 9
文章标签： 数据结构 考研 c++
于 2024-06-26 11:11:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ll2633ll/article/details/139982850
版权

本篇博客，主要是使用 C++ 实现考研数据结构的排序代码，实现的均为从小到大排序，本文的排序代码中的无穷大值均采用的是 INT_MAX = 2147483647，如有需要可以自行更改。

目录

直接插入排序

思想

直接插入排序的思想就是维护前部分的有序数组，然后将后面的未排列的元素依次插入到前部分。

代码实现：

vector<int> directInsertSort(vector<int> arr) {
    // 实现直接插入排序
    int cnt = 0; // 对比较次数进行计数
    int tmp = -INT_MAX, n = arr.size();
    for (int i = 1; i < n; ++i) {
        if (arr[i - 1] > arr[i]) {
            tmp = arr[i];
            // [0, ..., i - 1] 都是有序的, 将 arr[i] 插入进去
            int j = i - 1;
            while (j >= 0 && ++cnt && arr[j] > tmp) {
                arr[j + 1] = arr[j];
                --j;
            }
            arr[j + 1] = tmp;
        }
        ++cnt;
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

折半插入排序

所谓折半插入排序就是二分查找当前插入的元素在前面有序部分的位置，相对于简单插入排序可能速度相对而言快一些。

代码实现

vector<int> binaryInsertSort(vector<int> arr) {
    // 在简单排序的基础上加入折半（二分查找位置）
    int cnt = 0; // 对比较次数进行计数
    int tmp = -INT_MAX, n = arr.size();
    for (int i = 1; i < n; ++i) {
        if (arr[i - 1] > arr[i]) {
            // [0, ..., i - 1] 都是有序的, 将 arr[i] 插入进去
            // 为了实现稳定排序，应当查找的是 >= (arr[i] + 1) 元素的第一个位置
            int left = 0, right = i - 1;
            tmp = arr[i] + 1;
            while (left <= right) { // [left, right]
                int mid = left + ((right - left) >> 1);
                if (arr[mid] < tmp) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
                ++cnt;
            }
            int j = i - 1;
            while (j >= left) {
                arr[j + 1] = arr[j];
                --j;
            }
            arr[left] = tmp - 1;
        }
        ++cnt;
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

希尔排序

写入排序由简单插入排序所优化，目的是减少元素的移动位置；
对比来看，简单插入要排序的序列相邻元素的下标间隔是 1，而希尔排序的间隔可以是大于 1 小于数组的长度的整数值，然后不断的减少至间隔为 1（相当于最终退化成简单插入排序）。

代码实现

vector<int> shellInsertSort(vector<int> arr) {
    // 实现简单插入排序的基础上，优化移动次数成希尔排序
    int cnt = 0; // 对比较次数进行计数
    int tmp = -INT_MAX, n = arr.size();
    // 初始化窗口大小
    int dx = 1;
    while (dx <= n / 2) dx <<= 1;
    while (dx) {
        for (int i = 0; i < n - dx; ++i) {
            for (int k = i + dx; k < n; k += dx) {
                if (arr[k - dx] > arr[k]) { // 内部使用简单插入排序
                    tmp = arr[k];
                    // [i, i + dx, ..., k - dx] 都是有序的, 将 arr[k] 插入进去
                    int j = k - dx;
                    while (j >= 0 && ++cnt && arr[j] > tmp) {
                        arr[j + dx] = arr[j];
                        j -= dx;
                    }
                    arr[j + dx] = tmp;
                }
                ++cnt;
            }
        }
        dx >>= 1;
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

冒泡排序

思想

每次都扫描数组，然后将更小的元素尽量往左边移动，显然，最小的元素肯定会被移动到最左边，也就是说一趟排序后至少能够确定一个正确的位置。

代码实现

vector<int> bubbleExchangeSort(vector<int> arr) {
    // 实现冒泡排序
    int cnt = 0; // 对比较次数进行计数
    int tmp = -INT_MAX, n = arr.size();
    for (int i = 0; i < n; ++i) {
        bool flag = false; // 记录本回合是否发生交换
        for (int j = n - 1; j > i; --j) {
            if (++cnt && arr[j] < arr[j - 1]) {
                swap(arr[j], arr[j - 1]);
                flag = true;
            }
        }
        if (!flag) {
            cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
            return arr; // 当前已经排序完成了
        }
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

快速排序

思想

每次在需要排序的部分选中一个基准元素，然后将小于基准元素的元素移动到其左边，大于基准元素的值移动到其右边。这保证了，每一趟这个排序能够实现1个元素能够被置到合适的位置。

代码实现

int partion(vector<int>& arr, int left, int right, int& cnt) {
    int x = arr[left];
    while (left < right) {
        while (right > left && ++cnt && arr[right] >= x) --right;
        arr[left] = arr[right];
        while (left < right && ++cnt && arr[left] <= x) ++left;
        arr[right] = arr[left];
    }
    arr[left] = x;
    return left;
}
int quickSort(vector<int>& arr, int left, int right) {
    int cnt = 0;
    if (left >= right) return cnt;
    int mid = partion(arr, left, right, cnt);
    cnt += quickSort(arr, left, mid - 1);
    cnt += quickSort(arr, mid + 1, right);
    return cnt;
}
vector<int> quickSort(vector<int> arr) {
    // 实现快速排序, 使用第一个元素作为基准元素
    int n = arr.size();
    int cnt = quickSort(arr, 0, n - 1);
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

简单选择排序

思想

实现很简单，每次选中未排序的部分的最小值，与左边交换。

代码实现

vector<int> simpleSelectSort(vector<int> arr) {
    // 实现简单选择排序
    int cnt = 0; // 对比较次数进行计数
    int n = arr.size();
    for (int i = 0; i < n; ++i) {
        int min_value = INT_MAX, min_loc = -1;
        for (int j = i; j < n; ++j) {
            if (++cnt && min_value > arr[j]) {
                min_loc = j;
                min_value = arr[j];
            }
        }
        swap(arr[i], arr[min_loc]);
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

堆排序

思想

思想其实很简单，首先建立一个小根堆，然后依次将小根堆的堆顶输出，输出的时候注意维护好小根堆。

代码实现

void adjustHeap(vector<int>& arr, int j, int back, int& cnt) {
    while (j < back) {
        int left = INT_MAX, right = INT_MAX;
        if (2 * j < back) left = arr[2 * j];
        if (2 * j + 1 < back) right = arr[2 * j + 1];
        cnt += 2;
        if (left < arr[j] && right < arr[j]) {
            if (left < right) {
                swap(arr[j], arr[2 * j]);
                j = 2 * j;
            } else {
                swap(arr[j], arr[2 * j + 1]);
                j = 2 * j + 1;
            }
            ++cnt;
        } else if (left < arr[j]) {
            swap(arr[j], arr[2 * j]);
            j = 2 * j;
        } else if (right < arr[j]) {
            swap(arr[j], arr[2 * j + 1]);
            j = 2 * j + 1;
        } else break; // 无法调整树型
    }
}
vector<int> heapSort(vector<int> arr) {
    // 实现堆排序
    int cnt = 0; // 对比较次数进行计数
    // 构建小根堆
    int n = arr.size();
    for (int i = n / 2; i >= 0; --i) {
        adjustHeap(arr, i, n, cnt);
    }
    // 输出排序结果
    vector<int> tmp(n);
    int back = n - 1;
    for (int i = 0; i < n; ++i) {
        // 弹出堆顶元素
        tmp[i] = arr[0];
        // 调整堆
        arr[0] = arr[back];
        adjustHeap(arr, 0, back, cnt);
        back--;
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return tmp;
}

基数排序

思想

我觉得这个叫做桶排序更加形象一些，思想就是根据数位将数组元素装桶，然后出桶，直至所有元素都在一个桶结束，还是非常巧妙的。

代码实现

vector<int> baseNumberSort(vector<int> arr) {
    // 实现基数排序, 最低位优先
    vector<vector<int>> nums(10);
    int cur = 1; // 当前位数
    int tmp = 10; // 非空桶个数
    while (tmp > 1) {
        // 入桶
        for (int num : arr)
            nums[num / cur % 10].push_back(num);
        // 出桶
        tmp = 0;
        arr.clear();
        for (auto& arr1 : nums) {
            tmp += (arr1.size() != 0);
            for (auto num : arr1) {
                arr.push_back(num);
            }
            arr1.clear();
        }
        cur *= 10;
    }
    return arr;
}

归并排序

思想

将其两两分组，然后两两合并即可。

代码实现

vector<int> MergeSort(vector<int> arr) {
    // 实现归并排序, 使用二路归并
    int cnt = 0; // 对比较次数进行计数

    function<void(vector<int>&, int, int, int)> merge = [&](vector<int>& arr, int low, int mid, int high) {
        // [low, mid], [mid + 1, high] 有序，合并两个区间
        vector<int> tmp(high - low + 1);
        int left = low, right = mid + 1, ix = 0; // 双指针
        while (left <= mid || right <= high) {
            tmp[ix++] = arr[left] < arr[right] ? arr[left++] : arr[right++], ++cnt;
            while (left > mid && right <= high) tmp[ix++] = arr[right++];
            while (right > high && left <= mid) tmp[ix++] = arr[left++];
        }
        for (int i = low; i <= high; ++i)
            arr[i] = tmp[i - low];
        tmp.clear();
    };
    
    int k = 2, n = arr.size();
    while (k <= n) {
        for (int low = 0; low < n; low += k) {
            if (low + k / 2 - 1 >= n - 1) continue;
            int high = (low + k - 1) < n ? low + k - 1 : n - 1;
            merge(arr, low, low + k / 2 - 1, high);
        }
        k <<= 1;
    }
    if (k / 2 <= n) {
        merge(arr, 0, k / 2 - 1, n - 1);
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

代码测试

为了调用和输出更加方便，撰写了如下代码进行输出：

vector<int> copyArray(vector<int> arr) {
    return vector<int>(arr.begin(), arr.end());
}
void printArray(vector<int> arr) {
    cout << "array = [";
    for (int i = 0; i < arr.size() - 1; ++i) {
        cout << arr[i] << ", ";
    }
    cout << *arr.rbegin() << "]" << endl;
}

以下是对应的测试代码：

int main() {
    // 实现八大排序 (排序结果都是从小到大排序), 加入输出比较次数。
    vector<int> arr{12, 9, 19, 229, 210, 39, 67, 346, 234, 2, 2, 3, 3, 4, 5, 2, 7, 6, 8, 0};
    cout <<  "排序前原数组： " << endl;
    printArray(arr);
    cout <<  "直接插入排序： ";
    printArray(directInsertSort(arr));
    cout <<  "折半插入排序： ";
    printArray(binaryInsertSort(arr));
    cout <<  "希尔插入排序： ";
    printArray(shellInsertSort(arr));
    cout <<  "冒泡交换排序： ";
    printArray(bubbleExchangeSort(arr));
    cout <<  "快速排序： ";
    printArray(quickSort(arr));
    cout <<  "简单选择排序： ";
    printArray(simpleSelectSort(arr));
    cout <<  "堆排序： ";
    printArray(heapSort(arr));
    cout <<  "基数排序： " << endl;
    printArray(baseNumberSort(arr));
    cout <<  "归并排序： ";
    printArray(MergeSort(arr));
    return 0;
}

代码测试结果：

排序前原数组： 
array = [12, 9, 19, 229, 210, 39, 67, 346, 234, 2, 2, 3, 3, 4, 5, 2, 7, 6, 8, 0]
直接插入排序： 算法比较次数为：153  排序结果为： 
array = [0, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 12, 19, 39, 67, 210, 229, 234, 346]
折半插入排序： 算法比较次数为：74  排序结果为： 
array = [0, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 12, 19, 39, 67, 210, 229, 234, 346]
希尔插入排序： 算法比较次数为：399  排序结果为： 
array = [0, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 12, 19, 39, 67, 210, 229, 234, 346]
冒泡交换排序： 算法比较次数为：180  排序结果为： 
array = [0, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 12, 19, 39, 67, 210, 229, 234, 346]
快速排序： 算法比较次数为：109  排序结果为： 
array = [0, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 12, 19, 39, 67, 210, 229, 234, 346]
简单选择排序： 算法比较次数为：210  排序结果为： 
array = [0, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 12, 19, 39, 67, 210, 229, 234, 346]
堆排序： 算法比较次数为：257  排序结果为： 
array = [0, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 12, 19, 39, 67, 210, 229, 234, 346]
基数排序： 
array = [0, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 12, 19, 39, 67, 210, 229, 234, 346]
归并排序： 算法比较次数为：64  排序结果为： 
array = [0, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 12, 19, 39, 67, 210, 229, 234, 346]

从代码测试结果来看，代码实现应该没有很大的问题，放心食用~
写作不易，欢迎点赞~

以下是完整代码，可供复制：

#include<bits/stdc++.h>

using namespace std;

vector<int> copyArray(vector<int> arr) {
    return vector<int>(arr.begin(), arr.end());
}
void printArray(vector<int> arr) {
    cout << "array = [";
    for (int i = 0; i < arr.size() - 1; ++i) {
        cout << arr[i] << ", ";
    }
    cout << *arr.rbegin() << "]" << endl;
}

vector<int> directInsertSort(vector<int> arr) {
    // 实现直接插入排序
    int cnt = 0; // 对比较次数进行计数
    int tmp = -INT_MAX, n = arr.size();
    for (int i = 1; i < n; ++i) {
        if (arr[i - 1] > arr[i]) {
            tmp = arr[i];
            // [0, ..., i - 1] 都是有序的, 将 arr[i] 插入进去
            int j = i - 1;
            while (j >= 0 && ++cnt && arr[j] > tmp) {
                arr[j + 1] = arr[j];
                --j;
            }
            arr[j + 1] = tmp;
        }
        ++cnt;
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

vector<int> binaryInsertSort(vector<int> arr) {
    // 在简单排序的基础上加入折半（二分查找位置）
    int cnt = 0; // 对比较次数进行计数
    int tmp = -INT_MAX, n = arr.size();
    for (int i = 1; i < n; ++i) {
        if (arr[i - 1] > arr[i]) {
            // [0, ..., i - 1] 都是有序的, 将 arr[i] 插入进去
            // 为了实现稳定排序，应当查找的是 >= (arr[i] + 1) 元素的第一个位置
            int left = 0, right = i - 1;
            tmp = arr[i] + 1;
            while (left <= right) { // [left, right]
                int mid = left + ((right - left) >> 1);
                if (arr[mid] < tmp) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
                ++cnt;
            }
            int j = i - 1;
            while (j >= left) {
                arr[j + 1] = arr[j];
                --j;
            }
            arr[left] = tmp - 1;
        }
        ++cnt;
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

vector<int> shellInsertSort(vector<int> arr) {
    // 实现简单插入排序的基础上，优化移动次数成希尔排序
    int cnt = 0; // 对比较次数进行计数
    int tmp = -INT_MAX, n = arr.size();
    // 初始化窗口大小
    int dx = 1;
    while (dx <= n / 2) dx <<= 1;
    while (dx) {
        for (int i = 0; i < n - dx; ++i) {
            for (int k = i + dx; k < n; k += dx) {
                if (arr[k - dx] > arr[k]) { // 内部使用简单插入排序
                    tmp = arr[k];
                    // [i, i + dx, ..., k - dx] 都是有序的, 将 arr[k] 插入进去
                    int j = k - dx;
                    while (j >= 0 && ++cnt && arr[j] > tmp) {
                        arr[j + dx] = arr[j];
                        j -= dx;
                    }
                    arr[j + dx] = tmp;
                }
                ++cnt;
            }
        }
        dx >>= 1;
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

vector<int> bubbleExchangeSort(vector<int> arr) {
    // 实现冒泡排序
    int cnt = 0; // 对比较次数进行计数
    int tmp = -INT_MAX, n = arr.size();
    for (int i = 0; i < n; ++i) {
        bool flag = false; // 记录本回合是否发生交换
        for (int j = n - 1; j > i; --j) {
            if (++cnt && arr[j] < arr[j - 1]) {
                swap(arr[j], arr[j - 1]);
                flag = true;
            }
        }
        if (!flag) {
            cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
            return arr; // 当前已经排序完成了
        }
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

int partion(vector<int>& arr, int left, int right, int& cnt) {
    int x = arr[left];
    while (left < right) {
        while (right > left && ++cnt && arr[right] >= x) --right;
        arr[left] = arr[right];
        while (left < right && ++cnt && arr[left] <= x) ++left;
        arr[right] = arr[left];
    }
    arr[left] = x;
    return left;
}
int quickSort(vector<int>& arr, int left, int right) {
    int cnt = 0;
    if (left >= right) return cnt;
    int mid = partion(arr, left, right, cnt);
    cnt += quickSort(arr, left, mid - 1);
    cnt += quickSort(arr, mid + 1, right);
    return cnt;
}
vector<int> quickSort(vector<int> arr) {
    // 实现快速排序, 使用第一个元素作为基准元素
    int n = arr.size();
    int cnt = quickSort(arr, 0, n - 1);
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

vector<int> simpleSelectSort(vector<int> arr) {
    // 实现简单选择排序
    int cnt = 0; // 对比较次数进行计数
    int n = arr.size();
    for (int i = 0; i < n; ++i) {
        int min_value = INT_MAX, min_loc = -1;
        for (int j = i; j < n; ++j) {
            if (++cnt && min_value > arr[j]) {
                min_loc = j;
                min_value = arr[j];
            }
        }
        swap(arr[i], arr[min_loc]);
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

void adjustHeap(vector<int>& arr, int j, int back, int& cnt) {
    while (j < back) {
        int left = INT_MAX, right = INT_MAX;
        if (2 * j < back) left = arr[2 * j];
        if (2 * j + 1 < back) right = arr[2 * j + 1];
        cnt += 2;
        if (left < arr[j] && right < arr[j]) {
            if (left < right) {
                swap(arr[j], arr[2 * j]);
                j = 2 * j;
            } else {
                swap(arr[j], arr[2 * j + 1]);
                j = 2 * j + 1;
            }
            ++cnt;
        } else if (left < arr[j]) {
            swap(arr[j], arr[2 * j]);
            j = 2 * j;
        } else if (right < arr[j]) {
            swap(arr[j], arr[2 * j + 1]);
            j = 2 * j + 1;
        } else break; // 无法调整树型
    }
}
vector<int> heapSort(vector<int> arr) {
    // 实现堆排序
    int cnt = 0; // 对比较次数进行计数
    // 构建小根堆
    int n = arr.size();
    for (int i = n / 2; i >= 0; --i) {
        adjustHeap(arr, i, n, cnt);
    }
    // 输出排序结果
    vector<int> tmp(n);
    int back = n - 1;
    for (int i = 0; i < n; ++i) {
        // 弹出堆顶元素
        tmp[i] = arr[0];
        // 调整堆
        arr[0] = arr[back];
        adjustHeap(arr, 0, back, cnt);
        back--;
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return tmp;
}

vector<int> baseNumberSort(vector<int> arr) {
    // 实现基数排序, 最低位优先
    vector<vector<int>> nums(10);
    int cur = 1; // 当前位数
    int tmp = 10; // 非空桶个数
    while (tmp > 1) {
        // 入桶
        for (int num : arr)
            nums[num / cur % 10].push_back(num);
        // 出桶
        tmp = 0;
        arr.clear();
        for (auto& arr1 : nums) {
            tmp += (arr1.size() != 0);
            for (auto num : arr1) {
                arr.push_back(num);
            }
            arr1.clear();
        }
        cur *= 10;
    }
    return arr;
}

vector<int> MergeSort(vector<int> arr) {
    // 实现归并排序, 使用二路归并
    int cnt = 0; // 对比较次数进行计数

    function<void(vector<int>&, int, int, int)> merge = [&](vector<int>& arr, int low, int mid, int high) {
        // [low, mid], [mid + 1, high] 有序，合并两个区间
        vector<int> tmp(high - low + 1);
        int left = low, right = mid + 1, ix = 0; // 双指针
        while (left <= mid || right <= high) {
            tmp[ix++] = arr[left] < arr[right] ? arr[left++] : arr[right++], ++cnt;
            while (left > mid && right <= high) tmp[ix++] = arr[right++];
            while (right > high && left <= mid) tmp[ix++] = arr[left++];
        }
        for (int i = low; i <= high; ++i)
            arr[i] = tmp[i - low];
        tmp.clear();
    };
    
    int k = 2, n = arr.size();
    while (k <= n) {
        for (int low = 0; low < n; low += k) {
            if (low + k / 2 - 1 >= n - 1) continue;
            int high = (low + k - 1) < n ? low + k - 1 : n - 1;
            merge(arr, low, low + k / 2 - 1, high);
        }
        k <<= 1;
    }
    if (k / 2 <= n) {
        merge(arr, 0, k / 2 - 1, n - 1);
    }
    cout << "算法比较次数为：" << cnt << "  排序结果为： " << endl;
    return arr;
}

int main() {
    // 实现八大排序 (排序结果都是从小到大排序), 加入输出比较次数。
    vector<int> arr{12, 9, 19, 229, 210, 39, 67, 346, 234, 2, 2, 3, 3, 4, 5, 2, 7, 6, 8, 0};
    cout <<  "排序前原数组： " << endl;
    printArray(arr);
    cout <<  "直接插入排序： ";
    printArray(directInsertSort(arr));
    cout <<  "折半插入排序： ";
    printArray(binaryInsertSort(arr));
    cout <<  "希尔插入排序： ";
    printArray(shellInsertSort(arr));
    cout <<  "冒泡交换排序： ";
    printArray(bubbleExchangeSort(arr));
    cout <<  "快速排序： ";
    printArray(quickSort(arr));
    cout <<  "简单选择排序： ";
    printArray(simpleSelectSort(arr));
    cout <<  "堆排序： ";
    printArray(heapSort(arr));
    cout <<  "基数排序： " << endl;
    printArray(baseNumberSort(arr));
    cout <<  "归并排序： ";
    printArray(MergeSort(arr));
    return 0;
}
kongchen1024
关注
考研数据结构 C & C++ 基础
XSES_yasuoman的博客
08-13 1704
C/C++基础 文章目录C/C++基础变量长度，存储空间常量运算符类型转换循环静态变量和递归静态变量递归指针和数组指针数组指针数组指向函数的指针结构体和类结构体指向结构体的指针结构体自引用**C 使用结构体****C++ 使用结构体 / 类**使用 struct 关键字使用 class动态分配内存C 中使用 malloc 函数C ++ 中使用 new 关键字输入输出C/C++ 格式化输入输出输入输出C++ cin coutcincout 变量长度，存储空间 1 字节 = 8 bit char 1 个字符 i
数据结构考研
07-11
数据结构1800题1. 算法的计算量的大小称为计算的（ ）。【北京邮电大学2000 二、3 （20/8分）】 A．效率 B. 复杂性 C. 现实性 D. 难度 2. 算法的时间复杂度取决于（ ）【中科院计算所 1998 二、1 （2分）】 A．问题的规模 B. 待处理数据的初态 C. A和B 3.计算机算法指的是（1），它必须具备（2） 这三个特性。 (1) A．计算方法 B. 排序方法 C. 解决问题的步骤序列 D. 调度方法 (2) A．可执行性、可移植性、可扩充性 B. 可执行性、确定性、有穷性 C. 确定性、有穷性、稳定性 D. 易读性、稳定性、安全性 【南京理工大学 1999 一、1（2分） 【武汉交通科技大学 1996 一、1（ 4分）】 4．一个算法应该是（ ）。【中山大学 1998 二、1（2分）】 A．程序 B．问题求解步骤的描述 C．要满足五个基本特性 D．A和C. 5. 下面关于算法说法错误的是（ ）【南京理工大学 2000 一、1（1.5分）】 A．算法最终必须由计算机程序实现 B.为解决某问题的算法同为该问题编写的程序含义是相同的 C. 算法的可行性是指指令不能有二义性 D. 以上几个都是错误的 6. 下面说法错误的是（ ）【南京理工大学 2000 一、2 （1.5分）】 (1）算法原地工作的含义是指不需要任何额外的辅助空间 （2）在相同的规模n下，复杂度O(n)的算法在时间上总是优于复杂度O(2n)的算法 （3）所谓时间复杂度是指最坏情况下，估算算法执行时间的一个上界 （4）同一个算法，实现语言的级别越高，执行效率就越低 A．(1) B.(1),(2) C.(1),(4) D.(3) 7．从逻辑上可以把数据结构分为（ ）两大类。【武汉交通科技大学 1996 一 、4（2分）】 A．动态结构、静态结构 B．顺序结构、链式结构 C．线性结构、非线性结构 D．初等结构、构造型结构
【数据结构】考研复习笔记（C++）——指针
qq_44899247的博客
04-12 456
本人对C++ 、数据结构、指针都不太熟悉，笔记根据天勤2022考研数据结构的网课和《高分笔记》记录，仅供学习，如有错误望指出！！ 直接先上代码： int *a = &p; 这是标准的指针的定义格式（值类型） 定义了a这个整型指针变量，指向p的地址。 此刻的输出： int p = 12; int *a = &p; cout<<"p:"<<p<<endl; cout<<"a:"<<a<<endl; cout<<
考研c++数据结构 线性表高分复习笔记
gangangan0001的博客
10-27 631
基础概念 A1-A2-A3-...An 数据元素被一条线串起来 定义 线性表是具有相同特性数据元素的有限序列 相同特性 把同一类事物归类，方便批量处理 有限 表中元素个数为n，n有限大，n可以为0 序列 表中元素排成一排，体现了一对一的逻辑特性(每个元素有且仅有一个前驱和后继) 存储结构 顺序结构 利用数组来实现顺序的存储，使用位置关系来体现逻辑关系 A ...
数据结构 c++代码_数据结构考研如何120+？
weixin_39886251的博客
11-29 390
// 政治的复习文出来啦，还在更新中，需要可以点馒头他爹：简单易懂，考研政治怎么复习？关于考研复习安排以及数据结构复习有什么疑问的，都可以私信或者评论，有空一定会回复和解答。后面我还会写一篇关于考研整体复习的文，有需要可以关注一下。第一次写文，有什么问题请见谅，欢迎提意见啦。// 2020.8.18 更新 私信问题：初试复习时需不需要上机敲代码？这个问题经常有研友私信或者评论问我，更新文章统一回复...
王道数据结构课代表 - 考研数据结构 第八章 排序（内部排序：八大排序动图演示与实现 + 外部排序） 究极精华总结笔记（C版本）
clzZ2的博客
01-24 8214
数据结构与算法 笔记导航🚥🚥🚥 🥬 第一章 绪论 🥕 第二章 线性表 🥪 第三章 栈和队列 🍊 第四章 串-KMP(看毛片算法) 🍒 第五章 树和二叉树 🍀 第六章 图 🍚 第七章 查找(B树、散列表) 🧄 第八章 排序 (内部排序：八大排序动图演示与实现 + 外部排序) 🍔 数据结构与算法 复试精简笔记 🎨 408 全套初复试笔记汇总 传送门 🏃‍🏃‍🏃‍ 如果本篇文章对大家起到帮助的话，跪求各位帅哥美女们，求赞👍 、求收藏、求关注！
【408精华知识】史上最全的数据结构代码题总结！三万字长文！！！
weixin_51193374的博客
06-13 3961
代码作为一种和计算机交流的语言，要遵守程序语言世界的规范，接下来我们全部采用C语言书写代码。规范表达DataType 变量名 = 赋值内容DataType可以是常见数据类型int、string等，也可以是结构体比如LNode，还可以是指针LNode*、LinkList，变量名可以是单个数据，也可以是数组。关于数组DataType 变量名 [ Maxsize ]#define 常量名 值关于lnode * p的含义：p是一个指针，它指向lnode类型的变量，它是一个lnode型变量的地址；
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
*5.6 C＋＋处理字符串的方法——字符串类与字符串变量 5.6.1 字符串变量的定义和引用 5.6.2 字符串变量的运算 5.6.3 字符串数组 5.6.4 字符串运算举例 习题 第6章 指针 6.1 指针的概念 6.2 变量与指针 6.2.1 定义...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar )
06-13
*5.6 C＋＋处理字符串的方法——字符串类与字符串变量 5.6.1 字符串变量的定义和引用 5.6.2 字符串变量的运算 5.6.3 字符串数组 5.6.4 字符串运算举例 习题 第6章 指针 6.1 指针的概念 6.2 变量与指针 6.2.1 定义...
912数据结构教材_怎样科学复习考研数据结构
weixin_39631755的博客
10-21 686
多年以后，面对考卷，你将会回想起，教授带你去见识数据结构的那个遥远的下午。 数据结构是计算机最重要的专业课，只要还在干这行就逃不掉数据结构的学习和应用。这门课在统考中占到了45分（满分150分），然而这一门课又像毕加索一样抽象，对跨考的同学非常不友好，因此今天就来谈谈数据结构的复习。（本文前边废话较多，不想看的同学可以直接拉到最后一部分：怎样看书。） 知彼知己者，百战...
哈尔滨工程大学计算机院考研——常见问题第二弹
qq_39537623的博客
06-10 731
为什么学硕报录比这么高呀，我看其他学校不都是学硕少，专硕报的多的吗，是不是因为以前都是数一英语的缘故所以专硕报的少 报录比是不公布的，或许你说的是复试比？ 个人认为学硕的复试比高是因为今年允许校内调剂了。以2019为例，计科和软件学硕的复试比都不超过150%，专硕都需调剂。但是复试过程中会淘汰录取计划外的人数，也就是说如果复试及格但没有进入到录取名额内的人，无资格调剂到计算机院其他专业。2020计科学硕复试比高达190%，软件学硕168%，但是复试及格却没有进入到录取名额内的人，可以调剂到网安学硕或是电子
2019数据结构考研(一)
热门推荐
Oceansidexue的博客
02-12 2万+
2019数据结构考研(一) 知识框架 数据结构的基本概念 数据:数据是信息的载体,是所有能描述事物属性的数,字符以及所有能输入到计算机被计算机程序识别和处理的符号的集合 数据元素:数据元素是数据的基本单位 数据项:数据项是构成数据元素不可分割的最小单位 注意:不要混淆数据,数据元素和数据项,例如:学生记录就是一个数据元素,它由学号,姓名,性别等数据项组成 数据对象:数据对象是...
考研数据结构必备的C++语法
我的笔记
08-21 1681
1、输入输出 先看C语言的输入输出 //整数的输入输出 int a; scanf("%d", &a); printf("%d", a); //小数的输入输出 double b; scanf("%ld", &b); printf("%ld", b); //字符串的输入输出 char name[50]; scanf("%s",name); printf("%s",name); //输入输出两整数 int m,n; scanf("%d %d", &m,&n); prin
数据结构考研可能涉及的c/c++函数
sazass的博客
10-19 719
<1> char index(const chars ,int c) 功能：用来找出参数s字符串中第一个出现参数c的地址，然后将该字符串出现的地址返回； e.x. char *s = "abcd1234abcd"; char *p = index(s, 'c'); printf("%s\n",p); 结果：cd1234abcd <2> char *...
数据结构（二叉树）
最新发布
2301_80475151的博客
10-04 988
数据结构的二叉树、顺序结构的树和链式结构的树的实现
【笔记】数据结构12
m0_52024881的博客
09-29 589
看到的社区的一个知识总结，这里记录一下。
数据结构之树（3）
2301_76246515的博客
09-29 395
重要！树->二叉树由于孩子兄弟链式存储和二叉树链式存储本质相同，故树可转换为二叉树。森林->二叉树森林：m棵互不相交的树的集合森林->树 树->二叉树森林中各个树的根节点之间视为兄弟关系。
栈数据结构:定义，基本操作与应用
m0_66847953的博客
10-03 865
栈（Stack）是一种特殊的线性数据结构，其插入和删除操作都只允许在表的一端进行。这一端被称为栈顶（top），另一端则被称为栈底（bottom）。栈遵循后进先出（Last In First Out，LIFO）的规则，即最后存入的元素将被最先取出。顺序栈采用一个数组存放栈中的元素。如果需要用到两个类型相同的栈，这时若为它们各自开辟一个数组空间,极有可能出现这样的情况：第一个栈已满,再进栈就溢出了，而另一个栈还有很多空闲的存储空间。解决这个问题的方法是。
C++实现八大经典排序算法详解与代码示例
本文详细介绍了如何在C++中实现八个常见的排序算法，包括插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序以及LST基数排序。这些排序算法在计算机科学中具有重要的地位，它们在数据处理、数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值