数据结构机测一

顺序表应用4-2：元素位置互换之逆置算法(数据改进） 

#include <cstdio>
#include <iostream>
#define max 1000005
using namespace std;
int *data;
int m, len;

// 元素翻转   如 1 2 3 4 5   ---》   5 4 3 2 1
void reverse(int begin, int end, int m) {
    for (int i = 0; i < m; i++) {
        int temp = data[begin];
        data[begin++] = data[end];
        data[end--] = temp;
    }
}

int main() {
    int t;
    // 下面两种是在堆里申请内存  int data[1000000] 是在栈里申请
    // data = new int[max];
    data = (int *)malloc(max * sizeof(int));  // 不手动申请内存  会爆内存
    scanf("%d", &len);
    for (int i = 0; i < len; i++) {
        scanf("%d", &data[i]);
    }
    scanf("%d", &t);
    while (t--) {
        scanf("%d", &m);

        reverse(0, len - 1, len / 2);      // 变成 -1 9 8 7 6 5 4 3 2 1
        reverse(len - m, len - 1, m / 2);  // 变成 -1 9 8 7 6 5 4 3   1 2
        reverse(0, len - m - 1, (len - m) / 2);  // 变成 3 4 5 6 7 8 9 -1   1 2

        for (int i = 0; i < len; i++) {
            if (i == len - 1) {
                printf("%d\n", data[i]);
            } else {
                printf("%d ", data[i]);
            }
        }
    }

    return 0;
}

顺序表应用7：最大子段和之分治递归法

// #include <bits/stdc++.h>
#include <cstdio>
#include <iostream>
using namespace std;
int a[50005];
int cnt;
int make(int l, int r) {
    int ans = 0;
    cnt++;
    if (l == r) {
        if (a[l] >= 0) {
            ans = a[l];
        } else {
            ans = 0;
        }
    } else {
        int mid = (l + r) / 2;
        int lsum = make(l, mid);
        int rsum = make(mid + 1, r);
        int sum1 = 0, temp = 0, sum2 = 0;

        for (int i = mid; i >= l; i--) {
            temp += a[i];
            sum1 = max(sum1, temp);
        }
        temp = 0;
        for (int i = mid + 1; i <= r; i++) {
            temp += a[i];
            sum2 = max(sum2, temp);
        }
        ans = max(lsum, rsum);
        ans = max(sum1 + sum2, ans);
    }
    return ans;
}
int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    cnt = 0;
    int ans = make(1, n);
    // 直接输出返回的函数会报错
    // printf("%d %d\n", make(1, n), cnt);
    printf("%d %d\n", ans, cnt);

    return 0;
}

G - 顺序表应用8：最大子段和之动态规划法

#include <stdlib.h>
#include <cstdio>
#include <iostream>
int main() {
    int n, sum, max, i, a[100005];
    scanf("%d", &n);
    sum = 0;
    max = 0;
    for (i = 0; i < n; i++) {
        scanf("%d", &a[i]);  //将元素存在数组当中
    }
    for (i = 0; i < n; i++) {
        sum += a[i];
        if (sum < 0) {
            sum = 0;
        }
        if (sum > max) {
            max = sum;
        }
    }
    printf("%d\n", max);
}

 

数据结构实验之链表八：Farey序列

using namespace std;
struct node {
    int a, b;
    node *next;
};

int n;
int main() {
    cin >> n;
    node *head, *p, *q, *t;
    head = new node;
    head->next = NULL;
    // 初始化结点1
    p = new node;
    p->a = 0;
    p->b = 1;
    p->next = NULL;
    // 初始化结点2
    q = new node;
    q->a = 1;
    q->b = 1;
    q->next = NULL;
    // 结点连接
    head->next = p;
    p->next = q;
    // 遍历2--n级
    for (int i = 2; i <= n; i++) {
        p = head->next;
        while (p->next) {
            t = p->next;
            if (p->b + t->b <= n) {
                q = new node;
                q->b = p->b + t->b;
                q->a = p->a + t->a;
                q->next = NULL;

                p->next = q;
                q->next = t;
            }

            p = p->next;
        }
    }

    int cnt = 0;
    p = head->next;
    while (p) {
        cnt++;
        if (p == head->next) {
            printf("%d/%d\t", p->a, p->b);
        } else {
            if (cnt % 10 == 0 || p->next == NULL) {
                printf("%d/%d\n", p->a, p->b);
            } else {
                printf("%d/%d\t", p->a, p->b);
            }
        }

        p = p->next;
    }

    return 0;
}

数据结构实验之栈与队列二：一般算术表达式转换成后缀式

/*
    中缀表达式转后缀表达式的方法：
    1.遇到操作数：直接输出（添加到后缀表达式中）
    2.栈为空时，遇到运算符，直接入栈
    3.遇到左括号：将其入栈
    4.遇到右括号：执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出。
    5.遇到其他运算符：加减乘除：弹出所有优先级大于或者等于该运算符的栈顶元素，然后将该运算符入栈
    6.最终将栈中的元素依次出栈，输出。
*/
using namespace std;
int top = 0;
int main() {
    char s[100001], stack[100001];
    scanf("%s", s);
    for (int i = 0; s[i] != '#'; i++) {
        if (s[i] >= 'a' && s[i] <= 'z') {
            printf("%c", s[i]);
        } else if (s[i] == '(') {
            stack[++top] = s[i];
        } else if (s[i] == ')') {
            while (stack[top] != '(') {
                printf("%c", stack[top--]);
            }
            top--;
        } else if (s[i] == '+' || s[i] == '-') {
            while (top != 0 && stack[top] != '(') {
                printf("%c", stack[top--]);
            }
            stack[++top] = s[i];
        } else if (s[i] == '*' || s[i] == '/') {
            while (top != 0 && stack[top] != '(' &&
                   (stack[top] == '*' || stack[top] == '/')) {
                printf("%c", stack[top--]);
            }
            stack[++top] = s[i];
        }
    }
    while (top != 0) {
        printf("%c", stack[top--]);
    }
    return 0;
}

