22考研整理

2022

2021

2020

1.设计算法,从顺序表L中删除所有值为x的元素。要求算法的时间复杂度为O(n)，空间复杂度为0(1)。

void ListDelete(Sqlist &L,int x)
{
	int count = 0;
	for(int i = 0;i < L.length;i++ )
	{
		if(L.data[i]==x)
			count++;   //等于x跳过
		else
			data[i-count] = data[i];  //不等于x元素
									  //移动到等于x元素位置上
	}
	L.length=L.length-count;
}

2.设计算法，判断一个字符串是否是回文。如atbc3cb+a是回文序列，而

1++3==3+1不是回文序列。

#include <stdio.h>
#include <string.h>
#define N 100
int main()
{
	char s[N];
	int i = 0, j;
	printf("Input a String: \n");
	//输入一个字符串赋值给s
	gets_s(s);
	//j的初始值为s字符串最后一个位置
	j = strlen(s) - 1;
	//进行while判断i、j的位置和i、j位置的值的关系
	while (i <= j && s[i] == s[j]) {
		//每比较一次就i右移、j左移一位
		i++; j--;
	}
	//判断最终i和j的的位置
	//根据i、j的位置最终是会互相超越的，所以如果i<=j说明存在对应位置不等的情况就是不是回文串
	if (i <= j)
	{
		printf("不是回文字符串\n");
	}
	else { printf("是回文字符串\n"); }
	return 0;
}

3 设计算法，完成一趟快速排序算法。即将下标从low到high的元素以r[low]为基准分成两部分，小的在前、大的在后。

void quick_sort(int q[], int l, int r)
{
    if (l >= r) return;

    int i = l - 1, j = r + 1, x = q[l];
    while (i < j)
    {
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r); //一趟排序没有这行。
}

2019

1．试编写在链式存储结构实现求两个集合之差函数difference(A,B).令C=A-B,取仅当e是A中的一个元素，但不是B中的元素时，e是C中的一个元素。

void difference(node **LA, node *LB)
{
	node *pa, *pb, *pre, *q;
	pre = NULL;
	pa = *LA;
	while (pa)
	{
		pb = LB;
		while (pb&&pb->elem!=pa->elem)
		{
			pb = pb->next;
		}
		if (pb)
		{
			if (!pre)
				*LA = pa->next;
			else
			pre->next = pa->next;
			q = pa;
			pa = pa->next;
			free(q);
		}
		else
		{
			pre = pa;
			pa = pa->next;
		}
	}
}

2.试设计在带头结点的单循环链表h中查找元素值为x的结点所在的位置的算法

LNode *LocateElem(LinkList L, ElemType)
{
	Lnode *p = L->next;
	while (p != Null && p->next != e)
		p = p->next;
	return p;
}

3．写出中序线索二叉树中查找节点却中序后继的算法。

//在中序线索二叉树中找到结点p的后继结点
ThreadNode *NextNode(ThreadNode *p){
	if(p->rtag==1){
		p=p->rchild;
	}else{
		p=FirstNode(p->rchild);
	}
	return p;
}

中序二叉树

//找到以p为根的子树中，第一个被中序遍历的结点
ThreadNode *FirstNode(ThreadNode *p){
	while(p->ltag==0){        //循环找到最左下结点
		p=p->lchild;
	}
	return p;
}
//找到以p为根的子树中，最后一个被中序遍历的结点
ThreadNode *LastNode(ThreadNode *p){
	while(p->rtag==0){
		p=p->rchild;
	}
	return p;
}
//在中序线索二叉树中找到结点p的后继结点
ThreadNode *NextNode(ThreadNode *p){
	if(p->rtag==1){
		p=p->rchild;
	}else{
		p=FirstNode(p->rchild);
	}
	return p;
}	

//在中序线索二叉树中找到p的前驱结点
ThreadNode *PreNode(ThreadNode *p){
	if(p->ltag==1){
		p=p->lchild;
	}else{
		p=LastNode(p->lchild);
	}
	return p;
}


