算法分析题

和安韩Pro

已于 2024-04-12 15:56:35 修改

阅读量87

点赞数 1

分类专栏： # 数据结构代码题文章标签：算法

于 2024-01-05 18:48:29 首次发布

本文链接：https://blog.csdn.net/weixin_45714641/article/details/134015096

版权

数据结构代码题专栏收录该内容

9 篇文章 1 订阅

订阅专栏

//判断一棵二叉树是否是二叉排序树
ElemType predt = -32767;
int judgeBst(BTNode *bt){
	//b1表示左子树是否为二叉排序树
	//b2表示右子树是否是二叉排序树
	int b1, b2;
	if(bt == NULL){
		return 1;
	}
	b1 = judgeBst(bt->lchild);
	if(b1==0 || bt->data<predt){
		return 0;
	}
	predt = bt->data;
	b2 = judgeBst(bt->rchild);
	return b2;
}

//二叉树的中序非递归遍历
void inOrder(BTNode *b){
	//St[MaxSize]用于中序非递归遍历的辅助栈
	//p指针用于指向根节点
	BTNode *St[MaxSize],*p;
	int top = -1;
	if(b != NULL){
		p = b;
		while(top>-1 || p!=NULL){
			while(p != NULL){
				top++;
				St[top] = p;
				p = p->lchild;
			}
			if(top > -1){
				p = St[top];
				top--;
				printf("%C",p->data);
				p = p->rchild;
			}
		}
		printf("\n");
	}
}

//从线性表中删除自第i个元素开始的k个元素
int deletek(SqList &L, int i, int k){
	int j;//j用于控制元素后移
	if(i<1 || k<1 || i>L.length){
		return 0;
	}
	for(j=i+k-1; j<L.length; j++){
		L.elem[j-k] = L.elem[j];
	}
	L.length++;//L.length = L.length-k
	return 1;
}

//判断两个队列是否相等
int QueueEmpty(Queue Q);//判断队列空否，1为空，0不为空
int GetHead(Queue Q, ElemType &x);//通过x返回对头元素的值
void EnQueue(Queue &Q, ElemType x);//将新元素x插入到队列的队尾
void DeQueue(Queue &Q);//从队列中退出队头元素
int EqualQueue(Queue Q1, Queue Q2){
	//t1用于存储队列1的队头元素
	//t2用于存储队列2的队头元素
	//finish=1表示默认两个队列相等
	ElemType t1,t2;
	int finish = 1;
	while(!QueueEmpty(Q1) && !QueueEmpty(Q2)){
		GetHead(Q1,t1);
		DeQueue(Q1);
		GetHead(Q2,t2);
		DeQueue(Q2);
		if(t1 != t2){
			finish = 0;
			break;
		}
	}
	if(finish==0 || !QueueEmpty(Q1) || !QueueEmpty(Q2)){
		return 0
	}else{
		return 1;
	}
}

//将数组A[]的全部元素依次插入到二叉排序树T中
void Unknown(BiTree &T, ElemType A[], int n){
	//p做为下移指针
	//pr指向p的父节点
	//q做为新插入结点
	BiTNode *p, *pr, *q;
	int i;
	for(i=0; i<n; i++){
		q = (BiTNode)malloc(sizeof(BiTNode));
		q->data = A[i];
		q->lchild = q->rchild = NULL;
		if(T == NULL){
			T = q;
		}else{
			p = T;
			pr = NULL;
			while(p!=NULL && p->data!=q->data){
				pr = p;
				if(p->data < q->data){
					p = p->rchild;
				}else{
					p = p->lchild;
				}
			}
			if(p == NULL){
				if(q->data < pr->data){
					pr->lchild = q;
				}else{
					pr->rchild = q;
				}
			}
		}
	}
}

//删除值域重复的结点
void delSame(LinkList &head){
	//p指针指向基准元素
	//q指向要删除结点的前驱结点
	//r指向要删除结点
	//t指向要删除结点的后继结点
	LinkList p=head->next , q, r, t;
	while(p != NULL){
		q = p;
		r = p->next;
		while(r != NULL){
			if(r->data == p->data){
				t = r->next;
				q->next = t;
				free(r);
				r = t;
			}else{
				q = r;
				r = r->next
			}
		}
		p = p->next;
	}
}

