数据结构代码练习03

九月小羊i

已于 2024-01-16 13:51:09 修改

阅读量332

点赞数 6

分类专栏：数据结构文章标签：数据结构算法

于 2024-01-16 13:17:36 首次发布

本文链接：https://blog.csdn.net/m0_71844907/article/details/135622191

版权

数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

单链表相关操作

单链表默认结构体

//单链表默认结构体
typedef struct LNode{
	int data;
	struct LNode *next;	
}LNode,*Linklist;

单链表基础操作

//头插法建立单链表 
LinkList List_HeadInsert(LinkList &L){
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	scanf("%d",&x);
	while(x!=9999){
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;
		L->next=s;
		scanf("%d",&x);
	} 
	return 1;
} 

//尾插法建立单链表
LinkList List_TailInsert(LinkList &L){
	int x;
	L=(LinkList)malloc(sizeof(LNode));
	LNode *s,*r=L;
	scanf("%d",&x);
	while(x!=9999){
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;
		r=s;
		scanf("%d",&x);
	}
	r->next=NULL;
	return L;
}

//按序号查找结点
LNode *GetElem(LinkList L,int i){
	if(i<1)
		return NULL;
	int j=1;
	LNode *p=L->next;
	while(p!=NULL&&j<i){
		p=p->next;
		j++;
	}
	return p;
}

//按值查找表结点
LNode *LocateElem(LinkList L,Elemtype e){
	LNode *p=L->next;
	while(p!=NULL&&p->data!=e)
		p=p->next;
	return p;
} 

//插入结点
//p=GetElem(L,i-1);
//s->next=p->next;
//p->next=s; 

//删除结点
//p=GetElem(L,i-1);
//q=p->next;
//p->next=q->next;
//free(q);

单链表相关操作

//
//设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点
void del_x(LNode *&L,int x){
	LNode *p;
	if(L==NULL)
		return;
	if(L->data==x){
		p=L;
		L=L->next;
		free(p);
		del_x(L,x);
	}
	else
		del_x(L->next,x);
} 

