线性表-综合应用题

线性表整理

基础题

1. 设计一个算法，将顺序表中所有元素逆置。

 void reverse(Sqlist  &L)
 {
 	int i,j;
 	int temp;
 	for(i = 0, j = L.length-1; i < j; ++i, --j)
 	{
 		temp = L.data[i];
 		L.data[i] = L.data[j];
 		L.data[j] = temp;
 	}
 }

2. 设计一个算法，从一给定的顺序表 L 中删除下标 i ~ j （ i $\le$ j，包括 i、j ）的所有元素，假定 i、j 都是合法的。

void delete(Sqlist &L, int i, int j)
{
	int k, delta;
	delta = j-i+1;
	for(k = j+1; k < L.length; ++k)
	{
		L.data[k-delta] = L.data[k];
	}
	L.length -= delta;
}

3. 有一个顺序表 L ，其元素为整型数据，设计一个算法，将 L 中所有小于表头元素的整数放在前半部分，大于表头元素的整数放在后半部分。

void move(Sqlist &L)
{
	int temp;
	int i = 0, j = L.length-1;
	temp = L.data[i]；
	while(i < j)
	{
		while(i < j && L.data[j] > temp)	--j;
			
		if(i < j)
		{
			L.data[i] = L.data[j];
			++i;
		}
		while(i < j && L.data[i] < temp)	++i;
			
		if(i < j)
		{
			L.data[j] = L.data[i];
			--j;
		}
	}
	L.data[i] = temp;
}

4. 有一个递增非空单链表，设计一个算法删除值域重复的结点。例如，{1，1，2，3，3，3，4，4，7，7，7，9，9，9}经过删除后变成{1，2，3，4，7，9}。

vodi delsl1(LNode *L)
{
	LNode *p = L->next, *q;
	while(p->next != NULL)
	{
		if(p->data == p->next->data)
		{
			q = p->next;
			p->next = q->next;
			free(q);
		}
		else
			p = p->next;
	}
}

5. 设计一个算法删除单链表 L（有头结点）中的一个最小值结点。

void delminnode(LNode *L)
{
	LNode *pre = L, *p = pre->next, *minp = p, *minpre = pre;
	while(p != NULL)
	{
		if(p->data < minp->data)
		{
			minp = p;
			minpre = pre;
		}
		pre = p;
		p = p->next;
	}
	minpre->next = minp->next;
	free(minp); 
}

6. 有一个线性表，采用带头结点的单链表 L 来存储。设计一个算法将其逆置。要求不能建立新结点，只能通过表中已有结点的重新组合来完成。

void reversel(LNode *L)
{
	LNode *p = L->next, *q;
	L->next = NULL;
	while(p != NULL)
	{
		q = p->next;
		p->next = L->next;
		L->next = p;
		p = q;
	}
}

8. 设计一个算法，将一个头结点为 A 的单链表（其数据域为整数）分解成两个单链表 A 和 B ，使得 A 链表只含有原来链表中 data 域为奇数的结点，而 B 链表只含有原链表中 data 域为偶数的结点，且保持原来的相对顺序。

void splist2(LNode *A, LNode *B)
{
	LNode *p, *q, *r;
	B = (LNode *)malloc(sizeof(LNode));
	B->next = NULL;
	r = B;
	p = A;
	while(p->next != NULL)
	{
		if(p->next != NULL)
		{
			q = p->next;
			p->next = q->next;
			q->next = NULL;
			r->next = q;
			r = q;
		}
		else
			p = p->next;
	}
}

思考题

1. 有 N 个个位正整数存放在 int 型数组 A[0，…，N-1]中，N为已定义的常量且N $\le$ 9，数组 A[]的长度为N，另给一个 int 型变量 i ，要求只用上述变量（A[0]~A[N-1]与i，这N+1个整型变量）写一个算法，找出这N个整数中的最小者，并且要求不能破坏数组 A[]中的数据。

void findMin(int A[], int &i)
{
	i = A[0];
	while(i/10 <= N-1)
	{
		if(i%10 > A[i/10])
		{
			i = i - i%10;
			i = i + A[i/10];
		}
		i = i % 10;
	}
}

2. 写一个函数，逆序打印单链表中的数据，假设指针 L 指向了单链表的开始结点。

void reprint(LNode *L)
{
	if(L != NULL)
	{
		reprint(L->next);
		cout<<L->data<<" ";
	}
}

3. 设有两个用有序链表表示的集合 A 和 B，设计一个算法，判断它们是否相等。

#include <iostrean>
using namespace std;
typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode;
int isEqual(LNode* A, LNode* B)
{
	LNode* p = A->next;
	LNode* q = B->next;
	while(p != NULL && q != NULL)
	{
		if(p->data == q->data)
		{
			p = p->next;
			q = q->next;
		}
		else
			return 0;
	}
	if(p != NULL && q != NULL)
		return 0;
	else
		return 1;
}
void createList(LNode *&head, int arr[], int n)
{
	head = (LNode *)malloc(sizeof(LNode));
	head->next = NULL;
	LNode* r = head;
	for(int i = 0; i < n; ++i)
	{
		LNode* p = (LNode *)malloc(sizeof(LNode));
		p->data = arr[i];
		p->next = NULL;
		r->next = p;
		r = p;
	}
}
int main()
{
	int a[] = {1, 2, 3, 4, 6};
	int b[] = {1, 2, 3, 4, 5};
	LNode* A;
	LNode* B;
	createList(A, a, 5);
	createList(B, b, 5);
	cout<<isEqual(A, B)<<endl;
	return 0;
}

4. 设 A=（a₁，a₂，···，a_m）和 B=（b₁，b₂，···，b_n）均为顺序表，A’ 和 B’ 分别是除去最大公共前缀后的子表。例如，A=（b，e，i，j，i，n，g），B=（b，e，i，f，a，n，g），则两者的最大公共前缀为b，e，i，在两个顺序表中除去最大公共前缀后的子表分别为 A’=（j，i，n，g），B’=（f，a，n，g）。若 A’ = B’ =空表，则 A=B。若 A’=空表且 B’$\ne$空表，或两者均不为空且 A‘的第一个元素值小于 B’ 的第一个元素值，则 A<B，否则 A>B。所有表中元素均为 float型，试编写一个函数，根据上述方法比较 A 和 B 的大小。

int compare(float A[], int An, float B[], int Bn)
{
	int i = 0;
	while(i < An && i < Bn)
	{
		if(fabs(A[i] - B[i]) < min)
			++i;
		else
			break;
	}
	if(i >= An && i >= Bn)
		return 0;
	else if((i >= An && i < Bn) || A[i] < B[i])
		return -1;
	else
		return 1;
}

5. 键盘输入n个英文字母，输入格式为n、c1、c2、···、cn，其中n表示字母的个数。请编程用这些输入数据建立一个单链表，并要求将字母不重复地存入链表。

void createLinkNoSameElem(LNode *&head)
{
	head = (LNode *)malloc(sizeof(LNode));
	head->next = NULL;
	LNode *p;
	int n;
	char ch;
	std::cin>>n;
	for(int i = 0; i < n; ++i)
	{
		std::cin>>ch;
		p = head->next;
		while(p != NULL)
		{
			if(p->data == ch)
				break;
			p = p-next;
		}
		if(p == NULL)
		{
			p = (LNode *)malloc(sizeof(LNode));
			p->data = ch;
			p->next = head->next;
			head->next = p;
		}
	}
}