学习笔记-数据结构与算法之线性表

最新推荐文章于 2024-06-09 23:18:21 发布
最新推荐文章于 2024-06-09 23:18:21 发布
阅读量198 收藏
点赞数
分类专栏： 数据结构与算法 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ti__boyue/article/details/116261002
版权

目录

框架图

在这里插入图片描述

线性表

顺序结构

#include<iostream>
using namespace std;

#define maxsize 100
typedef int elemtype;

#define ok 1
#define error 0
typedef int status;

typedef struct List{
	elemtype data[maxsize];
	int length;
}list;

void create_list(list* sqlist);
void out_elem(list sqlist);
status get_elem(list sqlist,int i,elemtype *e);
status insert(list& sqlist,int i,elemtype e);
status delete1(list& sqlist,int i,elemtype *e);

int main(){
	
	list sqlist;
	// 创建
	create_list(&sqlist);
	// 输出验证
	out_elem(sqlist);
	cout<<endl;
	
	cout<<"获取第i个元素"<<endl;
	elemtype e;
	cout<<get_elem(sqlist,2,&e)<<endl;
	cout<<e<<endl;
	
	cout<<"插入元素"<<endl;
	cout<<insert(sqlist,3,9)<<endl;
	// 输出验证
	out_elem(sqlist);
	cout<<endl;
	cout<<"删除元素"<<endl;
	cout<<delete1(sqlist,4,&e)<<endl;
	// 输出验证
	out_elem(sqlist);
	cout<<endl;
	
	return 0;
}

创建线性表

void create_list(list* sqlist){
	elemtype temp[] = {1,2,3,4,5};
	int length = sizeof(temp)/sizeof(temp[0]);
	for(int i=0;i<length;i++){
		sqlist->data[i] = temp[i];
	}
	sqlist->length = length;
}

输出验证

void out_elem(list sqlist){
	for(int i=0;i<sqlist.length;i++){
		cout<<sqlist.data[i]<<' ';
	}
}

获取第i个元素

status get_elem(list sqlist,int i,elemtype *e){
	if(sqlist.length == 0 || i<1 || i>sqlist.length)
		return error;
	*e = sqlist.data[i-1];
	return ok;
}

插入元素到特定位置

status insert(list& sqlist,int i,elemtype e){
	
	if(sqlist.length == maxsize){
		cout<<"空间已满"<<endl;
		return error;
	}
	if(i<1 ||i>sqlist.length+1){
		cout<<"i不在范围"<<endl;
		return error;
	}
	
	int k = sqlist.length;
	if(i!=k+1){ //不在表尾
		while(i<=k){
			sqlist.data[k]=sqlist.data[k-1];
			k--;
		}
	}
	sqlist.data[k] = e;
	sqlist.length++;
	return ok;
}

删除特定位置元素

status delete1(list& sqlist,int i,elemtype *e){
	
	if(sqlist.length == 0 || i<1 || i>sqlist.length)
		return error;
	*e = sqlist.data[i-1];
	
	if(i!=sqlist.length){
		while(sqlist.length > i){
			sqlist.data[i-1] = sqlist.data[i];
			i++;
		}
	}
	sqlist.length --;
	return ok;
}

整体代码

#include<iostream>
using namespace std;

#define maxsize 100
typedef int elemtype;

#define ok 1
#define error 0
typedef int status;

typedef struct List{
	elemtype data[maxsize];
	int length;
}list;

void create_list(list* sqlist);
void out_elem(list sqlist);
status get_elem(list sqlist,int i,elemtype *e);
status insert(list& sqlist,int i,elemtype e);
status delete1(list& sqlist,int i,elemtype *e);// delete 是一个c++的函数 定义时需作出改变

