Day7-数据结构整理

ck钉钉钉

已于 2023-07-24 10:09:41 修改

阅读量807

点赞数

分类专栏：转世重生文章标签：数据结构算法

于 2023-07-23 19:12:17 首次发布

本文链接：https://blog.csdn.net/ck0056/article/details/131882200

版权

转世重生专栏收录该内容

46 篇文章 1 订阅

订阅专栏

二叉树的创建与遍历

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct Node
{
	char data;
	struct Node *left;
	struct Node *right;
}*Btree;
//创建二叉树　返回二叉树根节点地址
Btree create_tree()
{
	char e;
	printf("请输入tree->data:");
	scanf(" %c",&e);
	if(e=='0')
		return NULL;
	Btree tree=(Btree)malloc(sizeof(struct Node));
	if(tree==NULL)
		return NULL;
	tree->data=e;
	//递归创建左
	printf("左:");
	tree->left=create_tree();
	//递归创建右
	printf("右:");
	tree->right=create_tree();
	return tree;
}
//先序遍历
void first_output(Btree tree)
{
	if(tree==NULL)
		return;
	printf("%c ",tree->data);
	first_output(tree->left);
	first_output(tree->right);
}
//中序遍历
void mid_output(Btree tree)
{
	if(tree==NULL)
		return;
	mid_output(tree->left);
	printf("%c ",tree->data);
	mid_output(tree->right);
}
//后序遍历
void last_output(Btree tree)
{
	if(tree==NULL)
		return;
	last_output(tree->left);
	last_output(tree->right);
	printf("%c ",tree->data);
}
//计算各个节点个数
void count_tree(Btree tree,int *n0,int *n1,int *n2)
{
    if(tree==NULL)
        return;
    
    if(tree->left==NULL && tree->right==NULL)
        (*n0)++;//++*n0
    else if(tree->left!=NULL && tree->right!=NULL)
        (*n2)++;
    else
        (*n1)++;
    count_tree(tree->left,n0,n1,n2);
    count_tree(tree->right,n0,n1,n2);
}
int main(int argc, const char *argv[])
{
	//创建加输入，用递归
	Btree tree=create_tree();
	puts("先序遍历:");
	first_output(tree);
	puts("");
	puts("中序遍历:");
	mid_output(tree);
	puts("");
	puts("后序遍历:");
	last_output(tree);
	puts("");
	int n0=0,n1=0,n2=0;
	count_tree(tree,&n0,&n1,&n2);
	printf("n0=%d n1=%d n2=%d\n",n0,n1,n2);
	return 0;
}

查找

二分查找

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//升序
int half(int key,int *arr,int low,int high)
{
	int mid;
	while(low<=high)
	{
		mid=(low+high)/2;
		if(key==*(arr+mid))
			return mid;
		else if(key>*(arr+mid))
			low=mid+1;
		else
			high=mid-1;
	}
	return -1;
}
//降序
int half_2(int key,int *arr,int low,int high)
{
	int mid;
	while(low<=high)
	{
		mid=(low+high)/2;
		if(key==*(arr+mid))
			return mid;
		else if(key<*(arr+mid))
			low=mid+1;
		else
			high=mid-1;
	}
	return -1;
}
int main(int argc, const char *argv[])
{
	//int arr[]={1,10,30,50,90,110,123,126,127};
	int arr[]={127,126,123,110,90,50,30,10,1};
	int n=sizeof(arr)/sizeof(int);
	int key;
	printf("please enter key:");
	scanf("%d",&key);
	int low=0,high=n-1;
	int sub=half_2(key,arr,low,high);
	if(sub==-1)
		puts("没找到");
	else
		printf("在数组的第%d个位置\n",sub+1);
	return 0;
}

排序

直接插入排序

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, const char *argv[])
{
	int arr[10]={-5,9,6,3,1,0,10,-9,6,-7};
	int i,j,t;
	int *p=arr;
	for(i=1;i<10;i++)
	{
		t=*(p+i);
		for(j=i-1;j>=0;j--)
		{
			if(t<*(p+j))
				*(p+j+1)=*(p+j);
			else
				break;
		}
		*(p+j+1)=t;
	}
	for(i=0;i<10;i++)
	{
		printf("%d ",*(p+i));
	}
	printf("\n");
	return 0;
}

