首页 > 其他分享> > 2.2.3 综合应用题

2.2.3 综合应用题

2022-07-23 20:33:24 作者：互联网

王道数据结构课后编程题

2.2.3 综合应用题

线性表数据结构

typedef struct {
    ElemType data[MAXSIZE];
    int length;
}SqList;

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

标程：

bool Del_Min(SqList &L, ElemType &value) {
	if (L.length == 0) {
        return false;
    }   
    value = L.data[0];
    int pos = 0;
    for (int i = 1; i < L.length; i++) {
        if (L.data[i] < value) {
            value = L.data[i];
        	pos = i;
        }
    }
    L.data[pos] = L.data[L.length - 1];
    L.length--;
    return true;
}

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

我的答案：

void reverse(SqList &L) {
    ElemType x;
    for (int i = 0; i < L.length / 2; i++) {
        x = L.data[i];
        L.data[i] = L.data[L.length - i - 1];
        L.data[L.length - i - 1] = x;
    }
}

标程：

void reverse(SqList &L) {
    ElemType x;
    for (int i = 0; i < L.length / 2; i++) {
        x = L.data[i];
        L.data[i] = L.data[L.length - i - 1];
        L.data[L.length - i - 1] = x;
    }
}

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

标程：

void del(SqList &L, ElemType x) {
	int len = 0;
    for (int i = 0; i < L.length; i++) {
		if (L.data[i] != x) {
            L.data[len++] = L.data[i];
        }	
    }
    L.length = len;
}

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

我的答案：

bool del(SqList &L, ElemType s, ElemType t) {
	if (s >= t || L.length == 0) return false;
	int len = 0;
    for (int i = 0; i < L.length; i++) {
        if (L.data[i] < s || L.data[i] > t) {
            L.data[len++] = L.data[i];
        }
    }
    L.length = len;
    return true;
}

标程：（注意是有序表）

bool del(SqList &L, ElemType s, ElemType t) {
	if (s >= t || L.length == 0) return false;
    int i, j;
    while (i < L.length && L.data[i] < s) i++;
    if (i >= L.length) return false;
    j = i;
    while (j < L.length && L.data[j] < s) j++;
    for (; j < L.length; i++, j++) {
        L.data[i] = L.data[j];
    }
    L.length = i;
    return true;
}

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

标程：（不懂为啥要这样，直接跟第3题类似也行啊）

bool del(SqList &L, ElemType s, ElemType t) {
	if (s >= t || L.length == 0) return false;
    int k = 0;
  	for (int i = 0; i < L.length; i++) {
        if (L.data[i] >= s && L.data[i] <= t) {
            k++;
        } else {
            L.data[i - k] = L.data[i];
        }
    } 
    L.length -= k;
    return true;
}

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

我的答案：

bool del(SqList &L) {
	if (L.length == 0) return false;
	int k = 0;
	for (int i = 0; i < L.length; i++) {
        if (i > 0 && L.data[i] == L.data[i - 1]) {
            int j = i;
			while (j < L.length && L.data[j] == L.data[i]) {
				j++;
			}
			j--;
			k += j - i + 1;
			i = j;
    	} else {
			L.data[i - k] = L.data[i];
    	}
    }

	L.length -= k;

	return false;  
}

标程：

bool Delete_Same(SqList &L) {
    if (L.length == 0) return false;
    int i, j;
    for (i = 0, j = 1; j < L.length; j++) {
        if (L.data[i] != L.data[j]) {
            L.data[++i] = L.data[j];
        }
    }
    L.length = i + 1;
    return true;
}

将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表。

我的答案：

typedef struct {
    ElemType *data;
    int length;
}SqList;

SqList Merge(SqList L1, SqList L2) {
    SqList resL;
    resL.length = L1.length + L2.length; 
    resL.data = new ElemType[resL.length];
    
    int i = 0, j = 0, k = 0;
    while (i < L1.length && j < L2.length) {
        if (L1.data[i] < L2.data[j]) {
            resL.data[k++] = L1.data[i++];
        } else {
            resL.data[k++] = L2.data[j++];
        }
    }
    
    while (i < L1.length) resL.data[k++] = L1.data[i++];
    while (j < L2.length) resL.data[k++] = L2.data[j++];
    
    return resL;
}

标程：

bool Merge(SeqList A, SeqList B, SeqList C) {
    if (A.length + B.length > C.maxSize) {
        return false;
    }
    int i = 0, 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;
}

已知在一维数组\(A[m + n]\)中依次存放两个线性表\((a_1, a_2, ... a_m)\)和\((b_1, b_2, .... b_n)\)。编写一个函数，将数组中两个顺序表的位置互换，即将\((b_1, b_2, .... b_n)\)放在\((a_1, a_2, ... a_m)\)的前面。

我的答案：

void Swap_Elem(ElemType &x, ElemType &y) {
    ElemType temp = x;
    x = y;
    y = temp;
}

void Swap_List(SqList &A, int n, int m) {
    int len = m + n;
    for (int i = 0; i < len / 2; i++) {
        Swap_Elem(A.data[i], A.data[len - i - 1]);
    }

    for (int i = 0; i < m / 2; i++) {
        Swap_Elem(A.data[i], A.data[m - i - 1]);
    }

    for (int i = m; i < (len + m) / 2; i++) {
        Swap_Elem(A.data[i], A.data[len - (i - m) - 1]);
    }
}

标程：

typedef int DataType;
void Reverse(DataType A[], int left, int right, int arraySize) {
    if (left >= right || right >= arraySize) {
        return false;
    }
    int mid = (left + right) / 2;
    for (int i = 0; i <= mid - left; i++) {
        DataType temp = A[left + i];
        A[left + i] = A[right - i];
        A[right - i] = temp;
    }
}

void Exchange(DataType A[], int m, int n, int arraySize) {
    Reverse(A, 0, m + n - 1, arraySize);
    Reverse(A, 0, n - 1, arraySize);
    Reverse(A, n, m + n - 1, arraySize);
}

持续更新。。。

标签：应用题,int,ElemType,++,length,SqList,2.2,data,综合
来源： https://www.cnblogs.com/ZhengLijie/p/16512943.html