int main(){
	
	list sqlist;
	// 创建
	create_list(&sqlist);
	// 输出验证
	out_elem(sqlist);
	cout<<endl;
	
	cout<<"获取第i个元素"<<endl;
	elemtype e;
	cout<<get_elem(sqlist,2,&e)<<endl;
	cout<<e<<endl;
	
	cout<<"插入元素"<<endl;
	cout<<insert(sqlist,3,9)<<endl;
	// 输出验证
	out_elem(sqlist);
	cout<<endl;
	cout<<"删除元素"<<endl;
	cout<<delete1(sqlist,4,&e)<<endl;
	// 输出验证
	out_elem(sqlist);
	cout<<endl;
	
	return 0;
}
/* 创建线性表*/
void create_list(list* sqlist){
	elemtype temp[] = {1,2,3,4,5};
	int length = sizeof(temp)/sizeof(temp[0]);
	for(int i=0;i<length;i++){
		sqlist->data[i] = temp[i];
	}
	sqlist->length = length;
}
// 输出验证
void out_elem(list sqlist){
	for(int i=0;i<sqlist.length;i++){
		cout<<sqlist.data[i]<<' ';
	}
}
/* 获取第i个元素 */
status get_elem(list sqlist,int i,elemtype *e){
	if(sqlist.length == 0 || i<1 || i>sqlist.length)
		return error;
	*e = sqlist.data[i-1];
	return ok;
}
/*插入元素到特定位置*/
status insert(list& sqlist,int i,elemtype e){
	
	if(sqlist.length == maxsize){
		cout<<"空间已满"<<endl;
		return error;
	}
	if(i<1 ||i>sqlist.length+1){
		cout<<"i不在范围"<<endl;
		return error;
	}
	
	int k = sqlist.length;
	if(i!=k+1){ //不在表尾
		while(i<=k){
			sqlist.data[k]=sqlist.data[k-1];
			k--;
		}
	}
	sqlist.data[k] = e;
	sqlist.length++;
	return ok;
}

/*删除特定位置元素*/
// delete 是一个c++的函数 定义时需作出改变
status delete1(list& sqlist,int i,elemtype *e){
	
	if(sqlist.length == 0 || i<1 || i>sqlist.length)
		return error;
	*e = sqlist.data[i-1];
	
	if(i!=sqlist.length){
		while(sqlist.length > i){
			sqlist.data[i-1] = sqlist.data[i];
			i++;
		}
	}
	sqlist.length --;
	return ok;
}

链式结构

#include<iostream>
using namespace std;

typedef int elemtype;

typedef struct node {
	elemtype data;
	struct node *next;
} node, *link_node;

typedef int status;
#define ok 1
#define error 0

void create_node_list(link_node head);
void out_elem(node head_node);
status get_elem(link_node head, int i, elemtype *e);
status insert_node(link_node head, int i, elemtype e);
status delete_node(link_node head, int i, elemtype *e);
status delete_list(link_node head);

int main() {

	node head_node;
	cout << "创建链表" << endl;
	create_node_list(&head_node);
	out_elem(head_node);
	cout << "获取第i个元素" << endl;
	elemtype e;
	cout << get_elem(&head_node, 10, &e) << endl;
	cout << e << endl;
	cout << "插入元素" << endl;
	cout << insert_node(&head_node, 5, 12) << endl;
	out_elem(head_node);
	cout << "删除元素" << endl;
	cout << delete_node(&head_node, 5, &e) << endl;
	cout << e << endl;
	out_elem(head_node);
	cout<<"删除整表"<<endl;
	delete_list(&head_node);
	out_elem(head_node);
	return 0;
}

创建链表

void create_node_list(link_node head) {
	link_node p, q;

	elemtype array[] = { 1,2,3,4,5,6,7,8,9,10 };
	int length = sizeof(array) / sizeof(array[0]);
	q = head;
	head->data = length;
	head->next = NULL;

	for (int i = 0; i < length; i++) {
		p = new node;
		p->data = array[i];
		p->next = NULL; // 尾插法
		q->next = p;
		q = p;
	}
}

输出验证

