数据结构期末总复习（一）绪论和线性结构

最新推荐文章于 2024-08-22 20:55:15 发布
最新推荐文章于 2024-08-22 20:55:15 发布
阅读量138 收藏
点赞数 1
分类专栏： 数据结构学习笔记 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62012485/article/details/125413548
版权

一、绪论

程序=数据结构+算法
在这里插入图片描述

在这里插入图片描述
注意O和Ω两者的区分，最后归一为θ

化简方法

在这里插入图片描述
核心在于max或者相乘

二、线性表

顺序表理解成数组
可用指针来做，难点在于开空间

 List L；
 L=（List）malloc（sizeof（List）8*maxsize）;
顺序表学习代码主要功能实现
#include<stdio.h>
#include<stdlib.h>//malloc、free函数的头文件 
#define Initsize 10 //默认的最大长度
#include<iostream>
using namespace std;
//顺序表的创建
//固定空间
/*typedef struct list
{
	int data[Initsize];
	int length;
 }list;
 
 void initlist(list &L)//这里传进来的一定得是地址 
 {
 	L.length=0;
 	for(int i=0;i<Initsize;i++)
 	 L.data[i]=0;
 }
 int main()
{
 	list L;
 	initlist(L);
 	for(int i=0;i<Initsize;i++)
 	 cout<<L.data[i]<<endl;
 	
 }*/
 
 //动态空间(好处在于后期可进行更改） 
 /*
 typedef struct
 {
 	int *elem;
 	int length;
 	int maxsize;//为了更改需要随时记录 
  } list;
   
void initlist(list &L)//&为引用 ，与指针效果相当，对实参本身进行操作 
{
	L.elem=(int *)malloc(sizeof(int)*Initsize);
 	for(int i=0;i<Initsize;i++)
    L.elem[i]=0;
 	L.length=0;
 	L.maxsize=Initsize;
}
void increaselist(list &L) 
{
	int *p=L.elem;//先把原来的元素保留起来
	L.elem=(int *) malloc(sizeof(int)*(Initsize+10));
	for(int i=0;i<Initsize;i++)
	    L.elem[i]=p[i];
	L.length=Initsize;
	L.maxsize=Initsize+10;	
	free(p); 
}
  int main()
  {
  	list L;
  	initlist(L);
    increaselist(L);
  	cout<<L.maxsize;
   }*/
   
   //初始化要点：开空间，赋值，把list里的每个元素对应更新
   
typedef struct
 {
 	int *data;
 	int length;
 } list;
  void initlist(list &L)//&为引用 ，与指针效果相当，对实参本身进行操作 
{
	L.data=(int *)malloc(sizeof(int)*Initsize);
 	for(int i=0;i<Initsize;i++)
    L.data[i]=0;
 	L.length=0;
}
//插入操作关键点是两个特判和位置后移 
void insertlist(list &L,int i,int elem)
{
	if(L.length>Initsize)//表满 
	  return ;
	if(i<1||i>Initsize)//非位 
	  return ;
	for(int j=L.length;j>=i;j--)
	  L.data[j]=L.data[j-1]; //若是数组越界直接跳过这一步 
	  L.data[i-1]=elem;
	  L.length++;
}
//删除关键点也是特判和位置前移 
void deletelist(list &L,int i,int &e)//加个引用便于把函数返回 
{
	if(i>Initsize||i<1)
	return ;
	e=L.data[i-1] ;
	for(int j=i-1;j<Initsize-1;j++)
	  L.data[j]=L.data[j+1];//最后一位其实并没删掉，只是读取的时候length读不到那里 
	L.length--;
 } 
int main() 
{
	list L;
	initlist(L);
	/*insertlist(L,10,10);*/
    //插入测试	

	/*int e;//存储返回值 
	for(int i=0;i<Initsize;i++)
	insertlist(L,i+1,i+1);
	deletelist(L,10,e); 
	for(int i=0;i<L.length;i++)
 	 cout<<L.data[i]<<endl;	
 	 cout<<e<<endl;*/
 	//删除测试 
 	
	//线性表共性，先特判再办事 
	  
  }

插入的平均移动元素次数为n/2；删除为(n-1)/2

链表学习代码主要功能实现