//
//删除带头节点单链表中值为x的结点
//法一 
void del(LNode *&L,int x){
	LNode *p=L->next,*pre=L,*q;
	while(p!=NULL){
		if(p->data==x){
			q=p;
			pre->next=p->next;
			p=p->next;
			free(q);
		}
		else{
			pre=p;
			p=p->next;
		}
	} 
//法二
void Del(LNode *&L,int x){
	LNode *p=L;
	while(p->next!=NULL){
		if(p->next->data==x){
			LNode *q=p->next;
			p=next=q->next;
			free(q);
		}
		else
			p=p->next;
	} 
} 

//
//删除带头结点单链表中第一个值为x的结点
int finddelete(LNode *&C,int x){
	LNode *p,*q;
	p=C;
	while(p->next!=NULL){
		if(p->next->data==x)
			break;
		p=p->next;
	}
	if(p->next==NULL)
		return 0;
	else
		q=p->next;
		p->next=q->next;
		free(q);
		return 1;
} 

//
//从头到尾反向传输出单链表每个结点的值
void print(LNode *L){
	if(L->next!=NULL)
		print(L->next);
	count <<L->data<< "";
} 

//
//试编写算法将单链表就地逆置
//法一 头插法 
void reverse(LNode *&L){
	LNode *p=L->next,*r;
	L->next=NULL;
	while(p!=NULL){
		r=p->next;
		p->next=L->next;
		L->next=p;
		p=r;
	}
}
//法二 
void Reverse(LNode *&L){
	LNode *p=L->next,*r=p->next;
	LNode *pre;
	p->next=NULL;
	while(r!=NULL){
		pre=p;
		p=r;
		r=r->next;
		p->next=pre;
	}
	L->next=p;
} 

//
//从链表中删除给定值在s到t之间（不包含s，t）的所有元素 
void del(LNode *&L,int s,int t){
	LNode *p=L;
	while(p->next!=NULL){
		if(p->next->data > s && p->next->data < t){
			LNode *u=p->next;
			p->next=u->next;
			free(u);
		}
		else
			p=p->next;
	}
}

//
//在带头结点的单链表中删除最小值点
void del_min(LNode *&L){
	LNode *p=L->next;
	LNode *minp=L;
	while(p->next!=NULL){
		if(p->next->data < minp->next->data)
			minp=p;
		p=p->next;
	}
	LNode *u=minp->next;
	minp->next=u->next;
	free(u);
} 

//
//不带头结点的单链表l中删除最小值点
void del_min(LNode *&L){
	LNode *minp=L;
	LNode *p=L->next;
	while(p!=NULL){
		if(p->data < minp->data)
			minp=p;
		p=p->next;
	}
	if(L==minp){
		L=L->next;
		free(minp);
		return;
	}
	p=L;
	while(p->next!=minp)
		p=p->next;
	p->next=minp->next;
	free(minp);
} 

//
//给定单链表，按递增排序输出单链表中个结点的数据元素，并释放节点所占空间
void del_min(LNode *&head){
	while(head->next!=NULL){
		LNOde *pre=head;
		LNode *p=head->next;
		while(p->next!=NULL){
			if(p->next->data < pre->next->data)
				pre=p;
			p=p->next; 
		}
		count<<pre->next->data<<"";
		LNode *u=pre->next;
		pre->next=u->next;
		free(u);
	}
	free(head);
} 

//
//将一个带头结点的单链表A分解成两个带头结点的单链表AB
//A中含奇数位置元素，B中含偶数位置元素，相对位置不变
Linklist create(LNode *&A){
	LNode *B=new LNode;
	B->next=NULL;
	LNode *ra=A,*rb=B,*p=A->next;
	A->next=NULL;
	while(p!=NULL){
		ra->next=p;
		ra=p;
		p=p->next;
		rb->next=p;
		rb=p;
		if(p!=NULL)
			p=p->next; 
	}
	ra->next=NULL;
	return B;
} 

//
//将一个单链表（a1,b1,a2,b2...an,bn)拆分成（a1,a2..an)和（bn,bn-1,...b1)
Linklist create(LNode *&A){
	LNode *B=new LNode;
	B->next=NULL;
	LNode *ra=A,*p=A->next,*q;
	A->next=NULL;
	while(p!=NULL){
		ra->next=p;
		ra=p;
		p=p->next;
		q=p;
		if(q==NULL)
			break;
		p=p->next;
		q->next=B->next;
		B->next=q;	
	}
	ra->next=NULL;
	return B;
} 

//
//删除递增链表中重复的元素
void del(LNode *&L){
	LNode *p=L->next;
	LNode *q;
	if(p==NULL)
		return;
	while(p->next!=NULL){
		q=p->next;
		if(p->data==q->data){
			p->next=q->next;
			free(q);
		} 
		else
			p=p->next;
	}	
} 

//
//两个递增有序的单链表，合并成一个非递减有序的链表
void fun(LNode *&A,LNode *&B){
	LNode *p=A->next,*q=B->next;
	A->next=NULL;
	B->next=NULL;
	LNode *ra=A;
	while(p!=NULL&&q!=NULL){
		if(p->data <= q->data){
			ra->next=p;
			p=p->next;
			ra=ra->next;
		}
		else{
			ra->next=q;
			q=q->next;
			ra=ra->next;
		}
	} 
	if(p!=NULL)
		ra->next=p;
	if(q!=NULL)
		ra->next=q;
} 

//
//两个递增有序地单链表，设计成一个非递增有序的链表
void fun(LNode *&A,LNode *&B){
	LNode *p=A->next,*q=B->next,*s;
	A->next=NULL;
	B->next=NULL;
	while(p!=NULL&&q!=NULL){
		if(p->data <= q->data){
			s=p;
			p=p->next;
			s->next=A->next;
			A->next=s;
		}
		else{
			s=q;
			q=q->next;
			s->next=A->next;
			A->next=s;
		}
}
while(p!=NULL){
	s=p;
	p=p->next;
	s->next=A->next;
	A->next=s;
}
while(q!=NULL){
	s=q;
	q=q->next;
	s->next=A->next;
	A->next=s;
}
}

//
//AB两个单链表递增有序，从AB中找出公共元素产生单链表C
//要求不破坏AB结点
Linklist common(LNode *A,LNode *B){
	LNode *p=A->next;
	Lnode *q=B->next;
	LNode *C=new LNode;
	LNode *r=C,*s;
	while(p!=NUll&&q!=NULL){
		if(p->data < q->data)
			p=p->next;
		else if(p->data > q->data)
			q=q->next;
		else{
			s=new LNode;
			s->data=p->data;
			r->next=s;
			r=s;
			p=p->next;
			q=q->next; 
		} 
	}
	r->next=NULL;
	return C;
}

#include<stdio.h>
#include<malloc.h>
struct node//先定义一个结构体，里面包含数据与结构体指针
{
	int data;
	struct node* next;
};
int main()
{
	struct node* head, * tail, * p;
	head = (struct node*)malloc(sizeof(struct node));//先在头指针开辟一个存储空间，但是不储存数据
	head->data = 9;
	head->next = NULL;//初始化头指针指向空指针
	tail = NULL;//尾指针初始化为空指针
	int x;
	int n;
	scanf("%d", &n);//输入想要的数字n个
	int i = 0;
	//输入数组
	while (i<n)
	{
		p = (struct node*)malloc(sizeof(struct node));
		scanf("%d", &x);
		p->data = x;
		p->next = NULL;//p的指向下一个指针为空指针
		if (head->next == NULL)
			head->next = p;//固定头指针指向的指针，然后保持不变
		else
			tail->next = p;//此时的空间是新开辟的空间，tail->next即是上一个空间p->next
		tail = p;//为指针指向p,可以理解作为一个桥梁，用来储存是一个指向的空间
		i++;
	}
	//输出数组
	int j;
	for (j = 0, p = head->next; j < n; p = p->next,j++)
		printf("%d ", p->data);
	return 0;
}//实现链表输入输出功能

//
// AB两个单链表递增有序，从AB中找出公共元素存放于A
void Union(Lnode *&A,LNode *&B){
	LNode *p=A->next,*q=B->next;
	LNode *ra=A,*u;
	while(P!=NULL&&q!=NULL){
		if(q->data < p->data){
			u=p;
			p=p->next;
			free(u); 
		}
		else if(p->data > p->data){
			u=q;
			q=q->next;
			free(u);
		}
		else{
			ra->next=p;
			ra=p;
			p=p->next;
			u=p;
			q=q->next;
			free(u);
		}
	}
	while(p!=NULL){
		u=p;
		p=p->next;
		free(u);
	}
	while(q!=NULL){
		u=q;
		q=q->next;
		free(u);
	}
	ra->next=NULL;
	free(q);
} 

//
//查找单链表中倒数第K个结点，若成功输出该节点data，并返回1，否则返回0
int find(LNode *head,int k){
	LNode *q=head->next;
	LNode *p=head;
	int i=1;
	while(q!=NULL){
		q=q->next;
		++i;
		if(i>=k)
			p=p->next;
	}
	if(p==next)
		return 0;
	else
	{
		count<<p->next;
		return 1;
	 } 
}

//
//用单链表保存m个整数，并且|data|<=n
//设计时间复杂度尽可能高效的算法，对于data绝对值相等的点，仅保留第一次出现的点
void fun(LNode *&head,int n){
 	LNode *p=head;
 	LNode *r;
 	int *q=new int[n];
 	int m;
 	for(int i=0;i<n;++1)
 		q[i]=0;
 	while(p->next!=NULL){
 		if(p->next->data > 0)
 			m=p->next->data;
 		else
 			m=-p->next->data;
 		if(q[m-1]==0)
		 	q[m-1]=1;
			p=p->next; 
	 } 
	 else{
	 	r=p->next; 
	 	p->next=r->next;
	 	free(r);
	 }
 } 
free(q);

//
//判断带头结点的循环双链表是否对称
int fun(DNode *L){
	DNode *p=L->next;
	DNode *q=L->prior;
	while(p!=q&&q->next!=p){
		if(p->data == q->data){
			p=p->next;
			q=q->prior;
		} 
	}
	else
		return 0;
	return 1;
} 

//
//有两个循环单链表，链表头指针分别为h1,h2
//编写函数将h2链接到h1之后，要求链接后仍保持循环链表形式
void link(LNode *&h1,LNode *&h2){
	LNode *p,*q;
	p=h1,q=h2;
	while(p->next!=h1)
		p=p->next;
	while(q->next!=h2)
		q=q->next;
	p->next=h2;
	q->next=h1;
} 


//
//设有一个带头结点的循环单链表，其结点值为正整数
//设计算法反复找出链表中最小值并不断输出，并将结点从链表中删除，直至链表为空，再删除表头结点
void del(LNode *&L){
	LNode *p,*minp,*u;
	while(L->next!=L){
		p=L->next;
		minp=L;
		while(p->next!=L){
			if(p->next->data < minp->next->data){
				minp=p;
			p=p->next;
			}
		}
		printf("%d",minp->next->data);
//		count<<minp->next->data<<end1;
		u=minp->next;
		minp->next=u->next;
		free(u);	
	}
	free(L);
} 

//
//判断单链表是否有环
int find(LNode *L){
	LNode *fast=L,*slow=L;
	while(fast&&fast->next){
		slow=slow->next;
		fast=fast->next->next;
		if(slow==fast) 
			return 1;
	}
	return 0;
} 

//
//给定一个单链表L(a1,a2,a3...an)将其重新排列为(a1,an,a2,an-1...)
Linklist divrev(LNode *&L){
	LNode *p=L,*q=l;
	while(q!=NULL&&q->next!=NULL){
		p=p->next;
		q=q->next->next; 
	}
	LNode *L1=new LNode;
	L1->next=p->next;
	p->next=NULL;
	LNode *p1=L1->next,*r;
	L1->next=NULL;
	while(p!=NULL){
		r=p1->next;
		p1->next=L1->next;
		L1->next=p1;
		p1=r; 
	} 
	return L1;
} 
void merge(LNode *&L){
	LNode *r,*s;
	LNode *p=L->next,*q=L1->next;
	L1->next=NULL;
	while(q!=NULL){
		r=p->next;
		s=q->next;
		p->next=q;
		q->next=r;
		p=r;
		q=s;
	}
}