void out_elem(node head_node) {
	link_node p = head_node.next;
	while (p) {
		cout << p->data << ' ';
		p = p->next;
	}
	cout << endl;
}

获取第i个元素

status get_elem(link_node head, int i, elemtype *e) {
	if (head->data == 0 || i<1 || i>head->data)
		return error;
	int count = 1;
	link_node p = head->next;
	while (p && count < i) {
		p = p->next;
		count++;
	}
	*e = p->data;
	return ok;
}

插入元素

status insert_node(link_node head, int i, elemtype e) {
	if (i<1 || i>head->data + 1) return error;

	link_node q, p = head;
	int count = 1;
	while (p && count < i) {
		p = p->next;
		count++;
	}

	q = new node;
	q->data = e;
	q->next = p->next;
	p->next = q;

	head->data++;
	return ok;
}

删除元素

status delete_node(link_node head, int i, elemtype *e) {
	if (head->data ==0 || i<1 || i>head->data)
		return error;

	int count = 1;
	link_node q, p = head;
	while (p && count < i) {
		p = p->next;
		count++;
	}

	q = p->next;
	*e = q->data;
	p->next = q->next;
	delete q;

	head->data--;
	return ok;
}

删除整表

status delete_list(link_node head){
	link_node q,p=head->next;
	while(p){
		q=p;
		p=q->next;
		delete q;
		head->data--;
	}
	head->next=NULL;
	return ok;
}

完整代码

#include<iostream>
using namespace std;

typedef int elemtype;
typedef struct node {
	elemtype data;
	struct node *next;
} node, *link_node;

typedef int status;
#define ok 1
#define error 0

void create_node_list(link_node head);
void out_elem(node head_node);
status get_elem(link_node head, int i, elemtype *e);
status insert_node(link_node head, int i, elemtype e);
status delete_node(link_node head, int i, elemtype *e);
status delete_list(link_node head);

int main() {

	node head_node;
	cout << "创建链表" << endl;
	create_node_list(&head_node);
	out_elem(head_node);
	cout << "获取第i个元素" << endl;
	elemtype e;
	cout << get_elem(&head_node, 10, &e) << endl;
	cout << e << endl;
	cout << "插入元素" << endl;
	cout << insert_node(&head_node, 5, 12) << endl;
	out_elem(head_node);
	cout << "删除元素" << endl;
	cout << delete_node(&head_node, 5, &e) << endl;
	cout << e << endl;
	out_elem(head_node);
	cout<<"删除整表"<<endl;
	delete_list(&head_node);
	out_elem(head_node);
	return 0;

}
// 创建链表
void create_node_list(link_node head) {
	link_node p, q;

	elemtype array[] = { 1,2,3,4,5,6,7,8,9,10 };
	int length = sizeof(array) / sizeof(array[0]);
	q = head;
	head->data = length;
	head->next = NULL;

	for (int i = 0; i < length; i++) {
		p = new node;
		p->data = array[i];
		p->next = NULL; // 尾插法
		q->next = p;
		q = p;
	}
}
// 输出验证
void out_elem(node head_node) {
	link_node p = head_node.next;
	while (p) {
		cout << p->data << ' ';
		p = p->next;
	}
	cout << endl;
}
// 获取第i个元素
status get_elem(link_node head, int i, elemtype *e) {
	if (head->data == 0 || i<1 || i>head->data)
		return error;
	int count = 1;
	link_node p = head->next;
	while (p && count < i) {
		p = p->next;
		count++;
	}
	*e = p->data;
	return ok;
}
// 插入元素
status insert_node(link_node head, int i, elemtype e) {
	if (i<1 || i>head->data + 1) return error;

	link_node q, p = head;
	int count = 1;
	while (p && count < i) {
		p = p->next;
		count++;
	}

	q = new node;
	q->data = e;
	q->next = p->next;
	p->next = q;

	head->data++;
	return ok;
}
// 删除元素
status delete_node(link_node head, int i, elemtype *e) {
	if (head->data ==0 || i<1 || i>head->data)
		return error;

	int count = 1;
	link_node q, p = head;
	while (p && count < i) {
		p = p->next;
		count++;
	}

	q = p->next;
	*e = q->data;
	p->next = q->next;
	delete q;

	head->data--;
	return ok;
}
// 删除整表
status delete_list(link_node head){
	link_node q,p=head->next;
	while(p){
		q=p;
		p=q->next;
		delete q;
		head->data--;
	}
	head->next=NULL;
	return ok;
}