//用辅助栈来判断单链表中所有元素的正反序是否相同
int theSame(LinkList head){
	ElemType x;//x用来存储出栈元素
	struct node{
		Elemtype data[MaxSize];
		int top;
	}st;
	st.top = -1;;
	LinkList p = head->next;
	while(p != NULL){
		st.top++;
		st.data[st.top] = p;//st.sata[st.top] = p->data
		p = p->next;
	}//将链表中的所有元素全部入栈
	p = head->next;//p指针重新指回链表首结点
	while(p != NULL){
		x = st.data[st.top];
		st.top--;
		if(p->data != x){
			return 0;
		}
		p = p->next;
	}//出栈元素依次和链表元素对比看是否相同
	return 1;
}

//把单链表L拆分成偶数链表L和奇数链表M
void split(LinkList &L, LinkList &M){
	//p指针用于遍历链表
	//ra用于向偶数链表L中添加结点
	//rb用于向奇数链表M中添加结点
	LinkList p=L->next, ra, rb;
	ra = L;
	M = (LinkList)malloc(sizeof(LNode));
	rb = M;
	while(p != NULL){
		if(p->data%2 == 0){//偶数连在L上
			ra->next = p;
			ra = p;
			p = p->next;
		}else{//奇数连在M上
			rb->next = p;
			rb = p;
			p = p->next;
		}
	}
	ra->next = rb->next = NULL;
}

//集合求交集
void intersection(SqList A, SqList B, SqList &C){
	//i用于遍历顺序表A
	//j用于遍历顺序表B
	//k用于向顺序表C中插入元素
	int i, j, k=0;
	for(i=0; i<A.length; i++){
		j=0;
		while(j<B.length && A.elem[i]!=B.elem[j]){
			j++;
		}
		if(j < B.length){
			C.elem[k++] = A.elem[i];
		}
	}
	C.length = k+1;//C.length = k
}

//先右子树再根结点最后左子树递归遍历二叉排序树，并按递增次序打印二叉排序数中的元素
//先右子树再根结点最后左子树打印所有大于等于k的结点
void unknown(BiTree T, ElemType k){
	if(T == NULL){
		return;
	}
	if(T->rchild != NULL){
		unknown(T->rchild, k);
	}
	if(T->data >= k){
		printf("%d", T->data);
	}
	if(T->lchild != NULL){
		unknown(T->lchild, k);
	}
}

//删除单链表中的第i个元素，并由e返回其值
int listDelete(LinkList &L, int i, ElemType &e){
	//p指向q的前驱结点
	//q指向要删除结点
	LinkList p, q;
	p = L;
	int j = 0;//j用于让p指向第i-1个元素
	while(p->next && j<i-1){
		p = p->next;
		++j;
	}
	if(!(p->next) || j>i-1){
		return 0;
	}
	q = p->next;
	p->next = q->next ;
	e = q->data;
	free(q);
	return 1;
}

//求二叉排序树某个结点在树的第几层
int unknown(BiTNode *T, BiTNode *s){
	//s为指向二叉排序树中某个结点的指针
	//k用于表示s结点在二叉排序树的第几层
	int k = 0;
	BiTNode *p = T;
	if(T != null){
		k++;
		while(p->data != s->data){
			if(p->data < s->data){
				p = p->rchild;
			}else{
				p = p->lchild;
			}
			k++;
		}
	}
	return k;
}

//二叉树非递归中序遍历
int inOrderTraverse(BiTree T){
	SqStack S;//S辅助栈用于中序非递归遍历
	BiTree p;//p指针指向二叉树根节点
	p = T;
	push(S,T);
	while(!StackEmpty(S)){
		while(getTop(S,p) && p){//有左入左
			push(S,p->lchild);
		}
		pop(S,p);//弹出栈顶的null
		if(!StackEmpty(S)){//无左，弹出并打印出栈点，右入栈
			pop(S,p);
			printf("%d",T->data);
			push(p->rchild);//push(S,p->rchild)
		}
	}
	return 1;
}

在顺序表第i个元素之前插入元素e
int listInsert_Sq(SqList &L, int i, ElemType e){
	ElemType *p, *q;
	if(i<=1 || i>L.length+1){//要插入的位置不能过小也不能过大
		return 0;
	}
	if(L.listsize <= L.length){//空间不够，动态分配内存空间
		ElemType *newbase = (ElemType *)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof(ElemType));
		if(!newbase){
			return 0;
		}
		L.elem = newbase;
		L.listsize += LISSTINCREMENT;
	}
	q = &(L.elem[i-1]);//q存的是要插入的位置的地址
	for(p=&(L.elem(L.length-1); p>=q; --p)){//元素后移
		*(p+1) = *p;
	}
	*q = e;//元素e存入q指针所指的内存空间
	++L.length;
	return 1;
}

