数据结构初级

最新推荐文章于 2023-07-10 10:39:24 发布
最新推荐文章于 2023-07-10 10:39:24 发布
阅读量182 收藏 1
点赞数 3
分类专栏： # 数据结构与算法 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ly000666/article/details/109003556
版权

第一章：线性表
1.线性表的顺序存储

//请自行完成第一部分内容：头文件包含和常量定义
#define MAXSIZE 100
#define OK 1
#define ERROR 0

//请自行完成第二部分内容：先用typedef确定元素类型
//然后是结构体定义，务必注意最后要有分号
typedef int ElemType;
typedef struct
{
	ElemType elem[MAXSIZE];
	int last;
}SeqList;

//第三部分，自定义函数
int Locate(SeqList L,ElemType e)
{
	int i=0;   //i为扫描计数器，初值为0，即从第一个元素开始比较
	while((i<=L.last)&&(L.elem[i]!=e))   //顺序扫描表，直到找到值为key的元素
	    i++;
	if(i<=L.last)
		return(i+1);  //若找到值为e的元素，则返回其序号
	else
		return(-1);   //若没找到，则返回空序号
}

int InsList(SeqList *L,int i,ElemType e)
{
	int k;
	if((i<1)||(i>L->last+2))//首先判断插入位置是否合法
	{
		printf("插入位置i值不合法");
		return(ERROR);
	}
	if(L->last>=MAXSIZE-1)
	{
		printf("表已满无法插入");
		return(ERROR);
	}
	for(k=L->last;k>=i-1;k--) //为插入元素而移动位置
	     L->elem[k+1]=L->elem[k];
		 L->elem[i-1]=e;  //在C语言数组中，第i个元素的下标为i-1
		 L->last++;
		 return(OK);


int DelList(SeqList *L,int i,ElemType *e)
//在顺序表L中删除第i个数据元素，并用指针参数e返回值。i的合法取值为1
{
	int k;
	if((i<1)||(i>L->last+1))
	{
		printf("删除位置不合法！");
		return(ERROR);
	}
}
*e=L->elem[i-1];  //将删除的元素存放到e所指向的变量中
for(k=i;k<=L->last;k++)
     L->elem[k-1]=L->elem[k];
L->last--;
return(OK);
}

void Print(SeqList *L)
{
	int i;
	printf("表中元素为:");
	for(i=0;i<=L->last;i++)
		printf("%-6d%",L->elem[i]);
	printf("\n");
}

//第四部分，main函数
void main()
{
	SeqList H;
	int x;
	H.last=-1;
	
	InsList(&H,1,12);
	InsList(&H,2,5);
	InsList(&H,3,29);
	Print(&H);

	DelList(&H,2,&x);
	Print(&H);
	
    x=Locate(H,12);
	if(x==-1)
		printf("未找到");
	else
		printf("是第%d个元素",x);
}

2.线性表的链式存储单链表

/*请自行完成第一部分内容：头文件包含和常量定义*/
#include<stdio.h>
#define OK 1
#define ERROR 0


/*请自行完成第二部分内容：先用typedef确定元素类型，*/
/*然后是结构体定义，务必注意最后要有分号。*/

typedef char ElemType;
typedef struct Node
{
	ElemType data;
	struct Node* next;
}Node,*LinkList;
/*第三部分，自定义函数*/
void InitList(LinkList *L)/*对单链表进行初始化*/
{
	*L=(LinkList)malloc(sizeof(Node)); 
	(*L)->next=NULL;
}

void CreateFromTail(LinkList L)
{ 
	Node *r, *s;
	char c;
	int   flag =1; /*设置一个标志，初值为1，当输入"$"时，flag为0，建表结束*/
	r=L;                /*r指针动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/
	while(flag)         /*循环输入表中元素值，将建立新结点s插入表尾*/
	{
		c=getchar();
		if(c!='$')
		{
			s=(Node*)malloc(sizeof(Node));
			s->data=c;
			r->next=s;
			r=s;
		}
		else
		{
			flag=0;
			r->next=NULL;   /*将最后一个结点的next链域置为空，表示链表的结束*/
		}
	}   
} 