//非递归算法实现线索二叉树的遍历
void InOrder(ThreadTree T){
	for(ThreadNode *p=FirstNode(T);p!=NULL;p=NextNode(p)){
		visit(p);
	}
}
//逆向的中序遍历
void RevInOrder(ThreadTree T){
	for(ThreadNode *p=LastNode(T);p!=NULL;p=PreNode(p)){
		visit(p);
	}
}

2018

1.两个链式存储的线性表LA和LB,其元素均按从小到大的升序排列，编写一个算法将它们合并成一个链表LC,要求LC的元素从大到小的升序排列。要求利用原表长度(即LA表和LB表)的结点空间构造LC表,且算法时间性能达到两个表长之和。

void MergeList(SqList &La, SqList &Lb, SqList &Lc) {
	int i = 0, j = 0, k = 0;
	Lc.length = La.length + Lb.length;
	while (i < La.length && j < Lb.length) {
		if (La.elem[i] < Lb.elem[j]) {
			Lc.elem[k] = La.elem[i];
			i++;
		}
		else {
			Lc.elem[k] = Lb.elem[j];
			j++;
		}
		k++;
	}
	while (k < Lc.length) {
		if (i == La.length) {
			Lc.elem[k] = Lb.elem[j];
			j++;
		}
		else {
			Lc.elem[k] = La.elem[i];
			i++;
		}
		k++;
	}

void merge_sort(int q[], int l, int r)
{
    if (l >= r) return;

    int mid = l + r >> 1;
    merge_sort(q, l, mid);
    merge_sort(q, mid + 1, r);

    int k = 0, i = l, j = mid + 1;
    while (i <= mid && j <= r)
        if (q[i] <= q[j]) tmp[k ++ ] = q[i ++ ];
        else tmp[k ++ ] = q[j ++ ];

    while (i <= mid) tmp[k ++ ] = q[i ++ ];
    while (j <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];
}

2016

1.有两个带头结点的循环单链表LA、LB,编写一个算法，将两个循外单链表合并为一个循环单链表，其头指针为LA,并给出时间复杂度。

LinkList Link(LinkList &h1,LinkList &h2){
	LNode *p,*q;              //分别指向两个链表的尾结点 
	p=h1;
	while(p->next!=NULL){       //寻找h1的尾结点 
		p=p->next;
	}
	q=h2;
	while(q->next!=NULL){       //寻找h2的尾结点 
		q=q->next;
	}
	p->next=h2;               //将h2链接到h1之后 
	q->next=h1;				  //将h1的尾结点指向h1 
	return h1;
} 

2.写一算法，判断图是否连通，如果不连通有几个连通分量

在这里插入代码片

3 折半查找的非递归算法

## 4二叉链表存储二叉树，写出层次遍历二叉树的算法

4．编写函数InsSort(a,n)，完成对数组a[n]的直接插入排序。

void insertSort(ElemType A[], int n)
{
	int i, j;
	for (i = 2; i <= n; i++)
		if (A[i] < A[i - 1])
		{
			A[a] = A[i];
			for (int j = i - 1; A[0] < A[j]; --j)
				A[j + 1] = A[j];
			A[j + 1] = A[0];
		}
}

2015

1.是比爱写出单链表的删除值为x的结点的函数

void DeleteLinkList(LinkList head,int x)

2.写一算法，从顺序表中删除自第i个元素开始的k个元素

//顺序表的删除
Status Delete(SqList * L,int Location)
{
    if(L->Length==0)    //线性表为空
    return ERROR;
    if(Location<L->Length)
    {
        for(int i=Location;i<L->Length;i++)
        {
            L->data[i-1]=L->data[i];
        }
        L->Length--;
    }
    return OK;
}

3.设有一个循环单链表的长度大于1，且表中既无头结点也无头指针，已知s为指向链表某个结点的指针，试编写算法在链表中删除指针s所指结点的前驱结点。

14年

13年（a）

13年（b）

12（a）年

11（a）年

想要更多信息可以联系我，欢迎交流！