快速排序

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/*
 * function:    一轮排序
 * @param [ in] 
 * @param [out] 
 * @return      返回基准值的下表
 */
int one_sort(int arr[],int low,int high)
{
    int key=arr[low];//确定数组的第一个元素为基准值
    //low==high  循环结束
//    1  34  45   23  56
//    l
//h
    while(low<high)
    {
        
        //循环从右边开始比较
        while(low<high && key <=arr[high])
        {
            high--;
        }
        arr[low]=arr[high];
        //循环从左边开始
        while(low<high &&key >=arr[low])
        {
            low++;
        }
        arr[high]=arr[low];
    }
arr[low]=key;//把基准值插入到数组中  low/high就是基准值的下表
    return low;//high

}
void quick_sort(int arr[],int low,int high)
{
    //没有元素low>high
    //只有一个元素：low==high
    if(low>=high)
        return;
    
    //一轮排序
    int mid=one_sort(arr,low,high);
    //递归左边：递归左子树
    
    quick_sort(arr,low,mid-1);
    //递归右边：递归右子树
    quick_sort(arr,mid+1,high);
}
int main(int argc, const char *argv[])
{
    int arr[]={12,3,34,23,14,45,76,23,12};
    int len=sizeof(arr)/sizeof(arr[0]);
    quick_sort(arr,0,len-1);

    for(int i=0;i<len;i++)
    {
        printf("%d\t",arr[i]);
    }
    return 0;
}

链表

单链表

头插、头删、尾插、尾删、按位置插入和删除、排序、逆置、查找倒数第n个节点

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef int datatype;
typedef struct Node
{
	datatype data;
	struct Node *next;
}*Linklist;
 