Node * Get (LinkList  L, int i)
/*在带头结点的单链表L中查找第i个结点，若找到(1≤i≤n)，则返回该结点的存储位置; 否则返回NULL*/
{  
	int j;
	Node  *p;
	p=L;
	j=0;   /*从头结点开始扫描*/ 
	while ((p->next!=NULL)&&(j<i))
	{ 
		p=p->next;    /* 扫描下一结点*/
		j++;   /* 已扫描结点计数器 */
	}
	if(i == j)
		return p;   /* 找到了第i个结点 */
	else 
		return NULL;   /* 找不到，i≤0或i>n */
}

int	ListLength(LinkList L)
/*求带头结点的单链表L的长度*/
{   
	Node *p;
	int j;
	p=L->next;
	j=0;   /*用来存放单链表的长度*/
	while(p!=NULL)
	{	  
		p=p->next;
		j++;
	}
	return j;	/*j为求得的单链表长度*/
}  

int InsList(LinkList L,int i,ElemType e)
/*在带头结点的单链表L中第i个位置插入值为e的新结点s*/
{  
	Node *pre,*s;
	int k;
	pre=L;  
	k=0;                     /*从"头"开始，查找第i-1个结点*/
	while(pre!=NULL&&k<i-1)  /*表未查完且未查到第i-1个时重复，找到pre指向第i-1个*/ 
	{ 
		pre=pre->next;
		k=k+1; 
	}									/*查找第i-1结点*/
	if(!pre)      /*如当前位置pre为空表已找完还未数到第i个，说明插入位置不合理*/ 
	{ 
		printf("插入位置不合理!");
		return ERROR;
	}
	s=(Node*)malloc(sizeof(Node));   /*申请一个新的结点S */
	s->data=e;                       /*值e置入s的数据域*/
	s->next=pre->next;				/*修改指针，完成插入操作*/
	pre->next=s;
	return OK;
}

int DelList(LinkList L,int i,ElemType *e)
/*在带头结点的单链表L中删除第i个元素，并将删除的元素保存到变量*e中*/
{  
	Node *pre,*r;
	int k;
	pre=L;
	k=0;
	while(pre->next!=NULL && k<i-1)	/*寻找被删除结点i的前驱结点i-1使p指向它*/
	{ 
		pre=pre->next; 
		k=k+1;
	}								/*查找第i-1个结点*/
	if(!(pre->next))     /* 即while循环是因为p->next=NULL或i<1而跳出的,而是因为没有找到合法的前驱位置，说明删除位置i不合法。*/
	{
		printf("删除结点的位置i不合理!");
		return ERROR;
	}
	r=pre->next;
	pre->next=pre->next->next;    /*修改指针，删除结点r*/
	*e = r->data;
	return OK;
}
void Print(LinkList L)
{	
	Node* p;
	printf("表中元素为:");
	p = L->next;
	while (p != NULL)
	{
		printf("%4c", p->data);
		p = p->next;
	}
	printf("\n");
}
/*第四部分，main函数*/
void main()
{
	LinkList H, p;
	int i; char c;
	InitList(&H);
	printf("请输入单链表元素值,以$结束！\n");
	CreateFromTail(H); Print(H);
	printf("长度为%d\n", ListLength(H));
	InsList(H, 2, 'n'); InsList(H, 2, 'p'); Print(H);
	printf("长度为%d\n", ListLength(H));
	DelList(H, 1, &c); Print(H);
	printf("长度为%d\n", ListLength(H));
	printf("请输入要查找的结点序号:\n"); scanf("%d", &i);
	p = Get(H, i);
	if (p != NULL)
		printf("第%d个结点的值为:%c\n", i, p->data);
	else
		printf("未找到此结点！\n");

}

第二章：限定性线性表—栈与队列
2.1栈

3.顺序栈

#include<stdio.h>
/*第一部分，自定义*/
#define TRUE 1
#define FALSE 0
#define Stack_Size 50

