王道数据结构编程题（顺序存储线性表）

已于 2022-03-13 16:21:41 修改
阅读量984 收藏 7
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 c语言 数组
于 2022-03-01 21:51:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43686863/article/details/123202931
版权

1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删运算的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。

输入样例：
5
3 4 1 6 7
6
5 2 7 9 3 6
0

输出样例：
1
3 4 6 7
2
5 6 7 9 3
error


#include <stdio.h>

#define MAX_SIZE 100

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

int ListDelete(SqList *L);

int main() {
    SqList L;

    while (scanf("%d", &L.length) && L.length!= 0) {
        for (int i = 0; i < L.length; i++) {
            scanf("%d", &(L.data[i]));
        }
        printf("%d\n", ListDelete(&L));
        ListPrint(L);
    }
    printf("error");
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

int ListDelete(SqList *L) {
    int min_pos = 0, min_val = 0;

    for (int i = 0; i < L->length; i++) {
        if (L->data[i] < L->data[min_pos]) min_pos = i;
    }
    min_val = L->data[min_pos];
    L->data[min_pos] = L->data[L->length - 1];
    L->length--;
    return min_val;
}

2.设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为 O ( 1 ) O(1) O(1)。

输入样例：
5
3 4 1 6 7
6
5 2 7 9 3 6
0

输出样例：
7 6 1 4 3
6 3 9 7 2 5


#include <stdio.h>

#define MAX_SIZE 100

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

void ListInvert(SqList *L);

int main() {
    SqList L;

    while (scanf("%d", &L.length) && L.length!= 0) {
        for (int i = 0; i < L.length; i++) {
            scanf("%d", &(L.data[i]));
        }
        ListInvert(&L);
        ListPrint(L);
    }
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

void ListInvert(SqList *L) {
    for (int i = 0; i < L->length / 2; i++) {
        L->data[i] = L->data[i] + L->data[L->length - i - 1];
        L->data[L->length - i - 1] = L->data[i] - L->data[L->length - i - 1];
        L->data[i] = L->data[i] - L->data[L->length - i - 1];
    }
}

3.对长度为n的顺序表L，编写一个时间复杂度为 O ( n ) O(n) O(n)、空间复杂度为 O ( 1 ) O(1) O(1)的算法，该算法删除线性表中所有值为x的数据元素。

输入样例：
5
3 5 8 3 1
3
5
3 5 8 3 1
8
0

输出样例：
5 8 1
3 5 3 1


#include <stdio.h>

#define MAX_SIZE 100

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

void ListDelete(SqList *L, int x);

void ListDelete_(SqList *L, int x);

int main() {
    SqList L;

    while (scanf("%d", &L.length) && L.length!= 0) {
        int x;

        for (int i = 0; i < L.length; i++) {
            scanf("%d", &(L.data[i]));
        }
        scanf("%d", &x);
        ListDelete(&L, x);
        /*ListDelete_(&L, x);*/
        ListPrint(L);
    }
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

void ListDelete(SqList *L, int x) {
    int cursor = 0, offset = 0;//offset记录等于x的元素的个数

    while (cursor + offset < L->length) {
        if (L->data[cursor + offset] == x) {
            offset++;
        } else {
            L->data[cursor] = L->data[cursor + offset];//将当前不等于x的元素向前偏移offset
            cursor++;
        };
    }
    L->length -= offset;//更新顺序表长度
}

void ListDelete_(SqList *L, int x) {
    int slow = 0;

    for (int fast = 0; fast < L->length; fast++) {
        if (L->data[fast] != x) {
            L->data[slow] = L->data[fast];
            slow++;
        }
    }
    L->length = slow;//更新顺序表长度
}

4.从有序顺序表中删除其值在给定值s与t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示出错信息并退出运行。

输入样例：
5
1 2 3 4 5
2 4
6
5 6 7 8 9 10
8 10
0

输出样例：
1 5
5 6 7
error


#include <stdio.h>

#define MAX_SIZE 100

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

void ListDelete(SqList *L, int s, int t);

int main() {
    SqList L;

    while (scanf("%d", &L.length) && L.length!= 0) {
        int s, t;

        for (int i = 0; i < L.length; i++) {
            scanf("%d", &(L.data[i]));
        }
        scanf("%d %d", &s, &t);
        if (s >= t) break;
        ListDelete(&L, s, t);
        ListPrint(L);
    }
    printf("error");
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

void ListDelete(SqList *L, int s, int t) {
    int slow = 0;

    for (int fast = 0; fast < L->length; fast++) {
        if (L->data[fast] < s || L->data[fast] > t) {
            L->data[slow] = L->data[fast];
            slow++;
        }
    }
    L->length = slow;
}

5.从顺序表中删除其值在给定值s与t之间（包含s和t，要求s<t）的所有元素，若s或t不合理或顺序表为空，则显示出错信息并退出运行。

输入样例：
5
3 4 1 6 7
4 6
6
5 2 7 9 3 6
7 9
0

输出样例：
3 1 7
5 2 3 6


#include <stdio.h>

#define MAX_SIZE 100

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

void ListDelete(SqList *L, int s, int t);

int main() {
    SqList L;

    while (scanf("%d", &L.length) && L.length!= 0) {
        int s, t;

        for (int i = 0; i < L.length; i++) {
            scanf("%d", &(L.data[i]));
        }
        scanf("%d %d", &s, &t);
        if (s >= t) break;
        ListDelete(&L, s, t);
        ListPrint(L);
    }
    printf("error");
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

void ListDelete(SqList *L, int s, int t) {
    int slow = 0;

    for (int fast = 0; fast < L->length; fast++) {
        if (L->data[fast] < s || L->data[fast] > t) {
            L->data[slow] = L->data[fast];
            slow++;
        }
    }
    L->length = slow;
}

6.从有序表中删除所有其值重复的元素，使表中所有元素的值均不同。

输入样例：
5
1 2 2 2 3
10
1 2 2 2 3 4 4 4 5 5

输出样例：
1 2 3
1 2 3 4 5


#include <stdio.h>

#define MAX_SIZE 10

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

void ListDelete(SqList *L);

void ListDelete_(SqList *L);

int main() {
    SqList L;

    while (scanf("%d", &L.length) && L.length!= 0) {
        for (int i = 0; i < L.length; i++) {
            scanf("%d", &(L.data[i]));
        }
        /*ListDelete(&L);*/
        ListDelete_(&L);
        ListPrint(L);
    }
    printf("error");
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}
/*对有序表和无序表都适用*/
void ListDelete(SqList *L) {
    for (int i = 0; i < L->length; i++) {
        int same = 0;//重复元素的个数
        /*将当前元素与后面的所有元素进行比较*/
        for (int j = i + 1; j < L->length; j++) {
            if (L->data[i] == L->data[j]) {
                same++;
            } else {
                L->data[j - same] = L->data[j];
            }
        }
        L->length -= same;
    }
}
/*只能处理有序表*/
void ListDelete_(SqList *L) {
    int slow = 0, fast = 1;

    while (fast < L->length) {
        if (L->data[slow] != L->data[fast]) {
            L->data[++slow] = L->data[fast];
        }
        fast++;
    }
    L->length = slow + 1;
}

7.将两个有序顺序表合并为一个新的有序顺序表。

输入样例：
3 4
1 3 5
2 4 6 8
0 0

输出样例：
1 2 3 4 5 6 8


#include <stdio.h>

#define MAX_SIZE 10

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

void ListMerge(SqList A, SqList B, SqList *L);

int main() {
    SqList A;
    SqList B;

    while (scanf("%d %d", &A.length, &B.length) && A.length != 0 && B.length != 0) {
        SqList L;

        L.length = 0;
        for (int i = 0; i < A.length; i++) {
            scanf("%d", &(A.data[i]));
        }
        for (int i = 0; i < B.length; i++) {
            scanf("%d", &(B.data[i]));
        }
        ListMerge(A, B, &L);
        ListPrint(L);
    }
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

void ListMerge(SqList A, SqList B, SqList *L) {
    int cur_a = 0, cur_b = 0, cursor = 0;

    while (cur_a < A.length && cur_b < B.length) {
        if (A.data[cur_a] < B.data[cur_b]) {
            L->data[cursor++] = A.data[cur_a++];
            L->length++;
        } else {
            L->data[cursor++] = B.data[cur_b++];
            L->length++;
        }
    }
    while (cur_a < A.length) {
        L->data[cursor++] = A.data[cur_a++];
        L->length++;
    }
    while (cur_b < B.length) {
        L->data[cursor++] = B.data[cur_b++];
        L->length++;
    }
}

8.已知在一维数组A[m+n]中依次存放两个线性表 ( a 1 , a 2 , a 3 , … , a m ) (a_1, a_2, a_3, \dots, a_m) (a1​,a2​,a3​,…,am​)和 ( b 1 , b 2 , b 3 , … , b n ) (b_1, b_2, b_3, \dots, b_n) (b1​,b2​,b3​,…,bn​)。试编写一个函数，将数组中两个顺序表的位置互换，即将 ( b 1 , b 2 , b 3 , … , b n ) (b_1, b_2, b_3, \dots, b_n) (b1​,b2​,b3​,…,bn​)放在 ( a 1 , a 2 , a 3 , … , a m ) (a_1, a_2, a_3, \dots, a_m) (a1​,a2​,a3​,…,am​)前面。

输入样例：
2 3
1 2 3 4 5
2 5
1 2 3 4 5 6 7
0 0

输出样例：
3 4 5 1 2
3 4 5 6 7 1 2


#include <stdio.h>

#define MAX_SIZE 10

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

void ListInvert(SqList *L, int start, int end);

void ListSwap(SqList *L, int m, int n);

int main() {
    int m, n;
    SqList L;

    while (scanf("%d %d", &m, &n) && m != 0 && n != 0) {
        L.length = m + n;
        for (int i = 0; i < L.length; i++) {
            scanf("%d", &(L.data[i]));
        }
        ListSwap(&L, m, n);
        ListPrint(L);
    }
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

void ListSwap(SqList *L, int m, int n) {
    ListInvert(L, 0, L->length - 1);
    ListInvert(L, 0, n - 1);
    ListInvert(L, L->length - m, L->length - 1);
}

void ListInvert(SqList *L, int start, int end) {
    for (int i = start; i <= (start + end) / 2; i++) {
        int tmp = L->data[i];
        L->data[i] = L->data[start + end - i];
        L->data[start + end - i] = tmp;
    }
}

9.线性表 ( a 1 , a 2 , a 3 , … , a n ) (a_1, a_2, a_3, \dots, a_n) (a1​,a2​,a3​,…,an​)中的元素递增有序且按顺序存储于计算机内，要求设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置相交换，若找不到，则将其插入表中并使表中元素仍递增有序。

输入样例：
5
1 3 5 7 9
7
5
1 3 5 7 9
6
0

输出样例：
1 3 5 9 7
1 3 5 6 7 9


#include <stdio.h>

#define MAX_SIZE 10

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

void SearchExchangeInsert(SqList *L, int x);

int BinarySearch(SqList L, int key);

int main() {
    SqList L;

    while (scanf("%d", &(L.length)) && L.length != 0) {
        int x;

        for (int i = 0; i < L.length; i++) {
            scanf("%d", &(L.data[i]));
        }
        scanf("%d", &x);
        SearchExchangeInsert(&L, x);
        ListPrint(L);
    }
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

void SearchExchangeInsert(SqList *L, int x) {
    int pos = BinarySearch(*L, x);

    if (pos != -1) {
        /*exchange*/
        L->data[pos] = L->data[pos] + L->data[pos + 1];
        L->data[pos + 1] = L->data[pos] - L->data[pos + 1];
        L->data[pos] = L->data[pos] - L->data[pos + 1];
    } else {
        /*insert*/
        int i = L->length - 1;
        while (L->data[i] > x) {
            L->data[i + 1] = L->data[i];
            i--;
        }
        L->data[i + 1] = x;
        L->length++;
    }
}

int BinarySearch(SqList L, int key) {
    int low = 0, high = L.length - 1, mid;

    while (low < high) {
        mid = (low + high) / 2;
        if (L.data[mid] == key) {
            return mid;
        } else if (L.data[mid] > key) {
            high = mid - 1;//继续查找前半部分
        } else {
            low = mid + 1;//继续查找后半部分
        }
    }
    return -1;//查找失败
}

10.设将n（n>1）个整数存放到一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p（0<p<n）个位置，即将R中的数据由 ( X 0 , X 1 , … , X n − 1 ) (X_0, X_1, \dots, X_{n-1}) (X0​,X1​,…,Xn−1​)变换为 ( X p , X p + 1 , … , X n − 1 , X 0 , X 1 , … , X p − 1 ) (X_p, X_{p+1}, \dots, X_{n-1},X_0, X_1, \dots, X_{p-1}) (Xp​,Xp+1​,…,Xn−1​,X0​,X1​,…,Xp−1​)。

输入样例：
5
3 4 1 6 7
3
6
5 2 7 9 3 6
5
0

输出样例：
6 7 3 4 1
6 5 2 7 9 3


#include <stdio.h>

#define MAX_SIZE 10

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

void ListReverse(SqList *L, int low, int high);

void ListMove(SqList *L, int dis);

int main() {
    SqList L;
    int dis;

    while (scanf("%d", &(L.length)) && L.length != 0) {
        for (int i = 0; i < L.length; i++) {
            scanf("%d", &(L.data[i]));
        }
        scanf("%d", &dis);
        ListMove(&L, dis);
        ListPrint(L);
    }
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

void ListMove(SqList *L, int dis) {
    ListReverse(L, 0, L->length - 1);
    ListReverse(L, 0, L->length - dis - 1);
    ListReverse(L, L->length - dis, L->length - 1);
}

void ListReverse(SqList *L, int low, int high) {
    for (int i = low; i <= (high + low) / 2; i++) {
        int tmp = L->data[i];
        L->data[i] = L->data[high + low - i];
        L->data[high + low - i] = tmp;
    }
}

11.两个序列的中位数是含它们所有元素的升序序列的中位数。现在有两个等长升序序列A和B，请设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列的中位数。

输入样例：
3 3
1 5 8
2 4 6
5 5
1 3 4 6 7
2 3 5 6 7
0 0

输出样例：
4
4


#include <stdio.h>

#define MAX_SIZE 10

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

int FindMedian(SqList A, SqList B);

int main() {
    SqList A;
    SqList B;

    while (scanf("%d %d", &(A.length), &(B.length)) && A.length != 0 && B.length != 0) {
        for (int i = 0; i < A.length; i++) {
            scanf("%d", &(A.data[i]));
        }
        for (int i = 0; i < B.length; i++) {
            scanf("%d", &(B.data[i]));
        }
        printf("%d\n", FindMedian(A, B));
    }
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

int FindMedian(SqList A, SqList B) {
    int count = A.length;
    int cur_a = 0, cur_b = 0;
    int median;

    while (count-- > 0) {
        median = (A.data[cur_a] < B.data[cur_b]) ? A.data[cur_a++] : B.data[cur_b++];
    }
    return median;
}

12.对于一个含有n个元素的整数序列，如果元素x重复出现了m次且m>n/2，则称x为该序列的主元素。请设计一个尽可能高效的算法，找出一个序列的主元素，若存在输出该主元素，若不存在输出-1。

输入样例：
8
0 5 5 3 5 7 5 5
8
0 5 5 3 5 1 5 7
0

输出样例：
5
-1


#include <stdio.h>

#define MAX_SIZE 100

typedef struct SqList {
    int data[MAX_SIZE];
    int length;
} SqList;

void ListPrint(SqList L);

int GetMainEle(SqList L);

int main() {
    SqList L;

    while (scanf("%d", &(L.length)) && L.length != 0) {
        for (int i = 0; i < L.length; i++) {
            scanf("%d", &(L.data[i]));
        }
        printf("%d", GetMainEle(L));
    }
    return 0;
}

void ListPrint(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d%c", L.data[i], (i == L.length - 1) ? 10 : 32);
    }
}

int GetMainEle(SqList L) {
    int count[MAX_SIZE] = {0};
    for (int i = 0; i < L.length; i++) {
        count[L.data[i]]++;
    }
    for (int i = 0; i < MAX_SIZE; i++) {
        if (count[i] > L.length / 2)
            return i;
    }
    return -1;
}

13.给定一个含n个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。

输入样例：
5
-5 2 9 7 8
5
1 2 3 4 5
0

输出样例：
1
6


#include <stdio.h>

#define MaxSize 100

typedef struct SqList {
    int data[MaxSize];
    int len;
} SqList;

void ListQuickSort(SqList *sqList, int low, int high);
int ListPartition(SqList *sqList, int low, int high);

int GetMin(SqList sqList) {
    int minValue = 1;

    ListQuickSort(&sqList, 0, sqList.len - 1);
    for (int i = 0; i < sqList.len; i++) {
        if (minValue == sqList.data[i]) {
            minValue++;
        }
    }
    return minValue;
}

int main() {
    SqList L;

    while (scanf("%d%*c", &(L.len)) && L.len != 0) {
        for (int i = 0; i < L.len; i++) {
            scanf("%d%*c", &(L.data[i]));
        }
        printf("%d\n", GetMin(L));
    }
    return 0;
}

/**
 * quick sort
 * @param sqList
 * @param low
 * @param high
 */
void ListQuickSort(SqList *sqList, int low, int high) {
    if (low < high) {
        int pivotPosition = ListPartition(sqList, low, high);
        ListQuickSort(sqList, low, pivotPosition - 1);
        ListQuickSort(sqList, pivotPosition + 1, high);
    }
}

/**
 * separate all data by sqList->data[low]
 * @param sqList
 * @param low
 * @param high
 * @return
 */
int ListPartition(SqList *sqList, int low, int high) {
    int pivotValue = sqList->data[low];

    while (low < high) {
        while (low < high && sqList->data[high] > pivotValue) {
            high--;
        }
        sqList->data[low] = sqList->data[high];
        while (low < high && sqList->data[low] < pivotValue) {
            low++;
        }
        sqList->data[high] = sqList->data[low];
    }
    sqList->data[low] = pivotValue;
    return low;//return pivot position
}

14.定义三元组(a, b, c)的距离D=|a-b|+|b-c|+|c-a|。给定三个非空整数集合按升序分别存储在3个数组中。请设计一个尽可能高效的算法，计算并输出所有三元组中的最小距离。

输入样例：
3 4 5
-1 0 9
-25 -10 10 11
2 9 17 30 41
0 0 0

输出样例：
2


#include <stdio.h>
#include <stdbool.h>

#define MaxSize 100

typedef struct SqList {
    int data[MaxSize];
    int len;
} SqList;

int GetDistance(int x, int y, int z);
bool IsMinValue(int x, int y, int z);

int GetMin(SqList sqList1, SqList sqList2, SqList sqList3) {
    int i, j, k, minDistance = 0x7FFFFFFF;

    i = j = k = 0;
    while (i < sqList1.len && j < sqList2.len && k < sqList3.len) {
        int nowDistance = GetDistance(sqList1.data[i], sqList2.data[j], sqList3.data[k]);
        minDistance = (minDistance < nowDistance) ? minDistance : nowDistance;
        if (IsMinValue(sqList1.data[i], sqList2.data[j], sqList3.data[k])) {
            i++;
        } else if (IsMinValue(sqList2.data[j], sqList1.data[i], sqList3.data[k])) {
            j++;
        } else {
            k++;
        }
    }
    return minDistance;
}

int main() {
    SqList sqList1, sqList2, sqList3;

    while (scanf("%d %d %d%*c", &(sqList1.len), &(sqList2.len), &(sqList3.len)) && sqList1.len && sqList2.len && sqList3.len) {
        for (int i = 0; i < sqList1.len; i++) {
            scanf("%d%*c", &(sqList1.data[i]));
        }
        for (int i = 0; i < sqList2.len; i++) {
            scanf("%d%*c", &(sqList2.data[i]));
        }
        for (int i = 0; i < sqList3.len; i++) {
            scanf("%d%*c", &(sqList3.data[i]));
        }
        printf("%d\n", GetMin(sqList1, sqList2, sqList3));
    }
    return 0;
}

/**
 * get the distance
 * @param x
 * @param y
 * @param z
 * @return |x - y| + |x - z| + |y - z|
 */
int GetDistance(int x, int y, int z) {
    int distance = 0;

    distance += (x > y) ? (x - y) : (y - x);
    distance += (x > z) ? (x - z) : (z - x);
    distance += (y > z) ? (y - z) : (z - y);
    return distance;
}

/**
 * judge whether x is the minimum value
 * @param x
 * @param y
 * @param z
 * @return
 */
bool IsMinValue(int x, int y, int z) {
    return (x <= y && x <= z) ? true : false;
}
呦，又写BUG呢
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-顺序结构的线性表
01-06
数据结构-顺序表
《数据结构》第二章线性表习题.doc
12-01
本资源摘要信息对应的知识点主要涉及到数据结构的第二章线性表习题，包括线性表的定义、链式存储、顺序存储、单链表、双向循环链表、栈和队列等概念。 一、线性表的定义 线性表是指一个有限序列，可以为空。它的每...
王道数据结构代码题（C语言） 线性表部分
Cerulea_n的博客
05-20 182
1.顺序表删除最小元素，并函数返回，删除位置由最后一个元素填补。
王道数据结构编程题 顺序表
qq_37409526的博客
09-09 147
从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。
王道数据结构编程题 链表
qq_37409526的博客
09-09 183
以下为本文解题代码的链表定义。
【王道数据结构课后习题代码练习完整版】顺序表
致力于成为一名data scientist 的奋斗者
05-06 1400
设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置交换，若找不到，则将其插入表中并使表中元素仍递增有序。,am）和(b1,b2,…2.2.3-3 对长度为n的顺序表L，编写一个时间复杂度为o(n),空间复杂度为o(1)的算法，该算法删除线性表中所有值为x的元素。2.2.3-4 从有序顺序表中删除其值在s与t之间（s
23王道数据结构代码题全解（一）
漫磋嗟
04-09 9451
此次更新线性表（7/14）计划更新23王道数据结构所有课后代码习题的实现，虽然考试写的一般都是伪代码，但是强迫症的我还是全部实现了一遍，都可以编译运行，包含暴力解和最优解，仓库在这里 https://github.com/mancuoj/wangdao
【王道数据结构编程题】- 链表算法题
m0_56051805的博客
06-20 4131
王道代码题具体实现，可以运行，19. 设有一个带头结点的循环单链表，其结点值均为正整数。设计一个算法，反复找出单链表中结点值最小的结点并输出，然后将该结点从中删除，直到单链表空为止，再删除表头结点。20.设头指针为L的带有表头结点的非循环双向链表，其每个结点中除有pred(前驱指针)、data (数据)和next (后继指针)域外，还有一个访问频度域freq。在链表被启用前，其值均初始化为零。每当在链表中进行一-次Locate(L,x)运算时，令元素值为x的结点中freq域的值增1,并使此链表中结点保持按访
考研数据结构——线性表（顺序表&链表）最全！含代码！
最新发布
给你糖ya的博客
03-20 1077
和顺序表相比，单链表是链式存储而不是顺序存储，即在内存中是离散存储的，每个结点除了存放数据元素外还要存放指向下一个节点的指针；不需要大片连续空间，改变容量方便；但是不可随机存取，要耗费一定空间存放指针。typedef struct DNode { //定义单链表的结点类型int data;//每个结点存放一个数据元素//prior指向前驱结点，next指向后继结点单链表的各个结点离散地分布在内存中的各个地方；静态链表会分配一整块连续的内存空间来存放各个结点，各个结点不一定连续但都在这一块内存中。
2021版王道《数据结构》编程题汇总
shazi4399的博客
03-27 6992
2021版王道《数据结构》编程题汇总 第二章 线性表P19 1 ​ 1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。 ​ 算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填空出的原最小值元素的位置。 ​ 代码： bool Del_Min(sqList &L, El...
王道数据结构顺序表算法题第十二题
weixin_43788095的博客
08-19 92
王道数据结构顺序表算法题第十二题。
数据结构学习--线性表及其应用--顺序表
06-25
线性表是数据结构的基础，它是由n（n>=0）个相同类型元素构成的有限序列。线性表按照存储方式可以分为顺序表和链表。顺序表是将线性表中的元素顺序地存储在一块连续的内存空间里，通常采用数组作为其底层实现。这种...
入栈和出栈的基本操作
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-18 3859
入栈和出栈的基本操作，输入-1表示出栈，否则入栈，出栈若失败输出error并退出本轮循环。
数据结构编程练习（二叉树）
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
02-16 2921
1.基于二叉链表的二叉树的遍历 2.基于二叉链表的二叉树高度的计算 3.基于二叉链表的二叉树结点个数的统计 4.基于二叉链表的二叉树左右孩子的交换 5.二叉排序树的判定 6.基于二叉链表的二叉树最大宽度的计算
剑指 Offer 58 - II. 左旋转字符串
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
04-14 2837
剑指 Offer 58 - II. 左旋转字符串
基于链表的两个非递减有序序列的合并
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-16 2319
将两个非递减有序序列合并为另一个非递增有序序列。
双向链表实现双向冒泡排序
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-24 2284
n个记录存储在带头结点的双向链表中，利用双向冒泡排序对其进行升序排序。
数据结构编程练习（单链表）
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
02-15 2214
1.基于链表的两个递增有序序列的合并 2.基于链表的两个非递减有序序列的合并 3.基于链表的两个集合的交集 4.基于链表的两个集合差集 5.查找链表中的最大值 6.链表的逆转 7.删除链表中满足区间值的结点 8.查找链表中倒数第k个结点 9.删除链表中倒数第k个结点 10.交换链表中相邻的两个结点 11.基于链表的简单选择排序 12.链表的分解 13.基于链栈的回文字符序列判断 14.奇偶链表的分割 15.基于链表的两数之和 16.删除链表中绝对值相等的结点
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值