链表翻转

迭代反转法

// 翻转 -- 迭代反转法 -- 从首部开始
void turn_iteration_list(link_node head){
	//是否最多只有一个元素
	if(head->next == NULL || head->next->next == NULL) return;
	
	link_node p,q,s;
	q=NULL;
	p=head->next;
	s=p->next;
	while(1){
		p->next =q;
		if(s == NULL) break;
		q=p;
		p=s;s=p->next;
	}
	head->next = p;
}

递归翻转法

link_node turn_recursive_list(link_node first){
	// 递归出口
	if(first == NULL || first->next == NULL) return first;
	
	link_node new_head =  turn_recursive_list(first->next); 
	
	first->next->next = first;
	first->next = NULL;
	
	return new_head; // 持续返回新头部指针，恒定
}

头插法翻转

void turn_insert_head_list(link_node head){
	if(head->next == NULL || head->next->next == NULL) return;
	
	link_node end = head;
	while(end->next){
		end = end->next;
	}
	link_node p,q;
	p=head->next;
	while(p!=end){
		q=p->next;
		p->next = end->next;
		end->next = p;
		p = q;
	}
	head->next = end;
}

就地逆置法翻转

void turn_local_list(link_node head){
	if(head->next == NULL || head->next->next == NULL) return;
	
	link_node p,q;
	q=head->next;
	p=q->next;
	
	while(p){
		q->next = p->next;
		p->next = head->next;
		head->next = p;
		p=q->next;
	}
}

完整代码

#include<iostream>
using namespace std;

typedef int elemtype;
typedef struct node{
	elemtype data;
	struct node *next;
}node,*link_node;

void create_node_list(link_node head) {
	link_node p, q;

	elemtype array[] = {1,2,3,4,5,6,7,8,9,10};
	int length = sizeof(array) / sizeof(array[0]);
	q = head;
	head->data = length;
	head->next = NULL;

	for (int i = 0; i < length; i++) {
		p = new node;
		p->data = array[i];
		p->next = NULL; // 尾插法
		q->next = p;
		q = p;
	}
}
void out_elem(node head_node) {
	link_node p = head_node.next;
	while (p) {
		cout << p->data << ' ';
		p = p->next;
	}
	cout << endl;
}
void turn_iteration_list(link_node head);
link_node turn_recursive_list(link_node first);
void turn_insert_head_list(link_node head);
void turn_local_list(link_node head);
int main(){
	node head_node;
	create_node_list(&head_node);
	out_elem(head_node);
	cout<<"迭代翻转法："<<endl;
	turn_iteration_list(&head_node);
	out_elem(head_node);
	cout<<"迭代翻转法"<<endl;
	head_node.next = turn_recursive_list(head_node.next);
	out_elem(head_node);
	cout<<"头插法翻转"<<endl;
	turn_insert_head_list(&head_node);
	out_elem(head_node);
	cout<<"就地翻转"<<endl;
	turn_local_list(&head_node);
	out_elem(head_node);
	return 0;
}
// 翻转 -- 迭代反转法 -- 从首部开始
void turn_iteration_list(link_node head){
	//是否最多只有一个元素
	if(head->next == NULL || head->next->next == NULL) return;
	
	link_node p,q,s;
	q=NULL;
	p=head->next;
	s=p->next;
	while(1){
		p->next =q;
		if(s == NULL) break;
		q=p;
		p=s;s=p->next;
	}
	head->next = p;
}
// 递归翻转法 -- 从尾部开始
link_node turn_recursive_list(link_node first){
	// 递归出口
	if(first == NULL || first->next == NULL) return first;
	
	link_node new_head =  turn_recursive_list(first->next); 
	
	first->next->next = first;
	first->next = NULL;
	
	return new_head; // 持续返回新头部指针，恒定
}
// 头插法翻转
void turn_insert_head_list(link_node head){
	if(head->next == NULL || head->next->next == NULL) return;
	
	link_node end = head;
	while(end->next){
		end = end->next;
	}
	link_node p,q;
	p=head->next;
	while(p!=end){
		q=p->next;
		p->next = end->next;
		end->next = p;
		p = q;
	}
	head->next = end;
}
// 就地逆置法翻转
void turn_local_list(link_node head){
	if(head->next == NULL || head->next->next == NULL) return;
	
	link_node p,q;
	q=head->next;
	p=q->next;
	
	while(p){
		q->next = p->next;
		p->next = head->next;
		head->next = p;
		p=q->next;
	}
}