typedef char StackElementType;
typedef struct
{
   StackElementType elem[Stack_Size];
   int top;
}SeqStack;

/*第二部分，函数*/
/*初始化*/
void InitStack(SeqStack *S)
{
  /*构造一个空栈S*/
  S->top=-1;
}
/*判栈空*/
int IsEmpty(SeqStack *S) /*判断栈S为空栈时返回值为真，反之为假*/
{
  return(S->top==-1?TRUE:FALSE);
}
/*判栈满*/
int IsFull(SeqStack *S) /*判断栈S为满栈时返回值为真，反之为假*/
{
  return(S->top==Stack_Size-1?TRUE:FALSE);
}
/*进栈*/

/*出栈*/

/*读栈*/


/*主函数*/
void main()
{
  SeqStack N;char c;
  InitStack(&H);

  Push(&H,'A');
  Push(&H,'B');
  Push(&H,'C');
  printf("入栈序列为ABC，出栈序列为：");
  Pop(&H,&c);printf("%c",c);
  Pop(&H,&c);printf("%c",c);
  Pop(&H,&c);printf("%c",c);
}

4.链栈


#include<stdio.h>
#include<malloc.h>  //动态存储分配函数
#define TRUE 1
#define FALSE 0
//第二部分：结构体
typedef char StackElementType;
typedef struct node
{
StackElementType data;
struct node *next;
}LinkStackNode;
typedef LinkStackNode *LinkStack; 

//第三部分：函数
/*进栈操作。*/
int Push(LinkStack top, StackElementType x)/* 将数据元素x压入栈top中 */ 
{
	LinkStackNode *temp;
	temp=(LinkStackNode *)malloc(sizeof(LinkStackNode));
 	if(temp==NULL)  
 		return(FALSE);   /* 申请空间失败 */
	temp->data=x;
	temp->next=top->next;
	top->next=temp;   /* 修改当前栈顶指针 */ 
	return(TRUE);
}

/*出栈操作。*/
int Pop(LinkStack top, StackElementType *x)
{  
	/* 将栈top的栈顶元素弹出，放到x所指的存储空间中 */
	LinkStackNode * temp;
	temp=top->next;
	if(temp==NULL)  /*栈为空*/
		return(FALSE);
	top->next=temp->next;
	*x=temp->data;
	free(temp);   /* 释放存储空间 */
	return(TRUE);
}
//第四部分：主函数
void main()
{
	LinkStack H;char c;
	H=malloc(sizeof(LinkStackNode));
	H->next=NULL;
	Push(H,'G');
	Push(H,'D');
	Push(H,'S');
	printf("入栈顺序为G D S,出栈顺序为： ");
	Pop(H,&c);
	printf("%c",c);
	Pop(H,&c);
	printf("%c",c);
	Pop(H,&c);
	printf("%c",c);
}

2.2队列

5.链队列

#include<stdio.h>
#include<malloc.h>
#define  TRUE 1
#define  FALSE 0
#define MAXSIZE 50  /*队列的最大长度*/

//第二部分：结构体
typedef char QueueElementType;
typedef struct Node
{
	QueueElementType data;
	struct Node *next;
}LinkQueueNode;
typedef struct
{
	LinkQueueNode *front;
	LinkQueueNode *rear;
}LinkQueue;

//第三部分：函数
/*初始化操作。*/
int InitQueue(LinkQueue *Q)
{ 
	/* 将Q初始化为一个空的链队列 */
	Q->front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
	if(Q->front!=NULL)
	{
		Q->rear=Q->front;
		Q->front->next=NULL;
 		return(TRUE);
	}
	else return(FALSE);    /* 溢出！*/
}

/*入队操作。*/
int EnterQueue(LinkQueue *Q,QueueElementType x)
{  
	/* 将数据元素x插入到队列Q中 */
	LinkQueueNode *NewNode;
	NewNode=(LinkQueueNode * )malloc(sizeof(LinkQueueNode));
	if(NewNode!=NULL)
	{
		NewNode->data=x;
		NewNode->next=NULL;
		Q->rear->next=NewNode;
		Q->rear=NewNode;
		return(TRUE);
	}
	else  return(FALSE);    /* 溢出！*/
}

