数据结构 2.2.3

01 题目描述

bool Del_Min(SqList &LZElemType &value)
{
    // 删除顺亩表L中最小值元素结点，并通过引用型参数value返回其值
    // 若删除成功，则返回true；否则返回false
    if (L.length == 0)
        return false; // 表空，中止操作返回
    value = L.data[0];
    int pos = 0;
    // 假定0号元素的值最小
    for (int i = l; i < L.length; i++) // 循环，寻找具有最小值的元素
        if (L.data[i] < value)
            ( // 让value记忆当前具有最小值的元素
                value - L.data[i];
                pos = i;)
                L.data[pos] = L.data[L.length - 1]; // 空出的位置由最后一个元素填补
    L.length--;
    return true; // 此时，value即为最小值
}

02 题目描述

void Reverse(Sqlist &L)
{
    ElemType temp; // 辅助变量
    for (int i ^ O; i < L.length / 2; i++)
    {
        temp = L.data[i]; // 交换 L.data [i]与 L.data [L.length-i-1 ]
        L.data[i] = L.data[L.length - i - 1];
        L, data[L.length - i - 1] ^ temp;
    }
}

03 题目描述

void del_x_l(Sqlist &L, ElemType x)
{
    int k = 0, i;
    〃记录值不等于x的元素个数 for (i = 0; i < L.length; i++) if (L.data[i] != x)
    {
        L.data[k] = L.data[i];
        k++;
        〃不等于x的元素增1
    }
    L.length == k; // 顺序表L的长度等于k
}

void del_x_2(Sqlist &L, ElemType x)
{
    int k = 0zi = 0; // k记录值等于x的元素个数
    while (i < L.length)
    {
        if (L.data[i] == x)
            k++;
        else
            L.data[i - k] = L.data[i]; // 当前元素前移k个位置
        i++;
        .L.length = L.length - k; // 顺序表L的长度递减
    }
}

04 题目描述

bool Del_s__t2(SqList &L, ElemType s, ElemType t)
{
    // 删除有丽律表L中值在给定值s与t之间的所有元素
    int j;
    if (s >= t || L.length == 0)
        return false;
    for (i = 0; i < L.lengths & L.data[i] < s; i++)
        ; // 寻找值大于或等于 s 的第一个元素
    if (i >= L length)
        return -false; // 所有元素值均小于s,返回
    for (j = i; j < L.lengths & L.data[j] <= t; j++)
        ; // 寻找值大于 t 的第一个元素
    for (; j < L.length; i++, j++)

        L.data[i] = L.data[j]; // 前移，填补被删元素位置
    L.length = i;
    return true;
}

05 题目描述

bool Del_s_t(SqList &LrElemType s, ElemType t)
{
    // 删除顺段L中值在给定值s与t (要求s
    int i, k = 0;
    if (L length == 0 || s >= t)
        return false;
    . // 线性表为空或s、t不合法，返回
        for (i = 0; i < L.length; i++)
    {
        if (L.data[i] >= s && L.data[i] <= t)
            k++； else 、 L.data[i - k] = L.data[i]; // 当前元素前移k个位置
    }                                                // for
    L.length -= k;                                   // 长度减小
    return true;
}

06 题目描述

bool Delete_Same(SeqList &L)
{
    if (L.length == 0)
        return false;
    int ir j; // i存储第一个不相同的元素，j为工作指针
    for (i = 0, j = l; j < L.length; j++)
        if (L.data[i] ! = L.data[j]) // 查找下一个与上个元素值不同的元素
            L.data[++i] = L.data[j]; // 找到后，将元素前移
    L.length = i + l;
    return true;
}

07 题目描述

bool Merge(SeqList A, SeqList B, SeqList &C)
{
    // 将有序顺序表A与B合并为一个新的有序顺序表C
    if (A.length + B.length > C.maxSize)
        return false;
    int i = 0z j = 0, k = 0;
    while (i < A.length && j < B.length)
    {
        if (A.data[i] <= B.data[j])
            C.data[k++] = A.data[i++];
        else
            C.data[k++] = B.data[j++];
        // 大于顺序表的最大长度
        // 循环，两两比较，小者存入结果表
    }
    while (i < A.length)
        C.data[k++] = A.data[i++];
    while (j < B.length)
        C.data[k++] = B..data[j++];
    C.length = k;
    return true;
}

08 题目描述

typedef int DataType;
void Reverse(DataType A[], int left, int right, int arraySize)
{
    // 逆转(aleft, aleft+1, aleft+2…,aright)为(aright, aright-1, •••, aleft)
    if (left >= rightI | right >= arraySize)
        return false;
    int mid == (left + right) / 2;
    for (int i = 0; i <= mid - left; i++)
    {
        DataType temp = A[left4 - i];
        A[left + i] = A[right - i];
        A[right - i] = temp;
    }
}
void Exchange(DataType A[], int m, int n, int arraySize)
{
    /*数组A[m+n]中，从0到存放顺序表(al, a2, a3,…，am),.从m到m+n-l存放顺序表
    (bl,b2,b3,…，bn),算法将这两个表的位置互换*/
    Reverse(A, 0zm + n - l, arraySize);
    Reverse(A, 0, n - 1, arraySize);
    Reverse(A, n, m + n - l, arraySize);
}