Linklist change_data(int data,Linklist l,int e);  //按元素修改
Linklist insert_data_keke(int data,Linklist l,int e); //按元素插入(往前插)
void selection_sort(Linklist l);  //简单选择排序
void Bubble(Linklist l);  //冒泡排序
Linklist free_sqace(Linklist l);   //释放
Linklist rev_linklist(Linklist l);   //逆置
Linklist delete_by_data(int e,Linklist l);   //按元素删除
int search_by_data(int e,Linklist l);  //按元素查找
Linklist delete_by_pos(int n,Linklist l);//任意位置删除
Linklist bull(Linklist l);   //排序
int find_data(int n,Linklist l);  //任意位置查找
Linklist amend_data(int n,Linklist l);  //任意位置修改
Linklist insert_data(int n,Linklist l,int e);  //按位置插入
int Linklist_len(Linklist l);  //计算链表元素个数
Linklist delete_real(Linklist l);  //尾删
Linklist insert_end(int e,Linklist l);  //尾插1.0
Linklist delete_head(Linklist l);  //头删
Linklist creat_node();  //申请节点空间
Linklist insert_head(datatype e,Linklist l);  //头插
int ouputs(Linklist l);  //输出
Linklist insert_tail(datatype e,Linklist rear);  //尾插
Linklist creat_node()  //申请节点空间
{
	Linklist node=(Linklist)malloc(sizeof(struct Node));
	if(NULL==node)
		return NULL;
	node->data=0;
	node->next=NULL;
	return node;
}
Linklist insert_head(datatype e,Linklist l)  //头插
{
	Linklist node=creat_node();
	if(NULL==node)
		return NULL;
	node->data=e;
	node->next=l;
	l=node;
	return l;
}
int  ouputs(Linklist l)  //输出
{
	if(NULL==l)
	{
		return -1;
	}
	while(l!=NULL)
	{
		printf("%d ",l->data);
		l=l->next;
	}
	printf("\n");
}
Linklist insert_tail(datatype e,Linklist rear)  //尾插
{
	Linklist s=creat_node();
	if(NULL==s)
		return NULL;
	s->data=e;
	if(rear!=NULL)
		rear->next=s;
	rear=s;
	return rear;
 
}
Linklist insert_end(int e,Linklist l)  //尾插1.0
{
	Linklist s=creat_node();
	s->data=e;
	if(l==NULL)
	{
		l=s;
	}
	else
	{
		Linklist end=l;
		while(end->next!=NULL)
		{
			end=end->next;
		}
		end->next=s;
	}
	return l;
}
Linklist delete_head(Linklist l)  //头删
{
	if(NULL==l)
		return l;
	if(l->next==NULL)
	{
		free(l);
		l=NULL;
	}
	else
	{
		Linklist q=l->next;
		l->data=q->data;
		l->next=q->next;
		free(q);
		q=NULL;
	}
	return l;
}
Linklist delete_real(Linklist l)  //尾删
{
	if(NULL==l)
		return NULL;
	else if(l->next==NULL)
	{
		free(l);
		l=NULL;
	}
	else
	{
		Linklist p=l;
		while(p->next->next!=NULL)
		{
			p=p->next;
		}
		free(p->next);
		p->next=NULL;
	}
	return l;
}
int Linklist_len(Linklist l)  //计算链表元素个数
{
	int count=0;
	while(l!=NULL)
	{
		l=l->next;
		count++;
	}
	return count;
}
Linklist insert_data(int n,Linklist l,int e)  //按位置插入
{
	//１.判断链表是否为空
	//２.判断位置是否合法
	int len=Linklist_len(l);
	if(NULL==l||n<1||n>len+1)
	{
		puts("insert error\n");
		exit(-1);
	}
	Linklist p=l;
	if(n==len+1)
	{
		insert_end(e,l);
		return l;
	}
	else
	{
		for(int i=1;i<n;i++)
		{
			p=p->next;
		}
		Linklist s=creat_node();
		s->next=p->next;
		p->next=s;
		s->data=p->data;
		p->data=e;
		return l;
	}
}
Linklist amend_data(int n,Linklist l)  //任意位置修改
{
	int len=Linklist_len(l);
	if(NULL==l||n<1||n>len)
	{
		printf("insert error\n");		
		exit(-1);
	}
	int i;
	Linklist p=l;
	for(i=1;i<n;i++)
	{
		p=p->next;
	}
	printf("please enter the modified data:");
	int e;
	scanf("%d",&e);
	p->data=e;
	return l;
}
int find_data(int n,Linklist l)  //任意位置查找
{
	int len=Linklist_len(l);
	if(NULL==l||n<1||n>len)
	{
		printf("insert error\n");		
		 exit(-1);
	}
	int i;
	Linklist p=l;
	for(i=1;i<n;i++)
	{
		p=p->next;
	}
	return p->data;
}
Linklist bull(Linklist l)   //排序
{
	int len=Linklist_len(l);
	int arr[len];
	int i,j,t;
	Linklist p=l;
	Linklist q=l;
	for(i=0;i<len;i++)
	{
		arr[i]=p->data;
		p=p->next;
	}
	for(i=1;i<len;i++)
	{
		for(j=0;j<len-i;j++)
		{
			if(arr[j]>arr[j+1])
			{
				t=arr[j];arr[j]=arr[j+1];arr[j+1]=t;
			}
		}
	}
	for(i=0;i<len;i++)
	{
		q->data=arr[i];
		q=q->next;
	}
	return l;
}
Linklist delete_by_pos(int n,Linklist l)   //按任意位置删除
{
	if(NULL==l||n<1||n>Linklist_len(l))
	{
		exit(-1);
	}
	if(n==1)
	{
		delete_head(l);
	}
	else
	{
		Linklist p=l;
		for(int i=1;i<n-1;i++)
		{
			p=p->next;
		}
		Linklist q=p->next;
		p->next=q->next;
		free(q);
		q=NULL;
	}
	return l;
}
int search_by_data(int e,Linklist l)  //按元素查找
{
	if(NULL==l)
	{
		 exit(-1);
	}
	int n=0;
	while(l!=NULL)
	{
		n++;
		if(l->data==e)
		{
			return n;
		}
		l=l->next;
	}
	return -1;
}
/*Linklist delete_by_data(int e,Linklist l)   //按元素删除
{
	if(search_by_data(e,l)==-1)
		return l;
	else
	{
		//int n=Linklist_len(l);
		Linklist p=l;
		while(p!=NULL)
		{
			for(int i=1;i<Linklist_len(l);i++)
			{
				if(p->data==e)
					l=delete_by_pos(i,p);
				p=l;
			}
			p=p->next;
		}
	}
	return l;
}*/
Linklist rev_linklist(Linklist l)   //逆置
{
	if(NULL==l || l->next==NULL)
	{
		return l;
	}
	Linklist p=l->next;
	int len=Linklist_len(l)-1;
	l->next=NULL;
	for(int i=0;i<len;i++)
	{
		Linklist t=p;
		p=p->next;
		t->next=l;
		l=t;
	}
	return l;
}
Linklist free_sqace(Linklist l)   //释放
{
	if(NULL==l)
	{
		return l;
	}
	int len=Linklist_len(l);
	for(int i=0;i<len;i++)
	{
		l=delete_head(l);
	}
	return l;
}
void Bubble(Linklist l)  //冒泡排序
{
	if(NULL==l || l->next==NULL)
	{
		return ;
	}
	int len=Linklist_len(l);
	Linklist p;
	for(int i=1;i<len;i++)
	{
		p=l;
		for(int j=0;j<len-i;j++)
		{
			if(p->data > p->next->data)
			{
				int t = p->data;
				p->data = p->next->data;
				p->next->data = t;
			}	
			p=p->next;
		}
	}
}
void selection_sort(Linklist l)  //简单选择排序
{
	if(NULL==l || l->next==NULL)
	{
		return ;
	}
	int len=Linklist_len(l);
	Linklist min=NULL;
	Linklist p=l;
	for(int i=0;i<len-1;i++)
	{
		min=p;
		for(int j=i+1;j<len;j++)
		{
			if(min->data > min->next->data)
			{
				min=min->next;
			}
		}
		if(min!=l)
		{
			int t=p->data;
			p->data=min->data;
			min->data=t;
		}
		p=p->next;
	}
}
Linklist insert_data_keke(int data,Linklist l,int e) //按元素插入(往前插)
{
	if(NULL==l)
		return l;
	Linklist p=l;
	int count=0;
	while(p!=NULL)
	{
		if(p->data==data)
			count++;
		p=p->next;
	}
	if(count==0)
	{
		puts("没有这个元素");
		return l;
	}
	else
	{
		p=l;
	/*	Linklist s=creat_node();
		while(p->data!=data)
		{
			p=p->next;
		}
		s->next=p->next;
		p->next=s;
		s->data=p->data;
		p->data=e;
	*/
		Linklist q=NULL;
		int count=0;
		while(p!=NULL)
		{
			if(p->data==data)
			{
				count++;
			}
			p=p->next;
		}
		p=l;
		for(int i=0;i<count;i++)
		{
			while(p!=NULL)
			{
				if(p->data==data)
				{
					Linklist s=creat_node();
					s->next=p->next;
					p->next=s;
					s->data=p->data;
					p->data=e;
					q=s->next;
					break;
				}
				p=p->next;
			}
			p=q;
		}
		return l;
	}
}
Linklist change_data(int data,Linklist l,int e)  //按元素修改
{
	if(NULL==l)
		return l;
	Linklist p=l;
	int count=0;
	while(p!=NULL)
	{
		if(p->data==data)
			count++;
		p=p->next;
	}
	if(count==0)
	{
		puts("没有这个元素");
		return l;
	}
	else
	{
		p=l;
		while(p!=NULL)
		{
			if(p->data==data)
			{
				p->data=e;
			}
			p=p->next;
		}
		return l;
	}
}
int main(int argc, const char *argv[])
{
	Linklist l=NULL;
	int n;
	datatype e;
	printf("please enter n:");
	scanf("%d",&n);
	/*for(int i=0;i<n;i++)
	{
		//头插
		printf("please enter elemen:");
		scanf("%d",&e);
		l=insert_head(e,l);
	}*/
	for(int i=0;i<n;i++)
	{
		//尾插
		printf("please enter elemen:");
		scanf("%d",&e);
		l=insert_end(e,l);
	}
//	delete_head(l);
//	l=delete_real(l);
//	l=insert_data(l);
/*	ouputs(l);
	printf("请输入要插入的位置：");
	int n1;
	scanf("%d",&n1);
	printf("please enter elemen:");
	scanf("%d",&e);
	l=insert_data(n1,l,e);
	ouputs(l);
	ouputs(l);
	printf("请输入要修改的位置：");
	int n1;
	scanf("%d",&n1);
	l=amend_data(n1,l);
	ouputs(l);*/
	ouputs(l);
//	printf("请输入要查找的位置：");
//	int n1;
//	scanf("%d",&n1);
//	printf("%d\n",find_data(n1,l));
//	l=bull(l);
//	printf("请输入要删除的位置：");
//	int d;
//	printf("请输入要删除的元素：");
//	scanf("%d",&d);
//	l=delete_by_pos(d,l);
//	if(search_by_data(d,l)==-1)
//		puts("没找到");
//	else
//		printf("在第%d个\n",search_by_data(d,l));
//	l=free_sqace(l);
//	Bubble(l);
	int c;
	printf("请输入插入位置元素:");
	scanf("%d",&c);
	int d;
	printf("请输入要插入的元素:");
	scanf("%d",&d);
	l=insert_data_keke(c,l,d);
	ouputs(l);
	return 0;
}