合并链表

#include<iostream>
using namespace std;

typedef int elemtype;
typedef struct node{
	elemtype data;
	struct node *next;
}node,*link_node;

void create_node_list(link_node head,elemtype array[],int length);
void out_elem(node head_node);
void combine_node_list(link_node head_combin,node head_node1,node head_node2);
void combin_node_list_no(link_node head1,link_node head2);
int main(){
	
	node head_node1,head_node2,head_node_combine;
	elemtype array1[]={0,1,3,5,7,9};
	elemtype array2[]={1,2,4,6,8,10,11,12};
	cout<<"head_node1"<<endl;
	create_node_list(&head_node1,array1,sizeof(array1)/sizeof(array1[0]));
	out_elem(head_node1);
	cout<<"head_node2"<<endl;
	create_node_list(&head_node2,array2,sizeof(array2)/sizeof(array2[0]));
	out_elem(head_node2);
	cout<<"合并后新建链表"<<' ';
	combine_node_list(&head_node_combine,head_node1,head_node2);
	cout<<"长度:"<<head_node_combine.data<<endl;
	out_elem(head_node_combine);
	cout<<"原空间-以head_node1为主";
	combin_node_list_no(&head_node1,&head_node2);
	cout<<" 长度:"<<head_node1.data<<endl;
	out_elem(head_node1);
	return 0;
}
void create_node_list(link_node head,elemtype array[],int length){
	
	head->data=length;
	head->next=NULL;
	
	link_node q,p;
	p=head;
	
	for(int i=0;i<length;i++){
		q = new node;
		q->data = array[i];
		q->next = NULL;
		p->next = q;
		p=q;
	}
}
void out_elem(node head_node){
	if(head_node.next == NULL) return;
	link_node p=head_node.next;
	while(p){
		cout<<p->data<<" ";
		p=p->next;
	}
	cout<<endl;
}
void combine_node_list(link_node head_combin,node head_node1,node head_node2){
	link_node p,q,s,m;
	elemtype temp;
	head_combin->next=NULL;
	head_combin->data=0;
	
	p=head_combin;
	q=head_node1.next;
	s=head_node2.next;
	
	while(q&&s){
		if(q->data<=s->data){
			temp=q->data;
			q=q->next;
		}else {
			temp = s->data;
			s=s->next;
		}
		m = new node;
		m->data = temp;
		m->next = NULL;
		p->next=m;
		p=m;
	}
	if(q){
		p->next=q;
	}
	if(s){
		p->next=s;
	}
	head_combin->data = head_node1.data+head_node2.data;
}

void combin_node_list_no(link_node head1,link_node head2){
	link_node p,q,s;
	s=head1;
	p=head1->next;q=head2->next;
	while( p && q){
		if(p->data<=q->data){
			s->next = p;
			s=p;
			p=p->next;
		}else {
			s->next = q;
			s=q;
			q=q->next;
		}
	}
	if(p) s->next = p;
	if(q) s->next = q;
	head1->data=head1->data+head2->data;
}