//将无头单链表head复制到另一个无头单链表newhead
void unknown(LinkList head, LinkList &newhead){
	//head为一个无头结点的单链表的头指针
	//p用于遍历单链表head
	//q用于给单链表newhead增加元素
	//r用于指向插入newhead的结点
	LNode *p, *q, *r;
	newhead = (LinkList)malloc(sizeof(LNode));
	p = head;
	q = newhead;
	while(p != NULL){//将单链表head中的元素复制到单链表newhead中
		r = (LinkList)malloc(sizeof(LNode));
		r->data = p->data;
		q->next = r;
		q = r;
		p = p->next;
	}
	q->next = NULL;
	r = newhead;
	newhead = newhead->next;
	free(r);
}

//删除二叉排序树中所有小于等于x的结点
T&&T->data<=x
free(p)
p->data > x
q->lchild =p->rchild
p = q->lchild

//利用迪杰斯特拉算法求某个点到其他点的单源最短路径

//单链表的插入操作
int listInsert_L(LinkList &L, int i, ElemType e){
	//在带头结点的单链线性表L的第i个元素之前插入元素e
	//p指向s的前驱结点
	//s指向新插入结点
	LinkList p, s;
	p = L;
	int j = 0;//j用于让p指向第i-1个元素
	while(p && j<i-1){
		p = p->next;
		++j;
	}
	if( || j>i-1){//!p
		return 0;
	}
	s = (LinkList)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return 1;
}

//判断带头结点的单链表head是否为递减序列
//判断头指针为head的单链表是否为递减序列
int unknown(LNode *head){
	//head为单链表的头指针
	//p用于指向基准元素
	//q用于指向基准元素的前驱结点
	//flag=1表示单链表为递减序列
	LNode *p, *pre;
	int flag = 1;
	if(head){
		pre = head;
		p = head->next;
		while(p!=NULL && flag==1){
			if(pre->data < p->data){
				flag = 0;
			}
			pre = p;
			p = p->next;
		}
	}
	if(flag == 1){
		return 1;
	}else{
		return 0;
	}
}

//使用循环队列对二叉树进行层次遍历
//使用循环队列层次遍历二叉树并输出结点
#define MAXSIZE 100
int unknown(BiTNode *T){
	//T为指向二叉树根节点的指针
	//辅助队列Q用于二叉树层次遍历
	//p指针指向队头元素
	BiTNode *Q[MAXSIZE], *p;
	int front=0, rear=0;
	Q[++rear] = T;//队尾先加再赋
	while(front != rear){
		front = (front+1)%MAXSIZE;
		p = Q[front];//队头也应先加后赋
		printf("%d", p->data);
		if(P->lchild != NULL){
			rear = (rear+1)%MAXSIZE;
			Q[rear] = p->lchild;
		}
		if(p->rchild != NULL){
			rear = (rear+1)%MAXSIZE;
			Q->rear = p->rchild;
		}
	}
}

//从大到小输出二叉排序树中所有的值不小于x的关键字
int BST_OutputNode(BiTNode *T, ElemType x){
	if(T){
		BST_OutputNode(T->rchlid, x);
		if(T->data >= x){
			printf(T->data);
		}else{
			return 1;
		}
		BST_OutputNode(T->lchild, x);
	}
}

//选择排序
int indexOfLargest(int A[], int n){
	//IndexSoFar初始默认第一个元素的值最大
	//CurrentIndex用于向后遍历找最大元素的数组位置
	int IndexSoFar, CurrentIndex;
	IndexSoFar = 0;
	for(CurrentIndex=1; CurrentIndex<n; CurrentIndex++){
		if(A[CurrentIndex] > A[IndexSoFar]){
			IndexSoFar = CurrentIndex;
		}
		return IndexSoFar;
	}
}//找最大元素的数组位置
void selectSort(int A[], int n){
	//last用于循环把最大元素归位
	//L指向最大元素的数组位置
	//temp临时变量用于交换最大元素和最大元素最终位置的元素
	int last, L;
	int temp;
	for(last=n-1; last>=1; last--){
		L = IndexOfLarge(A, last+1);
		temp = A[L];
		A[L] = A[last];
		A[last] = temp;
	}//依次把最大元素归位
}