单向循环链表

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef int datatype;
typedef struct Node
{
	datatype data;
	struct Node *next;
}*Linklist;


void Yuesefu(int n,int m,Linklist l);   //约瑟夫环
Linklist delete_real(Linklist l);  //尾删
Linklist delete_head(Linklist l);  //头删
Linklist insert_end(datatype e,Linklist rear);  //尾插
int  ouputs(Linklist l);  //输出
Linklist creat_node();  //申请节点空间
Linklist insert_head(datatype e,Linklist l);  //头插
{
	Linklist node=(Linklist)malloc(sizeof(struct Node));
	if(NULL==node)
		return NULL;
	node->data=0;
	node->next=node;
	return node;
}
Linklist insert_head(datatype e,Linklist l)  //头插
{
	Linklist node=creat_node();
	if(NULL==l)
	{
		l=node;
		node->data = e;
	}
	else
	{
		node->next = l->next;
		l->next = node;
		node->data = l->data;
		l->data = e;
	}
	return l;
}
int  ouputs(Linklist l)  //输出
{
	if(NULL==l)
	{
		return -1;
	}
	Linklist p=l;
	do
	{
		printf("%d ",p->data);
		p=p->next;
	}while(p!=l);
	printf("\n");
}
Linklist insert_end(int e,Linklist l)  //尾插1.0
{
	Linklist s=creat_node();
	s->data=e;
	if(l==NULL)
	{
		l=s;
	}
	else
	{
		Linklist end=l;
		while(end->next!=l)
		{
			end=end->next;
		}
		end->next=s;
		s->next=l;
	}
	return l;
}
Linklist delete_head(Linklist l)  //头删
{
	if(NULL==l)
		return l;
	if(l->next==l)
	{
		free(l);
		l=NULL;
	}
	else
	{
		Linklist end=l;
		while(end->next!=l)
		{
			end=end->next;
		}
		Linklist q=l->next;
		l->data=q->data;
		l->next=q->next;
		end->next=l;
		free(q);
		q=NULL;
	}
	return l;
}
Linklist delete_real(Linklist l)  //尾删
{
	if(NULL==l)
		return NULL;
	else if(l->next==l)
	{
		free(l);
		l=NULL;
	}
	else
	{
		Linklist p=l;
		while(p->next->next!=l)
		{
			p=p->next;
		}
		free(p->next);
		p->next=l;
	}
	return l;
}
void Yuesefu(int n,int m,Linklist l)   //约瑟夫环
{
	Linklist p=l;
	for(int i=0;i<n;i++)
	{
		for(int j=1;j<m-1;j++)
		{
			p=p->next;
		}
		Linklist q=p->next;
		printf("%d ",q->data);
		p->next=q->next;
		free(q);
		q=NULL;
		p=p->next;
	}
	printf("\n");
}
int main(int argc, const char *argv[])
{
/*	Linklist l=NULL;
	int n;
	datatype e;
	printf("please enter n:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		//头插
		printf("please enter elemen:");
		scanf("%d",&e);
		l=insert_end(e,l);
	}
	ouputs(l);
//	printf("请输入想插入的值：");
//	int d;
//	scanf("%d",&d);
	l=delete_real(l);
	ouputs(l);*/
	Linklist l=NULL;
	int n;
	printf("请输入人数：");
	scanf("%d",&n);
	for(int i = 1;i <= n; i++)
	{
		l=insert_end(i,l);
	}
	printf("请输入数字：");
	int m;
	scanf("%d",&m);
	Yuesefu(n,m,l);
	return 0;
}