传送门

青岛大学-王卓-数据结构
单链表反转详解（4种算法实现）
合并两个单链表（链表方式）

小韭菜~
关注
专栏目录
数据结构与算法学习笔记
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
C语言学习笔记----数据结构之线性表的顺序存储结构
weixin_51927439的博客
04-08 203
头文件内部有一个用一个结构体来表示顺序表，N为顺序表的长度，宏定义N为128，结构体包括一个数组和长度，线性表的顺序存储结构指的是用一段地址连续的存储单元依次存储线性表的数据单元。数据结构是是相互之间存在一种或者多种特定关系的数据元素的集合。函数接口定义为：sqlink list_create(void)2.1 首先定义一个头文件sqlist.h。1.2 线性表的顺序存储结构。2.2 顺序表的创建。二、顺序表的常用接口。2.3 顺序表的清空。
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 43万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
学习笔记-数据结构-线性表（2024-04-21）
XuJiaKai的博客
04-22 361
假设有两个元素值递增有序的线性表La和Lb，均以带头节点的单链表作为存储结构，编写算法将La表和Lb表合并为一个按元素值递减有序排列的线性表Lc，并要求利用原表（La和Lb表）的节点空间存放表Lc。: 在算法执行过程中，pa是一个遍历指针，用于顺序访问La链表中的节点。: 指向第二个有序单链表的头节点，该链表中的元素同样按递增顺序排列。: 指向第一个有序单链表的头节点，该链表中的元素按递增顺序排列。: 指向结果单链表的头节点，合并后的链表将按元素值递减有序排列。
数据结构与算法学习笔记-线性表
qq_53548177的博客
12-10 634
声明：本博客仅为本人学习途中做的笔记 采自青岛大学王卓老师的视频教学 主要内容为算法思路，具体代码实现还需修改后才能运行，望各位看官多多包涵，您的点赞与评论是对我最大的肯定！ # 1.线性表的定义和特点 线性表是具有相凤特性的数据元素的一个有限序列 (a1,a2,...ai−1,ai,ai+1,...,an) (a_1, a_2, ... a_i-_1, a_i,a_i+_1, ..., a_n) (a1​,a2​,...ai​−1​,ai​,ai​+1​,...,an​)\qquad\qquad\q.
数据结构与算法学习笔记-一般线性表
freak2020的博客
01-27 656
定义 线性表是一个具有相同特性的数据元素的有限序列 相同特性：所有元素属于同一数据类型 序列：数据元素由逻辑序号唯一确定，一个线性表中可以由相同值的元素 顺序存储结构 顺序表和线性表的区别：顺序表是物理结构，线性表是逻辑结构 算法实现 顺序表 类型定义 创建顺序表 void CreateList(SqList *&L,ElemType a[],int n){ int i; L=(SqList *)mall...
学习笔记-数据结构-线性表（2024-04-27）
XuJiaKai的博客
04-28 254
扫描顺序表L的前半部分元素，对于元素L.data[i]（0
学习笔记-数据结构-线性表（2024-04-16）
XuJiaKai的博客
04-17 537
int value;代码思想：双指针操作（快慢指针），利用p、q两个指针实现，p先走k-1步，然后p和q再同时出发，当p指向最后一个节点时，正好q指向了链表中倒数第k个节点。// 声明并初始化两个用于遍历链表的指针p=head;q=head;// 循环，目的是将p移动到正向数第k个节点的位置for(i=1;inext;// 持续遍历直到p指向成最后一个节点// p q 两个指针都向下一个节点移动。
学习笔记-数据结构-线性表（2024-04-17）
XuJiaKai的博客
04-18 279
指针变量，始终指向q节点的前一个节点。在删除q所指向的节点时，s的next将被更新为q->next，从而维持链表的连续性。在内层循环中，q从p所指向节点的下一个节点开始，遍历p之后的所有节点。它用于寻找和删除与p指向节点的data值相同的节点。- 参数变量，代表链表的头节点。在调用DelSameNum函数时，需要传递链表的头节点的地址给这个参数，从而允许函数对链表进行操作。- 指针变量，用于在链表中顺序遍历节点。在外层循环中，p从头节点开始，依次指向链表中的每一个节点，直到最后一个节点。
【学习笔记】数据结构与算法第二章 线性表
Qi_kilig的博客
08-30 1028
第二章 线性表 数据结构与算法Ⅰ
DataStruct:张铭-数据结构与算法习题
04-11
:keycap_2: 习题 1 ：是北大张铭《数据结构与算法》教材习题以及对应的《数据结构与算法-学习指导与习题解析》 :keycap_3: 习题 2 ：来自王道教材习题 第一章 概述 第二章 线性表 第三章 栈和队列 :green_book: 第...
考研系列-数据结构第二章、线性表
最新发布
Nelson_hehe的博客
06-09 2082
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
黑马程序员C++学习笔记（第一阶段：基础）
TI__boyue的博客
09-20 1565
目录起步：hello c++定义常量：# define ,const 起步：hello c++ #include <iostream> using namespace std; int main(){ cout <<"hello c++"<< endl; // system("pause"); return 0; } 定义常量：# define ,const #define 宏变 ...
黑马程序员C++学习笔记（第二阶段核心：面向对象）（一）
TI__boyue的博客
09-29 1148
内存分区：代码区，全局区，栈区，堆区 程序运行前：代码区，全局区 程序运行后：栈区，堆区 数据保留一次 //栈区：局部变量 int a=10; // 堆区:程序员开辟new，释放delete, int *p=new int(10); // 返回的是整型数据10存放的地址编号 int *p = new int(10); //开辟 delete p; //释放 int *arr = new int[10]; //10个元素 返回首地址\ for(int i=0;i<10;i++){ a
黑马程序员C++学习笔记（第二阶段核心：面向对象）（二）
TI__boyue的博客
10-14 672
目录C++对象模型和this指针成员变量和成员函数分开存储this 指针 C++对象模型和this指针 成员变量和成员函数分开存储 在C++中，类内的成员变量和成员函数分开存储 只有非静态成员变量才属于类的对象上面(类对应的对象的内存大小不会发生改变) 空对象占用内存空间为: C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置 每个空对象也应该有一个独一无二的内存地址 this 指针 每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码。那
C++面试高频考点整理--基础
TI__boyue的博客
05-29 603
目录1、const、define的联系与区别2、指针和引用的区别传送门 1、const、define的联系与区别 const ：在堆栈分配了空间，在程序中可以被调用、传递，存在于程序的数据段 define：仅将具体数值传递到目标变量，生命周期止步于编译期，在程序中仅是一个常数，没有实际存在，存在于数据的代码段 2、指针和引用的区别 指针： 是一个变量，指向内存中的一个存储单元，存储的是一个地址 可以有const指针 可以有多级，即指针的指针 可以为空 nullptr 初始化后指针指向可以改变 size
学习笔记-数据结构与算法之栈与队列
TI__boyue的博客
05-01 514
目录栈 栈
学习笔记-数据结构与算法之二叉树
TI__boyue的博客
05-06 411
#include<iostream> using namespace std; #include<math.h> #include<stdlib.h> #include<string> // 孩子兄弟表示法 typedef char elemtype; typedef struct node{ elemtype data; struct node *first_child,*right_sib; }tree_node,*link_tree_node;
数据结构与算法学习笔记：线性表和顺序存储
"数据结构与算法的学习笔记，包含基本数据结构的概念、代码实现及图片，但笔记格式不美观。" 本文将深入探讨数据结构与算法的相关知识，首先，我们要理解数据结构这一概念。数据结构是一门研究非数值计算中数据元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值