09 题目描述

void SearchExchangelnsert(ElemType A[], ElemType x)
{
    int low = 0, high = n - l, mid; // low和high指向顺序表下界和上界的下标
    while (low <= high)
    {
        mid = (low + high) / 2; // 找中间位置
        if (A[mid] == x)
            break; // 找到 x,退出 while 循环
        else if (A[mid] < x)
            low = mid + l; // 到中点 mid 的右半部去查
        else
            high = mid - l; // 到中点mid的左半部去查
    }                       // 下面两个if语句只会执行一个
    if (A[mid] == x &&mid ! = n - l)
    { // 若最后一个元素与x相等，则不存在与其后继交换的操作
        t = A[mid];
        A[mid] = A[mid + l];
        A[mid + l] = t;
    }
    if (low > high)
    { // 查找失败，插入数据元素x
        for (i = n - l; i > high; i—)
            A[i + l] = A[i]; // 后移元素
        A[i + l] = x;
        // 插入 x
    } // 结束插入
}

10 题目描述

void Reverse(int R[] z int from, int to)
{
    int i, temp;
    for (1 = 0; i < (to - from + 1) / 2; i++)
    {
        temp = R[from + i];
        R[from + i] = R[to - i];
        R[to - i] = temp;
    } // Reverse
    void ConversR(int R[], int n, int p)
    {
        Reverse(R, 0, p - 1);
        Reverse(R, p, n - 1);
        Reverse(R, 0, n - 1);
    }
}

11 题目描述

int M__Search(int A[], int B[] z int n)
{
    int sl = 0, s2 = 0, d2 = n - l, m2;
    // 分别表示序列A和B的首位数、末位数和中位数
    while (si != dl || s2 != d2)
    {
        ml - (sl + dl) / 2;
        m2 = (s2 + d2) / 2;
        if (A[ml] == B[m2])
            return A[ml];  // 满足条件①
        if (A[ml] < B[m2]) // 满足条件②
        {
            if ((sl + dl) % 2 == 0) // 若元素个数为奇数
            {
                sl = ml; // 舍弃A中间点以前的部分且保留中间点
                d2 = m2; // 舍弃B中间点以后的部分且保留中间点
            }
            else // 元素个数为偶数
            {
                sl = ml + l; // 舍弃A中间点及中间点以前部分
                d2 = m2;     // 舍弃B中间点以后部分且保留中间点
            }
        }
        else // 满足条件③
        {
            if ((s2 + d2) % 2 == 0) // 若元素个数为奇数
            {
                dl = ml; // 舍弃A中间点以后的部分且保留中间点
                s2 = m2; // 舍弃B中间点以前的部分且保留中间点

                // 舍弃A中间点以后部分且保留中间点
                // 舍弃B中间点及中间点以前部分
            }
            else // 元素个数为偶数
            {
                dl = ml;
                s2 = m2 + l;
            }
        }
    }
    return A[sl] < B[s2] ? A[sl] : B[s2];
}

12 题目描述

int Majority(int A[] z int n)
{
    int I, c, count = l;    // c用来保存候选主元素，count用来计数
    C = A[0];               // 设置A[0]为候选主元素
    for (i = l; i < n; i++) // 查找候选主元素
    {
        if (A⑴ == c)
            count++; // 对A中的候选主元素计数
        else    
            if (count > 0)// 处理不是候选主元素的情况
                count--;
            else        // 更换候选主元素，重新计数
            {
                c = A[i];
                count«l;
            }
    }
    if (count > 0)
        for (i ^ count = O; i < n; i++)// 统计候选主元素的实际出现次数
            if (A[i] == c)
                count++;
    if (count > n / 2) // 确认候选主元素
        return c;
    else
        return -1;  // 不存在主元素
}

13 题目描述

int findMissMin(int A[] z int n)
{
    int i, *B;
    B = (int *)malloc(sizeof(int) * n);
    memset(B, 0, sizeof(int) * n);
    for (i = 0; i < n; i++)
        if (A[i] > 0 && A[i] <= n)
            for (i = 0; i < n; i++)
                if (B[i] == 0)
                    break;
    return i + 1;
}

14 题目描述

#define INT_MAX 0x7fffffff.int abs_(int a)
{ // 计算绝对值
    if (a < 0)
        return -a;
    else
        return a;
}

bool xls_min(int a, int bz int c)
{ // a是否是三个数中的最小值
    if (a <= b && a <= c)
        return true;
    return false;
}
int findMinofTrip(int A[].z int n, int B[], int m, int C[] z int p)
{
    // D_min用于记录三元组的最小距离，初值赋为INT_MAX
    int i = 0, j = 0, k = 0, D_min = INT_MAX, D;
    while (i < n && j < m && k < p && D__min > 0)
    {
        D = abs_(A[i] - B[j]) + abs_(B[j] - C[k]) + abs_(C[k] - A[i]);
        // 计算 D
        if (D < D_min)
            D__min = D; // 更新 D
        if (xls_min(A[i] rB[j], C[k]))
            i++; // 更新 a
        else if (xls_min(B[j] zC[k] zA[i]))
            j++;
        else
            k++;
    }
    return D_min;
}

推荐一个零声学院免费公开课程，个人觉得老师讲得不错，分享给大家：Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等技术内容，立即学习