双向链表

头插、尾插、头删、尾删、逆置

#ifndef __HEAD_H__
#define __HEAD_H__
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef char  datatype[20];
typedef struct Node
{
	
	datatype data;
	struct Node *next;
	struct Node *prev;
}*DoubleLink;


//逆置2.0
DoubleLink inversion2_0(DoubleLink l);
DoubleLink create_node();  //创建节点

//　头插
DoubleLink insert_head(datatype e,DoubleLink l);

// 输出
void outpus(DoubleLink l);

//　尾插
DoubleLink insert_real(datatype e,DoubleLink l);

//　头删
DoubleLink del_head(DoubleLink l);

//　尾删
DoubleLink del_real(DoubleLink l);
//逆置
DoubleLink inversion(DoubleLink l);
#endif
DoubleLink create_node()  //创建节点
{
	DoubleLink node=(DoubleLink)malloc(sizeof(struct Node));
	if(NULL==node)
	{
		return NULL;
	}
//对新节点的数据域赋值
	strcpy(node->data,"");
//对指针域赋值
	node->next=node->prev=NULL;
	return node;
}
// 输出
void outpus(DoubleLink l)
{
	//判断链表是否为空
	if(l==NULL)
		return;
	//正向遍历
	puts("正向遍历");
	while(l->next!=NULL)
	{
		printf("%s ",l->data);
		l=l->next;
	}
	printf("%s\n",l->data);
	//逆向遍历
/*	puts("逆向遍历");
	while(l!=NULL)
	{
		printf("%s ",l->data);
		l=l->prev;
	}
	printf("\n");*/
}
//　头插
DoubleLink insert_head(datatype e,DoubleLink l)
{
	DoubleLink s=create_node();
	if(NULL==s)
		return l;
	strcpy(s->data,e);
	if(NULL!=l)
	{
		s->next=l;
		l->prev=s;
	}
	l=s;
	return l;
}
//　尾插
DoubleLink insert_real(datatype e,DoubleLink l)
{
	DoubleLink s=create_node();
	if(NULL==s)
	{
		return l;
	}
	strcpy(s->data,e);
	if(NULL==l)
	{
		l=s;
		return l;
	}
	DoubleLink real=l;
	while(real->next!=NULL)
		real=real->next;
	real->next=s;
	s->prev=real;
	return l;
}
//　　头删
DoubleLink del_head(DoubleLink l)
{
	if(l==NULL)
		return l;
	if(l->next==NULL)
	{
		free(l);
		l=NULL;
		return l;
	}
	else if(l->next->next==NULL)
	{
		DoubleLink q=l->next;
		strcpy(l->data,q->data);
		l->next=l->prev;
		free(q);
		q=NULL;
		return l;
	}
	else
	{
		DoubleLink q=l->next;
		strcpy(l->data,q->data);
		l->next=q->next;
		q->next->prev=l;
		free(q);
		q=NULL;
		return l;
	}
}