/*出队操作。*/
int DeleteQueue(LinkQueue *Q,QueueElementType *x)
{  
	/* 将队列Q的队头元素出队，并存放到x所指的存储空间中 */
	LinkQueueNode * p;
	if(Q->front==Q->rear)
		return(FALSE);
	p=Q->front->next;
	Q->front->next=p->next;  /* 队头元素p出队 */
	if(Q->rear==p)  /* 如果队中只有一个元素p，则p出队后成为空队 */
		Q->rear=Q->front;  
	*x=p->data;
	free(p);   /* 释放存储空间 */
	return(TRUE);	
}

//第四部分：主函数
void main()
{
	LinkQueue H;
	char c;
	InitQueue(&H);
	EnterQueue(&H,'S');
	EnterQueue(&H,'S');
	EnterQueue(&H,'B');
	printf("入队元素为SSB，出队元素为：");
	DeleteQueue(&H,&c);printf("%c",c);
	DeleteQueue(&H,&c);printf("%c",c);
	DeleteQueue(&H,&c);printf("%c",c);
}

6.循环队列（顺序队）

#include<stdio.h>
#include<malloc.h>
#define  TRUE 1
#define  FALSE 0
#define MAXSIZE 50  /*队列的最大长度*/

//第二部分：结构体
typedef char QueueElementType;
typedef struct 
{
	QueueElementType element[MAXSIZE];
	int front;
	int rear;
}SeqQueue;

//第三部分：函数
/*初始化操作*/
void InitQueue(SeqQueue *Q)
{  
	/* 将*Q初始化为一个空的循环队列 */
	Q->front=Q->rear=0;
}

/*入队操作*/
int EnterQueue(SeqQueue *Q, QueueElementType x)
{  
	/*将元素x入队*/
	if((Q->rear+1)%MAXSIZE==Q->front)  /*队列已经满了*/
		return(FALSE);
	Q->element[Q->rear]=x;
	Q->rear=(Q->rear+1)%MAXSIZE;  /* 重新设置队尾指针 */
	return(TRUE);  /*操作成功*/
}

/*出队操作*/
int DeleteQueue(SeqQueue *Q, QueueElementType *x)
{ 
	/*删除队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	Q->front=(Q->front+1)%MAXSIZE;  /*重新设置队头指针*/
	return(TRUE);  /*操作成功*/
}

//第四部分：主函数
void main()
{
	SeqQueue H;
	char c;
	InitQueue(&H);
	EnterQueue(&H,'S');
	EnterQueue(&H,'S');
	EnterQueue(&H,'B');
	printf("入队元素为SSB，出队元素为：");
	DeleteQueue(&H,&c);printf("%c",c);
	DeleteQueue(&H,&c);printf("%c",c);
	DeleteQueue(&H,&c);printf("%c",c);
}

约瑟夫问题：

/* Note:Your choice is C IDE */
#include<stdio.h>
typedef struct Node
{
	int password;
	int num;
	struct Node *next;
}Node,*Linklist;
void main()
{
	Linklist L;
	Node *p,*r,*q;
	int m,n,C,j;
	L=(Node*)malloc(sizeof(Node));
	if(L==NULL) {printf("\n链表申请不到空间！");return;}
		L->next=NULL;
		r=L;
	printf("请输入数据n的值（n>0):");
	scanf("%d",&n);
	for(j=1;j<=n;j++)
	{
	  p=(Node*)malloc(sizeof(Node));
	  if(p!=NULL)
	   {
	   printf("请输入第%d个人的密码:",j);
	   scanf("%d",&C);
	   p->password=C;
	   p->num=j;
	   r->next=p;
	   r=p;
	   }
	}
	r->next=L->next;
	printf("请输入第一个报数上限值m(m>0):");
	scanf("%d",&m);
	printf("***************************\n");
	printf("出列的顺序为：\n");
	q=L;
	p=L->next;
	while(n!=1)
	{
	  j=1;
	  while(j<m)
	    {
	      q=p;
	      p=p->next;
	      j++;
	    }
	 printf("%d->",p->num);
	 m=p->password;
	 n--;
	 q->next=p->next;
	 r=p;p=p->next;
	 free(r);
	}
	printf("%d\n",p->num);
	}