数据结构实验之栈与队列三：后缀式求值

#include <stdio.h>
#include <string.h>
int top = 0, i, b[1000];
int main() {
    char s;
    while (scanf("%c", &s), s != '#') {
        if (s >= '0' && s <= '9') {
            b[++top] = s - '0';
        } else if (s == '+' || s == '-' || s == '*' || s == '/') {
            if (s == '+') {
                b[top - 1] = b[top - 1] + b[top];
                top--;
            }
            if (s == '-') {
                b[top - 1] = b[top - 1] - b[top];
                top--;
            }
            if (s == '*') {
                b[top - 1] = b[top - 1] * b[top];
                top--;
            }
            if (s == '/') {
                b[top - 1] = b[top - 1] / b[top];
                top--;
            }
        }
    }
    printf("%d\n", b[top]);
    return 0;
}

数据结构实验之栈与队列六：下一较大值（二）

using namespace std;
int main() {
    int t, n;
    int a[100001];      // 存放输入值
    int b[100001];      // 存放较大值
    int stack[100001];  // 栈
    ios::sync_with_stdio(false);
    cin >> t;
    while (t--) {
        cin >> n;
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        b[n - 1] = -1;  // 顺序输入的最后一个数无较大值
        int top = 0;    // 栈空
        for (int i = n - 2; i >= 0; i--) {
            int flag = 0;
            if (a[i + 1] > a[i]) {
                b[i] = a[i + 1];
                stack[++top] = a[i + 1];  // 较大的入栈
            } else {
                while (top != 0) {
                    if (stack[top] > a[i]) {
                        b[i] = stack[top];
                        flag = 1;
                        break;
                    }
                    top--;
                }
                if (flag == 0) b[i] = -1;  // 如果栈内没有比a[i]更大的
            }
        }
        for (int i = 0; i < n; i++) {
            cout << a[i] << "-->" << b[i] << endl;
        }
        if (t != 0) cout << endl;
    }

    return 0;
}

数据结构实验之栈与队列七：出栈序列判定

using namespace std;
int main() {
    int t, n, m;
    int a[10001];
    int b[10001];  // 栈
    ios::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    cin >> t;
    while (t--) {
        for (int i = 0; i < n; i++) {
            cin >> b[i];
        }

        int stack[10001], top = 0;
        for (int i = 0, j = 0; j < n;) {
            if (a[i] == b[j]) {
                i++;
                j++;
            } else if (top != 0 && stack[top] == b[j]) {
                j++;
                top--;
            } else if (i < n) {
                stack[++top] = a[i++]; // 必须是++top  不然上面条件要修改
            } else {
                break;
            }
        }
        printf(top == 0 ? "yes\n" : "no\n");
    }

    return 0;
}

数据结构实验之栈与队列九：行编辑器

using namespace std;
int main() {
    char s[255];
    while (gets(s)) {
        char stack[255];
        int top = 0;
        for (int i = 0; i < strlen(s); i++) {
            if (s[i] == '#') {
                // 这里注意  如果top！=0写到上面的话  #有可能被压进栈
                if (top != 0) {
                    top--;
                }
            } else if (s[i] == '@') {
                top = 0;
            } else {
                stack[++top] = s[i];
            }
        }
        if (top != 0) {
            for (int i = 1; i <= top; i++) {  // 注意i从1 开始 否则报错
                cout << stack[i];
            }
            cout << endl;
        }
    }
    return 0;
}

数据结构实验之栈与队列十：走迷宫

using namespace std;

int ans, n, m;
int gra[111][111];  // 矩阵
int vis[111][111];  // 标记
void dfs(int x, int y) {
    if (x >= n || y >= m || x < 0 || y < 0) return;
    if (x == n - 1 && y == m - 1) {
        ans++;
        return;
    }
    if (vis[x][y] == 0 && gra[x][y] == 0) {
        vis[x][y] = 1;
        dfs(x + 1, y);
        dfs(x, y + 1);
        dfs(x - 1, y);
        dfs(x, y - 1);
        vis[x][y] = 0;  // 递归完后 点标为未走过  防止影响其他情况
    }
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        memset(gra, 0, sizeof(gra));
        memset(vis, 0, sizeof(vis));
        cin >> n >> m;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                cin >> gra[i][j];
            }
        }
        ans = 0;
        dfs(0, 0);
        cout << ans << endl;
    }

    return 0;
}

数据结构实验之栈与队列十一：refresh的停车场

using namespace std;
int main() {
    int n, m, flag;
    string a, b;
    while (cin >> n >> m) {
        flag = 0;
        queue<string> q;
        stack<string> s;
        while (m--) {
            cin >> a;
            if (a == "Add") {
                cin >> b;
                if (s.size() < n) {
                    s.push(b);  // 有车位 进入停车栈
                } else
                    q.push(b);  // 无车位 进入排队队列
            }
            if (a == "Del") {
                if (s.empty())
                    flag = 1;
                else {
                    s.pop();
                    if (!q.empty()) s.push(q.front());  // 排队车 进入 停车栈
                }
            }
            if (a == "Out") {
                if (q.empty())
                    flag = 1;
                else
                    q.pop();
            }
        }
        if (flag == 1)
            cout << "Error" << endl;
        else {
            while (!s.empty()) {
                cout << s.top() << endl;
                s.pop();
            }
        }
    }
}

 

来源：CSDN

作者：QXQZX_

链接：https://blog.csdn.net/Cherishlife_/article/details/102489026