//　尾删
DoubleLink del_real(DoubleLink l)
{
	if(NULL==l)
		return l;
	if(NULL==l->next)
	{
		free(l);
		l=NULL;
		return l;
	}
	else
	{
		DoubleLink real=l;
		while(real->next!=NULL)
			real=real->next;
		real->prev->next=NULL;
		free(real);
		real=NULL;
		return l;
	}
}

//逆置
DoubleLink inversion(DoubleLink l)
{
	if(NULL==l||l->next==NULL)
		return l;
	datatype t;
	DoubleLink	p=l;
	while(l->next!=NULL)
		l=l->next;
	DoubleLink q=l;
	l=p;
	while(p!=q&&p->prev!=q)
	{
		strcpy(t,q->data);
		strcpy(q->data,p->data);
		strcpy(p->data,t);
		p=p->next;
		q=q->prev;
	}
	return l;
}

//逆置2.0
DoubleLink inversion2_0(DoubleLink l)
{
	if(NULL==l||l->next==NULL)
		return l;
	DoubleLink p=l->next;
	l->next=NULL;
	int i;
	for(i=0;i<4;i++)
	{
		DoubleLink t=p;
		t->prev=NULL;
		p=p->next;
		t->next=l;
		l->prev=t;
		l=t;
	}
	return l;
}
int main(int argc, const char *argv[])
{
	DoubleLink l=NULL;
	int n;
	printf("please enter n:");
	scanf("%d",&n);
	datatype e;
	for(int i=0;i<n;i++)
	{
		printf("please enter e:");
		scanf("%s",e);
//		l=insert_head(e,l);
		l=insert_real(e,l);
	}
	l=inversion2_0(l);
	outpus(l);
	return 0;
}