链表中第一个结点的存储位置叫做头指针，头指针和头结点不同，头结点即第一个结点，头指针是指向第一个结点的指针。链表中可以没有头结点，但不能没有头指针，如果链表有头结点，那么头指针就是指向头结点数据域的指针（头结点数据域为空也可以放个长度啥的只不过初始化的时候要搞一下）。

#include <iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
 
 typedef struct node
 {
 	int data;
 	struct node *next;
 }list, * linklist;
 //这里使用带头结点的吧 

void initlist(linklist &L)
{
	L=(list *)malloc(sizeof(linklist));
	L->next=NULL;
}
//其他多余操作不需要加；

bool isempty(linklist &L) 
{
	if(L->next==NULL)
	 return true;
	 else 
	 return false;
}

//对于位序插入，要先找到节点的位置 
void insertlist(linklist &L,int i,int e)
{
	linklist p,q;
	int j=0;
	p=L;//L存的是头结点的指针，不能拿来直接循环 
	while(p!=NULL&&j<i-1)
	{
		p=p->next;
		j++; 
	}
	if(p==NULL)
	 return ;
	 //p指向的是要插入的前一个 
	q=(list *)malloc(sizeof(linklist));
	q->data=e;
	q->next=p->next;
	p->next=q;	
}
//注意细节的处理 
//若是不带头结点在i==1时单独说明

void deletelist(linklist& L,int i,int &e)
{
	linklist p,q;
	int j=0;
	p=L;
	while(p!=NULL&&j<i-1)
	{
		p=p->next;
		j++;
	}
	if(p==NULL||p->next==NULL)
	    return;
	    
	 e=p->next->data;
	 q=p->next;
	 p->next=q->next;
	 free(q) ;
}
//插入删除时间复杂度均为O（1）

void output(linklist& L)
{
	linklist p=L->next;
	while(p!=NULL)
	{
		cout<<p->data;
		p=p->next;
	}
}
  

  int main()
 {
     linklist L;
	 initlist(L);
	 for(int i=1;i<10;i++)
	 insertlist(L,i,i);
	 int e;
	 deletelist(L,5,e);
	 output(L);
	 cout<<endl<<e;
 }

本文使用的为有头结点，其他完整版可参考数据结构总复习

其他思想：

  • 逆置

在这里插入图片描述
头插到原来的头结点之下实现倒置

  • 双链表：使用前后指针
    在这里插入图片描述
    重点在插入，先接后一个再接前一个
    删除时只需要接住一个前一个后

  • 循环链表
    判空条件：L->next=L;

三、堆栈

主要在于栈顶的标定，有一些令top=-1，有一些令top=base

顺序存储
#include <iostream>
#include<stdio.h>
#include<string.h>
#define maxsize 10
#include<stdlib.h>
using namespace std;
  
typedef struct 
{
	int data[maxsize];
	int top;
}stack;

void initstack(stack &s)
{
	s.top=-1;
}

void push(stack &s,int e)
{
	if(s.top==maxsize-1)
	return;
	s.data[s.top+1]=e;
	s.top++;
}
void pop(stack &s,int &e)//不要忘了往里传地址 
 {
   if(s.top==-1)
      return;
    e=s.data[s.top];
    s.top--;
}
//比较简单，先判空，再处理一下数组尾部 
int main()
{
	stack s;
	initstack(s);
	for(int i=0;i<maxsize;i++)
    push(s,i);
	int e;
	pop(s,e);
	pop(s,e); 
	cout<<e;
}
链式存储

在这里插入图片描述
若尾部作为栈顶，找不到前继位，无法pop

代码
#include <iostream>
#include<stdlib.h>
#include<stdio.h> 
using namespace std;
typedef struct stac
{
	int data;
	struct stac *next;
}node,*stack;
//无头结点 
void initstack(stack &s)
{
	s=NULL;//	
}

void push(stack& s,int e)
{
	stack q;
	q=(stack) malloc(sizeof(stack));
	q->data=e;
	q->next=s;
	s=q;
}
//开空间，赋值，换头
 
void pop(stack& s,int &e)
{
	if(s==NULL)
	return;
	else
	{
		stack p;
		p=s;
		e=p->data;
		s=s->next;
		free(p); 
	}
}
//判空，开替代，删除 


int main ()
{
	stack s;
	initstack(s);
	for(int i=0;i<5;i++)
	push(s,i);
	int e;
	for(int i=0;i<5;i++)
	{
		pop(s,e);
		cout<<e;
	}
 }