二叉树
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

layla:)
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】队列（链队列、循环队列）的存储结构及基本运算（C语言）
weixin_51450101的博客
01-22 9496
目录1. 队列基本概念2. 链队列代码+注释运行结果3. 循环队列代码+注释运行结果 1. 队列基本概念 队列（Queue）是一种限定性线性表，它只允许在表的一端插入元素，而在另一端删除元素，具有先进先出的特点。在队列中，允许插入的一端称为队尾（Rear），允许删除的一端称为队头（Front）。 队列有顺序和链式两种存储表示。 2. 链队列 链队列采用带头结点的链表结构，并设置一个队头指针 front 和一个队尾指针 rear ，队头指针始终指向头结点，队尾指针指向最后一个元素。空的链队列的队头指针和队尾指
数据结构基础知识
qq_43467548的博客
08-07 1071
一．第一章 什么是数据结构： 常用到以下几个名词： 1.数据： 数据就是计算机加工处理的“原料”，是信息的载体。 数据分为两类：一类是数值数据，另一类是非数值数据。 2.数据元素： 数据元素是能够独立，完整地描述问题世界中的实体最小数据单位，它是数据这个集合中的一个一个的元素。数据元素又称为数据节点，或简称节点。数据项是数据元素不可分割的最小单位。 3.数据对象 一个数据对象被定义为具有相同性质的...
数据结构之单链表（一）
u013071074的专栏
05-28 844
一、存储结构 二、基本操作 三、单链表相关的算法
数据结构（用java描述）之单链表
weixin_43587550的博客
09-15 486
单链表的存储示意图 对于结点类的描述 package LinkList; //对于结点的描述 public class Node { public Object data; //存放结点值 public Node next; //后继结点的引用 //无参数时的构造函数 public Node(){ this(null,null); } //带一个参数的构造函数 pu...
C语言数据结构初级c-language-master (1).zip
最新发布
03-17
《C语言数据结构初级》是针对初学者设计的一份学习资料，主要涵盖了C语言基础知识以及数据结构的基本概念和实现。C语言是一种强大的编程语言，它以其简洁、高效和灵活的特点被广泛应用于系统开发、嵌入式系统以及...
数据结构初级入门教程
09-24
本教程"数据结构初级入门教程"是为初学者设计的，旨在帮助理解基本的数据结构类型及其应用，为后续的编程学习打下坚实的基础。 首先，我们从`chap001.ppt`开始，这通常会介绍数据结构的基本概念和重要性。数据结构...
数据结构初级演示系统
10-11
这是很好的数据结构演示系统，很适合初学者使用！
数据结构课件 初级教程
10-31
数据结构入门级教程！非常全面的数据结构课件
《数据结构》-循环单链表的表示及实现(尾指针)
tyustli
02-12 1455
#include <string.h> #include <malloc.h> #include <stdio.h> #include <stdlib.h> // 函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 ...
数据结构（03）——单链表
08-20 514
单链表概念 链表的节点均单向指向下一个节点，形成一条单向访问的数据链。 单链表的初始化 typedef struct _LinkNode { int data; //结点的数据域 struct _LinkNode *next; //结点的指针域 }LinkNode, LinkList; //链表节点、链表 bool InitList(LinkList* &L)//...
Java单链表查找值的位置_JAVA数据结构问题:在带头结点的单链表中，查找值为X的结点若找到则删除否则输出NO...
weixin_33506815的博客
03-08 1313
单独函数实现的话，如下：//链表按值查找int research_Date(Node *head, int date){ Node *p; int n=1; p = head->pstnext; while(NULL != p && date != p->nDate) { p = p->pstnext; ++n; } if(NULL == p) { retu...
带头结点的单链表java语言_在带头结点的单链表中查找
weixin_42388631的博客
02-27 471
【简答题】试述点法的分类和动作要领【其它】请各小组按照节, 提交 第四节背腰骶臀部的授课PPT和手法视频 12月14日下午的课上将采用翻转课堂的方式,随机抽取一组同学进行讲授和视频演示,最好教师点评,根据各组的课件和视频质量给各小组打分,纳入平时成绩。请各组成员务必高度重视,认真研究讨论并制作课件和视频。【单选题】【单选题】给出的四个判断(1) ={0},(2)空集没有子集,(3)任何一个集合必有...
数据结构入门学习（非常详细）从零基础入门到精通，看完这一篇就够了。
Javachichi的博客
07-10 6916
数据结构(data structure)是带有结构特性的数据元素的集合，它研究的是数据的[逻辑结构](https://baike.baidu.com/item/%E9%80%BB%E8%BE%91%E7%BB%93%E6%9E%84/9663235?fromModule=lemma_inlink "逻辑结构")和数据的物理结构以及它们之间的相互关系，并对这种结构定义相适应的运算，设计出相应的算法，并确保经过这些运算以后所得到的新结构仍保持原来的结构类型。
顺序表的基本操作 详细教学
xiaohe857的博客
10-19 464
题目： 1、编写函数，创建一个顺序表（数据自拟）； 2、编写函数，在顺序表的指定位置插入一个元素； 3、编写函数，在顺序表的指定位置删除一个元素； 4、编写函数，将两个有序顺序表合并成一个新的有序顺序表； 解答： #include<stdio.h> #define MAXSIZE 100 //顺序表的最大空间 #define OK 1 #define ERROR 0 //定义返回量 typedef int Status; typedef int ElemType; typedef s
数据结构（栈与队列）——栈的顺序表示和实现、队列的链式表示和实现
haha_7的博客
11-27 2435
实验内容： 编写一个程序实现顺序栈的各种基本运算。 实现队列的链式表示和实现。 实验步骤： 1．初始化顺序栈 插入元素 删除栈顶元素 取栈顶元素 遍历顺序栈 置空顺序栈 初始化并建立链队列 入链队列 出链队列 遍历链队列 1、栈的顺序表示和实现 #include <stdio.h> #include <stdlib.h> #include <conio.h> #define TRUE 1 #define FALSE 0 #define OK
稀疏数组实现记录棋盘棋子位置和恢复棋盘
qq_37177957的博客
04-21 222
package com.chanyarn.Algorithms; import sun.awt.image.SurfaceManager; /** * @author chanyarn * @create 2020-04-21 22:43 * 编写的五子棋程序中，有存盘退出和续上盘的功能。稀疏数组 * 因为该二维数组的很多值是默认值 0, 因此记录了很多没有意义的数据.->稀疏数...
C语言创建MaxSize头文件,我不知道怎样定义头文件#include<seqlist.h>
weixin_39637151的博客
05-24 1957
满意答案sgkkz3592017.10.26采纳率：50%等级：10已帮助：671人C语言的库文件中，并没有SeqList.h这个标准头文件。这个是一个自定义头文件。在数据结构教材中，使用了该名字。其中存储了顺序表的实现。该头文件内容如下：1234567891011121314151617181920212223242526272829303132333435363738394041424...
单链表的基础操作
Twenty-Seven的博客
06-26 535
1.定义单链表的数据类型和变量typedef char ElemType; typedef struct LNode{ //链表结点 ElemType data;     //数据域 struct LNode *next; //指针域(指向自身的指针) } LinkList; 2.初始化链表void InitList(LinkList *&amp;L){//初始化链表 ...
C语言版数据结构教程：大学初级算法入门
"数据结构_c语言版本 - 大学教材，基础教程，适合初级算法接触人员" 这篇摘要提及的资源是一本以C语言描述的数据结构教材，适用于初次接触算法的大学学习者。数据结构是计算机科学中的核心课程，它研究如何在计算机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值