双向循环链表

#ifndef __HEAD_H__
#define __HEAD_H__
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef char  datatype[20];
typedef struct Node
{
	
	datatype data;
	struct Node *next;
	struct Node *prev;
}*DoubleLink;


DoubleLink create_node();  //创建节点

//　头插
DoubleLink insert_head(datatype e,DoubleLink l);

// 输出
void outpus(DoubleLink l);

//　尾插
DoubleLink insert_real(datatype e,DoubleLink l);

//　头删
DoubleLink del_head(DoubleLink l);

//　尾删
DoubleLink del_real(DoubleLink l);
#endif
int main(int argc, const char *argv[])
{
	DoubleLink l=NULL;
	int n;
	printf("please enter n:");
	scanf("%d",&n);
	datatype e;
	for(int i=0;i<n;i++)
	{
		printf("please enter e:");
		scanf("%s",e);
//		l=insert_head(e,l);
		l=insert_real(e,l);
	}
//	l=del_head(l);
	l=del_real(l);
	outpus(l);
	return 0;
}
DoubleLink create_node()  //创建节点
{
	DoubleLink node=(DoubleLink)malloc(sizeof(struct Node));
	if(NULL==node)
	{
		return NULL;
	}
//对新节点的数据域赋值
	strcpy(node->data,"");
//对指针域赋值
	node->next=node->prev=node;
	return node;
}
// 输出
void outpus(DoubleLink l)
{
	//判断链表是否为空
	if(l==NULL)
		return;
	//正向遍历
	puts("正向遍历");
	DoubleLink p=l;
	while(l->next!=p)
	{
		printf("%s ",l->data);
		l=l->next;
	}
	printf("%s\n",l->data);
	//逆向遍历
	puts("逆向遍历");
	while(l!=p)
	{
		printf("%s ",l->data);
		l=l->prev;
	}
	printf("%s\n",l->data);
}
//　头插
DoubleLink insert_head(datatype e,DoubleLink l)
{
	DoubleLink s=create_node();
	if(NULL==s)
		return l;
	strcpy(s->data,e);
	DoubleLink real;
	if(NULL!=l)
	{
		real=l->prev;
		s->next=l;
		l->prev=s;
		real->next=s;
		s->prev=real;
	}
	l=s;
	return l;
}
//　尾插
DoubleLink insert_real(datatype e,DoubleLink l)
{
	DoubleLink s=create_node();
	if(NULL==s)
	{
		return l;
	}
	strcpy(s->data,e);
	if(NULL==l)
	{
		l=s;
		return l;
	}
	DoubleLink real=l->prev;
	real->next=s;
	s->prev=real;
	s->next=l;
	l->prev=s;
	return l;
}
//　　头删
DoubleLink del_head(DoubleLink l)
{
	if(l==NULL)
		return l;
	DoubleLink p=l;
	if(l->next==p)
	{
		free(l);
		l=NULL;
		return l;
	}
	else
	{
		DoubleLink q=l->next;
		strcpy(l->data,q->data);
		l->next=q->next;
		q->next->prev=l;
		free(q);
		q=NULL;
		return l;
	}
}