四、队列
顺序存储结构时可以让front 和 rear同为-1，之后front在实际位置的前一个，也可以同为0，然后rear在实际位置后

#include<stdio.h>
#include<malloc.h>
#include<iostream>
#define maxsize 100
using namespace std;
//顺序存储结构时可以让front 和 rear同为-1，之后front在实际位置的前一个
//也可以同为0，然后rear在实际位置后
typedef struct quene
{
	int data[maxsize];
	int front,rear;
}quene;
void initquene(quene &q)
{
	q.rear=q.front=0;
 } 
 
 void inquene(quene &q,int e)
 {
 	if((q.rear+1)%maxsize==q.front)
 	//如果放满的话，rear==front，而队列为空时也存在这个关系，因此只放n-1个
 	  return ;
 	q.data[q.rear]=e;
 	q.rear=(q.rear+1)%maxsize;
 }
 
 void outquene(quene &q,int &e) 
 {
 	if(q.front==q.rear)
 	return ;
 	e=q.data[q.front];
 	q.front =(q.front+1)%maxsize;
 }
  // 关键点：判断加更新
  
 int main()
 {
 	quene q;
 	initquene(q);
 	for(int i=0;i<5;i++)
	 inquene(q,i);
	 int e;
	for(int i=0;i<5;i++)
	{
	   outquene(q,e);
	   cout<<e;
    }
 }

链式存储
不加头结点的时候，rear和front指向最后一个和第一个元素实际位置，不存在前置后置

#include<stdio.h>
#include<malloc.h>
#include<iostream>
#include<bits/stdc++.h>
#define maxsize 100
using namespace std;
typedef struct node
{
	int data;
	struct node *next;
 } *qnode;
 typedef struct quenee
 {
 	qnode front,rear;
 }* quene;
 //创建的时候注意，rear和front都是节点
 void initquene(quene &q)
 {
 	q=(quene)malloc(sizeof(quene));
 	q->front=NULL;
 	q->rear=NULL;
 }
 void inquene(quene &q,int e)
 {
 	qnode p;
 	p=(qnode)malloc(sizeof(qnode));
 	p->data=e;
	p->next = NULL;//不要忘了这一步
	//之后吧这一节点放到链表里面
	if(q->rear==NULL)
	  q->rear=q->front=p;
	 else
	 {
	    q->rear->next=p;
	 	q->rear=p;
	 }  	
 }
 //建结点，分情况赋值
 void outquene(quene &q,int &e) 
 {
 	if(q->front==NULL)
 	return;
 	qnode p;
 	p=q->front;
 	e=p->data;
 	q->front=q->front->next;
 	free(p);
 }
 //找替身，操作，删除 
 
 int main()
 {
 	quene q;
 	initquene(q);
 	for(int i=0;i<5;i++)
	 inquene(q,i);
	 int e;
	for(int i=0;i<5;i++)
	{
	   outquene(q,e);
	   cout<<e;
    }
 }
小白有颗大白梦
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】栈
Obliviate的博客
01-27 1195
顺序栈 定义 #define MaxSize 50 //栈中元素最大个数 typedef struct{ ElemType data[MaxSize]; //存放栈中元素 int top; //栈顶指针 }SqStack; 操作集 void InitStack(SqStack &S); //初始化 bool StackEmpty(SqStack S); //判空 bool Push(SqStack &S,ElemType x); //进栈 bool
* & 的问题 （待整理）
weixin_30545285的博客
04-22 651
资料：http://tieba.baidu.com/f?kz=1053435983 void InitStack( SqStack *&S) 浏览次数：3426次悬赏分：5|解决时间：2006-8-12 00:19|提问者：dangdangxww 为什么这个S形参前面用了* 和&呢？是怎么个用法，含义如何呀？ 小弟在这先谢了，那位高手...
数据结构---链栈
l1051663145的博客
10-08 242
数据结构–链栈 根据栈的定义，和链表结合 利用链表的头插法实现入栈，利用链表删除头元素的方法实现出栈 定义结构体 //定义链栈 typedef struct Linknode{ elemtype data; Linknode *next; }*ListStack; 对栈进行初始化 //初始化 void initStack(ListStack &S){ S=(ListStack)malloc(sizeof(Linknode));//创建头节点 S->next=NULL;//指向空
数据结构基础——栈
XXXTENTAC1ON的博客
04-13 459
栈什么是栈栈的代码实现顺序栈的结构顺序栈的操作方法方法的实现InitStack__栈的初始化Push__入栈Top__获取栈顶数据Pop__弹出栈顶数据Empty__判空DestryStack__销毁栈链式栈的实现栈的应用中缀转后缀两个栈实现一个队列 什么是栈 关于栈，在 如何使用两个栈实现一个队列 中粗略介绍过，下面将详细接受栈以及栈代码的实现。 栈 符合 先进后出，后进先出！——函数调用堆栈，类似于弹匣的结构。 栈底： 栈的存储空间的最底下的位置。一般是一块空间的首地址。 栈顶： 动态变化的位置
C++栈和递归实验
康小庄的博客
11-20 835
【代码】C++栈和递归实验。
大一下数据结构期末复习题综合题库
07-03
数据结构从逻辑上可以分为线性结构和非线性结构。 - **问题9**: 选项C正确。逻辑结构是数据元素之间关系的抽象表示，与物理存储无关。 - **问题10**: 选项C正确。数据的基本单位是数据元素。 - **问题11**: 选项B...
数据结构期末复习大纲
02-08
1.1 数据结构的定义与类型：理解数据结构的基本概念，包括逻辑结构（如线性结构、树形结构、图结构和集合）和物理结构（如顺序存储和链式存储）。 1.2 算法与数据结构的关系：阐述算法的重要性，以及数据结构如何...
《数据结构》期末考试复习题 第1章 绪论.pdf
07-08
在《数据结构》的第一章“绪论”中，我们主要学习了以下几个关键知识点： 1. **算法的复杂性**：算法的计算量大小称为计算的复杂性，通常用时间复杂度和空间复杂度来衡量。时间复杂度描述了算法运行所需的时间与...
四川大学数据结构期末复习题
05-21
### 四川大学数据结构期末复习题知识点梳理 #### 第一部分：考试说明概览 - **课程定位**：《数据结构与算法分析》是计算机科学与技术专业本科生的基础核心课程，涉及数据组织形式及其基本操作。 - **主要内容**：...
杭电-[数据结构(c语言版)]复习题纲杭州电子科技大学.pdf
04-26
根据给定的文件信息，我们可以总结出以下关于“数据结构（C语言版）”的关键知识点，这些知识点主要涉及数据结构的基础理论以及几种重要的数据结构，包括线性表、栈、队列、串、数组和广义表、树和二叉树等内容。...
栈的顺序实现
人生如梦，一樽还酹江月
03-27 1301
<!--CTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dt--><!--CTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose
栈的应用
GSON的博客
01-20 162
1、算术表达式求值 #include<stdio.h> #include<stdlib.h> #include<ctype.h> typedef struct Node { int data; struct Node * pNext; }NODE,* PNODE; typedef struct Stack { PNODE pTo...
栈结构之顺序栈详解（C语言版）
热门推荐
qq_44075108的博客
10-24 1万+
本文对栈结构的顺序栈进行详解并使用C语言对顺序栈进行实现，文章的主要内容包括顺序栈的定义、顺序栈的结构以及顺序栈的常用操作
笔记分享: 香港中文大学CSCI5610高级数据结构——最邻近查询
qq_64091900的博客
08-18 719
香港中文大学CSCI5610高级数据结构
【Redis】Redis 底层的数据结构（结合源码）
秋玄的博客
08-22 639
Redis 底层数据结构详解
算法的学习笔记—二叉搜索树的后序遍历序列(牛客JZ33)
最新发布
业精于勤，荒于嬉
08-22 678
通过递归地判断数组的子序列是否满足二叉搜索树的性质，我们可以有效地判断一个数组是否是某二叉搜索树的后序遍历序列。这个方法在逻辑上比较直观，并且能够处理复杂的情况，尽管其时间复杂度为O(n^2)，但在实际应用中仍然是一个实用的算法。希望通过这篇文章，大家能够更加深入地理解二叉搜索树及其后序遍历的相关概念，并掌握如何通过编程来解决这类问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVC。
东华大学数据结构期末复习：关键概念与选择题详解
在《数据结构期末复习题》中，主要涉及了数据结构和算法的基本概念，以及线性表的相关知识点。以下是对章节内容的详细解读： 第1章绪论： 1. **算法复杂性**：算法的计算量大小通常用其**时间复杂度**来衡量，即...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值