//　尾删
DoubleLink del_real(DoubleLink l)
{
	if(NULL==l)
		return l;
	if(l==l->next)
	{
		free(l);
		l=NULL;
		return l;
	}
	else
	{
		DoubleLink real=l->prev;
		real->prev->next=l;
		l->prev=real->prev;
		free(real);
		real=NULL;
		return l;
	}
}

队列

循环队列

因为顺序队列的使用是一次性的，会出现假溢出问题，所以引出循环队列，解决假溢出问题。

循环队列创建

#include <string.h>
#include <stdlib.h>
typedef int datatyp;
#define MAXSIZE 5
typedef struct
{
	//队头
	int front;
	//队尾
	int rear;
	//数据元素
	datatyp data[MAXSIZE];
}QueueList;
//在堆区申请空间
QueueList *create_queue()
{
	QueueList *queue=(QueueList *)malloc(sizeof(QueueList));
	if(NULL==queue)
		return NULL;
	queue->front=queue->rear=0;
	memset(queue->data,0,sizeof(queue->data));
	return queue;
}

循环队列入队

/*
 * function:    循环队列入队
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int enqueue(datatype e,QueueList *queue)
{
    //1,判断是否创建
    //2，判断是否满
    if(NULL==queue ||queue->front==(queue->rear+1)%MAXSIZE)
    {
    puts("enqueue error");
    return -1;
    }
    //3,入队：在队尾插入
queue->data[queue->rear]=e;
queue->rear=(queue->rear+1)%MAXSIZE;
    return 0;
    
}

循环队列出队

/*
 * function:    出队
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delqueue(QueueList *queue)
{
    //1,判断是否创建
    //2，判断是否为空
    if(NULL==queue || queue->front==queue->rear)
    {
    puts("delqueue error");
    return -1;
    }
    //3,出队：出队在队头
    printf("delqueue data is:%d\n",queue->data[queue->front]);
queue->front=(queue->front+1)%MAXSIZE;
    return 0;

}

循环队列的遍历

/*
 * function:    循环输出队列
 * @param [ in] 
 * @param [out] 
 * @return      无
 */
void output(QueueList *queue)
{
    //1,判断是否创建
    //2，判断是否为空
    if(NULL==queue || queue->front==queue->rear)
    {
    puts("output error");
    return;
    }
    //3,从队头到队尾输出
    for(int i=queue->front;i!=queue->rear;i=(i+1)%MAXSIZE)
    {
    printf("%d\t",queue->data[i]);
    }
    puts("");
}

循环队列个数计算

/*
 * function:    计算循环队列个数
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int loop_queue_count(QueueList *queue)
{
 return (MAXSIZE-queue->front+queue->rear)%MAXSIZE;
}

链式队列

因为循环队列存在队满的情况，切适用于数据量较小的时候，所以引出链式队列，存储类型不同，不存在队满，可以存储数据量较多的时候。

链式队列节点创建【单链表节点创建】

/*
 * function:    创建一个节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist create_node()
{
    Linklist node=(Linklist)malloc(sizeof(struct Node));
    if(NULL==node)
        return NULL;
    node->data=0;
    node->next=NULL;
    return node;//0x10
}

链式队列入队【单链表尾插】

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist insert_rear(datatype e,Linklist L)
{
    //创建一个新节点
    Linklist s=create_node();
    s->data=e;
    if(L==NULL)
    {
        L=s;
    }
    else
    {
        //rear指向最后一个节点的地址
        Linklist rear=L;
        while(rear->next!=NULL)
        {
            rear=rear->next;
        }
        rear->next=s;
    }
    return L;
}

链式队列出队【单链表头删】

/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist delete_head(Linklist L)
{
    //判断链表是否为空
    if(NULL==L)
    {
        return L;
    }
    printf("delete data is:%d\n",L->data);
    if(L->next==NULL)
    {
        free(L);
        L=NULL;
    }
    else
    {
        Linklist q=L->next;
        L->data=q->data;
        L->next=q->next;
        free(q);
        q=NULL;
    }
    return L;


}

链式队列遍历【单链表的输出】

/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int link_output(Linklist L)
{
    //判断是否创建
    //判断是否为空
    if(NULL==L )
    {
        return -1;
    }
    while(L!=NULL)
    {
        printf("%d\t",L->data);
        L=L->next;
    }
    puts("");
}