自己写链表结构体和二叉树

已于 2022-11-12 20:01:44 修改
阅读量108 收藏
点赞数
分类专栏： Leetcode问题总结 文章标签： c语言 算法 数据结构
于 2021-07-08 14:01:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37297658/article/details/118569722
版权

上次商汤科技面试问到删除链表倒数第N个节点的题目，题目本身不难，但是需要自己写链表的输入，结构体创建等，下面附上两种方法，其实是一样的哈哈，细微区别，考虑到了链表可能输入长度是0的情况！
Case1：自定义输入链表元素，然后实现功能，链表元素可以不输入就是空链表
代码1：val赋值和链表创建分开：

//删除倒数第N个链表j节点自己写
//	head->next=new Listnode();这样是不行的，因为next是空节点，没有资格进行操作，因为没有val 
#include<bits/stdc++.h>
using namespace std;
struct ListNode{
	int val;
	ListNode*next;
	ListNode():val(0),next(nullptr){}
	ListNode(int x):val(x),next(nullptr){}		
}; 

ListNode* DeleteNode(ListNode* head,int n); //函数声明 
int main(){
	cout<<"Please enter the length of the list: ";
	int M; cin>>M;
	vector<int>nums(M);
	ListNode* head=new ListNode();
	ListNode* temp=head;
	if(M==0){
		cout<<"nullptr";
		return 0;
	}
		
	for(int i=0;i<M;i++){
    	cin>>nums[i];
		temp->next=new ListNode(nums[i]); //反正注意把，只有new的元素可以对next进行操作，操作也是给new！！ 除非索引到已经建立的链表就Listnode*temp=head; 
		temp=temp->next;
		temp->next=nullptr;//稳妥起见		
	}
	head=head->next;
	
	//调用函数
	cout<<"Please delete the last n node: ";
	int n; cin>>n; 
	ListNode* Head=DeleteNode(head,n);
	if(Head==nullptr)
		cout<<"This is nullptr"; 
	while(Head!=nullptr){
		cout<<Head->val<<" ";
		Head=Head->next;
	}
	return 0;		
}
///leetcode函数 
ListNode* DeleteNode(ListNode* head,int n){
	if(head==nullptr)
		return head; 
	ListNode* dummy = new ListNode(0);
	dummy->next=head;
	ListNode* cur = dummy;
	int length=0;
	while(head){
		length++;
		head=head->next;	
	}
        
	for (int i = 1; i < length - n + 1; ++i) {
        	cur = cur->next;
    }
    cur->next = cur->next->next;
    ListNode* ans = dummy->next;
    delete dummy;
    return ans;		
}

代码2：val和链表创建合在一起：

//删除倒数第N个链表j节点自己写
//	head->next=new Listnode();这样是不行的，因为next是空节点，没有资格进行操作，因为没有val 
#include<bits/stdc++.h>
using namespace std;
struct ListNode{
	int val;
	ListNode*next;
	ListNode():val(0),next(nullptr){}
	ListNode(int x):val(x),next(nullptr){}		
}; 

ListNode* DeleteNode(ListNode* head,int n); //函数声明 
int main(){
	cout<<"Please enter the length of the list: ";
	int M; cin>>M;
	vector<int>nums(M);
	ListNode* head=new ListNode(); //没有赋值就是空结点 
	ListNode* temp=head;
	for(int i=0;i<M;i++){
    	cin>>nums[i];
    	temp->val=nums[i];
    	if(i!=M-1){
    		temp->next=new ListNode(); //反正注意把，只有new的元素可以对next进行操作，操作也是给new！！ 除非索引到已经建立的链表就Listnode*temp=head; 链表这种必须分配空间就是反正
			temp=temp->next; 	
		}
		temp->next=nullptr;//稳妥起见		
	}
	
	//调用函数
	cout<<"Please delete the last n node: ";
	int n; cin>>n; 
	ListNode* Head=DeleteNode(head,n);
	if(Head==nullptr)
		cout<<"This is nullptr"; 
	while(Head!=nullptr){
		cout<<Head->val<<" ";
		Head=Head->next;
	}
	return 0;		
}
///leetcode函数 
ListNode* DeleteNode(ListNode* head,int n){
	if(head==nullptr)
		return head;
	ListNode* dummy = new ListNode(0);
	dummy->next=head;
	ListNode* cur = dummy;
	int length=0;
	while(head){
		length++;
		head=head->next;	
	}
        
	for (int i = 1; i < length - n + 1; ++i) {
        	cur = cur->next;
    }
    cur->next = cur->next->next;
    ListNode* ans = dummy->next;
    delete dummy;
    return ans;		
}

下面附上删除正数第N个节点的主干程序：

如输入1->2->3->3->4->5,删除第3个节点;
ListNode * deleteNodes(ListNode* head,int& index)
{
    if(head== nullptr)
    {
        return nullptr;
    }
    ListNode* dumpy=new ListNode();
    dumpy->next=head;
    ListNode* cur=head;
    ListNode* prev=dumpy;
    int count=1;
    while(cur!= nullptr)
    {
        if(count==index)
        {
            prev->next=cur->next;
            break;
        }
        prev=cur;
        cur=cur->next;
        count++;

    }
    return dumpy->next;
}

————————————————————————————————————————
Case2：根据输入的数组来创建二叉树，然后对二叉树操作Leetcode题目实现功能：
除了链表，二叉树的输入也是题目可能会考到的，下面举个简单的二叉树问题来分析代码：

代码1: 层序遍历输入数组创建二叉树，层序遍历输出，这里输出可以前中后序就不展开了。这里的情况针对输入是完全二叉树

//程序功能：输入一组数据是二叉树的层序遍历，要求根据数据创建二叉树，然后用层序遍历来输出二叉树 
#include<string>
#include<sstream>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;

struct TreeNode{
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode():val(0),left(NULL),right(NULL){} //这样允许我们可以使用 new TreeNode 或者 new TreeNode() 
	TreeNode(int x):val(x),left(NULL),right(NULL){} //这里就简单这么赋值把 
};

TreeNode* creatBinTree(vector<int> & arr) ;
void printBinTree_bfs(TreeNode* head); //声明下二叉树输出函数 
int Final_Task(TreeNode* head);
int main() {
	vector<int> a;
	cout<<"Please enter the numbers: "<<endl;
	string str; getline(cin,str);
	stringstream ss(str); string temp;
 	while(getline(ss,temp,' '))
    {
 		a.push_back(stoi(temp));
    }

	TreeNode* head = creatBinTree(a); //注意到这样就行了，虽然里面是创建了形参，但是我最终给他return出来了两个地址对上了地址的改变还是存在的！！！ 
	printBinTree_bfs(head);
	//int res=Final_Task(head); //比如是int形式的输出
	//cout<<res; 
}


//按照层序遍历构造二叉树--二叉树构造程序 
TreeNode* creatBinTree(vector<int> & arr) { 
 queue<TreeNode*> q;
 //如果层序序列为空，返回空树
 if (arr.empty()) {
  return nullptr;
 }
 
 TreeNode* head =new TreeNode; //创建头节点  注意到结构体的赋值用new一般是针对指针式样结构体 如链表和树这种 
 head->val = arr[0];  //存放数组首元素
 q.push(head); //入队
 
 TreeNode* temp; //工具人temp 
 int i = 1;
 while (!q.empty()) {
  temp = q.front();  //取出头节点，准备给它安排左右孩子
  q.pop(); //头节点出队，每一次新的循环，都让头出队
  
  //先弄左孩子
  //i只要不超过数组的有效长度，就有左孩子从0开始计数，0已经赋值就1了 
  if (i < arr.size()) {
   temp->left = new TreeNode(); //或者 new TreeNode 
   temp->left->val = arr[i];
   q.push(temp->left);  //左孩子入队
   i++; //数组后移
  }
  else {
   temp->left = nullptr;
  }
  
  //再弄右孩子
  if (i < arr.size()) {
   temp->right = new TreeNode();
   temp->right->val = arr[i];
   q.push(temp->right);  //右孩子入队
   i++;  //数组后移
  }
  else {
   temp->right = nullptr;
  }
 }
 return head;  //最后队列为空就出while，返回头节点
}

//层序遍历二叉树
void printBinTree_bfs(TreeNode* head) {
 queue<TreeNode*> q;
 
 //树为空
 if (head == nullptr) {
  cout << "TreeNode is empty!" <<endl;
  return;
 }
 
 //头节点入队
 q.push(head);
 TreeNode* b; //工具人b 
 while (!q.empty()) {
  b = q.front();  //拿到队头，队头出队
  q.pop();
  cout <<b->val<< endl;  //打印对头的数据
  
  //对头的左孩子存在就入队
  if (b->left) {
   q.push(b->left);
  }
  
  //对头的右孩子存在就入队
  if (b->right) {
   q.push(b->right);
  }
 }
}




///自己的程序
/*
Final_Task(TreeNode*head){
	//比如输出二叉树的最大深度 
}

*/

代码2：那有人会问，上面的情况是 针对完全二叉树，如果输入的数据中有null怎么办啊 可以在输入时候做微小的改动，这里是层序遍历的输入元素，可以存在nullptr，然后层序输出二叉树元素

//程序功能：输入一组数据是二叉树的层序遍历，要求根据数据创建二叉树，然后用层序遍历来输出二叉树，支持输入的元素是逗号隔开存在nullptr
#include<string>
#include<cstring>
#include<sstream>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;

struct TreeNode{
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode():val(0),left(NULL),right(NULL){} //这样允许我们可以使用 new TreeNode 或者 new TreeNode() 
	TreeNode(int x):val(x),left(NULL),right(NULL){} //这里就简单这么赋值把 
};

TreeNode* creatBinTree(vector<string> & arr) ;
void printBinTree_bfs(TreeNode* head); //声明下二叉树输出函数 
int Final_Task(TreeNode* head);
int main() {
	vector<string> a;
	cout<<"Please enter the numbers: "<<endl;
	string str; getline(cin,str);
	stringstream ss(str); string temp;
 	while(getline(ss,temp,' '))
    {
 		a.push_back(temp);
    }

	TreeNode* head = creatBinTree(a); //注意到这样就行了，虽然里面是创建了形参，但是我最终给他return出来了两个地址对上了地址的改变还是存在的！！！ 
	printBinTree_bfs(head);
	//int res=Final_Task(head); //比如是int形式的输出
	//cout<<res; 
}


//子程序1：-------------------------按照层序遍历构造二叉树--二叉树构造程序 
TreeNode* creatBinTree(vector<string> & arr) { 
 queue<TreeNode*> q;
 if (arr.empty()) {
  return nullptr;
 }
 
 TreeNode* head =new TreeNode; //创建头节点  注意到结构体的赋值用new一般是针对指针式样结构体 如链表和树这种 
 head->val = stoi(arr[0]);  
 q.push(head); 
 
 TreeNode* temp; //工具人temp 
 int i = 1;
 while (!q.empty()) {
  temp = q.front();  
  q.pop(); 
  
  //先弄左孩子
  //i只要不超过数组的有效长度，就有左孩子从0开始计数，0已经赋值就1了 
  if (i < arr.size()) {
  	if(arr[i]=="nullptr")
   		temp->left=nullptr;
    else{
   		temp->left = new TreeNode(); //或者 new TreeNode 
   		temp->left->val = stoi(arr[i]);
   		q.push(temp->left);  //左孩子入队
	   }
	i++; //数组后移 
}
  else 
   temp->left = nullptr;
  
  //再弄右孩子
  if (i < arr.size()) {
  	if(arr[i]=="nullptr")
  		temp->right=nullptr;
  	else{
  		temp->right = new TreeNode();
   		temp->right->val = stoi(arr[i]);
   		q.push(temp->right);  //右孩子入队
	  }
	i++;  //数组后移	
  }
  else 
   temp->right = nullptr; 
 }
 return head;  //最后队列为空就出while，返回头节点
}

//子程序2：------------------------层序遍历输出二叉树
void printBinTree_bfs(TreeNode* head) {
 queue<TreeNode*> q;
 
 //树为空
 if (head == nullptr) {
  cout << "TreeNode is empty!" <<endl;
  return;
 }
 
 //头节点入队
 q.push(head);
 TreeNode* b; //工具人b 
 while (!q.empty()) {
  b = q.front();  //拿到队头，队头出队
  q.pop();
  cout <<b->val<< endl;  //打印对头的数据
  
  //对头的左孩子存在就入队
  if (b->left) {
   q.push(b->left);
  }
  
  //对头的右孩子存在就入队
  if (b->right) {
   q.push(b->right);
  }
 }
}




///自己的程序
/*
Final_Task(TreeNode*head){
	//比如输出二叉树的最大深度 
}

*/

————————————————————————————————————————
Case3：
有时候我们的输入不是层序遍历，比如是前序遍历，或者后序中序遍历。这里原理是一样的。我们取前序遍历来展开。即，输入的元素比如1 2 3 4是二叉树的前序遍历顺序，要求我们创建对应二叉树实现功能，如何创建二叉树呢：
下面的是前序遍历构建二叉树的子程序！ 注意到我们的index作为全局变量初始值给1，因为遇到空节点的时候会自动return，这样就不会说出不来了。注意就是当我们是right或者left指向的时候其实宏观是这个根节点的位置!!这个是递归的想法

//子程序1：-------------------------按照前序构造二叉树--二叉树构造程序 
TreeNode* creatBinTree(vector<string> & arr) { 
    if(arr.size()==0)
    	return nullptr;
 
    string value=arr[index];
    index++;
	if (value =="nullptr") {
		return nullptr;
	}
	TreeNode* head = new TreeNode(stoi(value));//如果不为空则创建该节点，同时递归进行左节点与右节点的创建 
	head->left = creatBinTree(arr);
	head->right= creatBinTree(arr);
	return head;
	
}

或者，如何实现后续遍历输入呢：
对于1 2 3然后下面4个空节点的二叉树，我们按照后序遍历输入：
X X 2 X X 3 1，层序遍历输出应该是1 2 3
下面附上代码，其思路是按照根 右 左，和后续遍历的顺序相反来构建二叉树，前提是对输入数组进行一个反转。这样就能和前序遍历类似来构造函数了：
这也是考虑到了中序或者后续遍历开头就是nullptr，不好返回

//子程序1：-------------------------按照后续遍历构造二叉树--二叉树构造程序 
TreeNode* creatBinTree(vector<string> & arr) { 
    if(arr.size()==0)
    	return nullptr;
 
    string value=arr[index];
    index++;
	if (value =="nullptr") {
		return nullptr;
	}
	TreeNode* head = new TreeNode(stoi(value));
	
	head->right= creatBinTree(arr);  //注意到我这边用了 根、右、左的顺序。输出的是相反的 
	head->left = creatBinTree(arr);
	
	return head;
	
}

中序遍历不能得到有效解：
可以看到同样的输入序列有不同的二叉树~
在这里插入图片描述

谢蟹蟹猴啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单的链表结构体
keeplooking2510的专栏
10-06 546
#include using namespace std; //数组相当于一个大小不可以调解的容器，一般用来存放比较少的东西。 //而链表就一个大容器分成很多个小容器，在每个小容器中放入合适大小的元素，然后用指针将它们链接起来， //它可以根据需要设定容器的大小，所以不会浪费空间。 //结构体与类的不同点：结构体的成员默认为公有成员，而类的成员默认为私有成员。 struct book
数据结构-二叉链表的结构与实现
最新发布
m0_61789994的博客
05-11 8141
二叉链表是一种特殊的链表，它的每个节点都有两个指针，一个指向左子树，一个指向右子树。这种结构可以用来表示树形结构，如二叉树等。二叉链表是一种常用的数据结构，它可以用于实现二叉树、哈夫曼树、二叉堆、二叉搜索树等算法。二叉链表的结构相对简单，实现起来也比较容易，但是需要注意指针的使用，避免出现空指针和死循环等问题。在实际应用中，我们需要根据具体的需求选择合适的数据结构，以提高算法的效率和性能。
二叉链表结构定义简单解释
CapsLock_CL0658的博客
08-25 5256
二叉链表结构定义简单解释 1、链表定义 typedef int DataType; typedef struct Node { DataType data; //数据域 struct Node *next; //指针域 }Node; //此处Node表示这个链表的名字 2、二叉链表定义 typedef struct BiTNode{ TElemtype data; //
二叉树的二叉链表的简单实现及操作
TECH_PRO的博客
06-05 5316
本文主要简单的说一说二叉树的二叉链表的简单实现及操作。简单的说一说二叉链表的结点定义，树的创建，结点的插入，子树的销毁、树的拷贝等常用操作。 一、创建二叉树、拷贝二叉树 本文创建的二叉树采用二叉链表的形式来创建，二叉链表定义的树的结点通常包含一个数据域，两个地址域（分别用来指向左右子树），所以在创建树之前需要定义一个表示结点的结构体，具体实现如下： /* 定义一个结构体用于表示二叉树
二叉树的二叉链表存储结构及C++实现
weixin_34268843的博客
12-29 1127
前言：存储二叉树的关键是如何表示结点之间的逻辑关系，也就是双亲和孩子之间的关系。在具体应用中，可能要求从任一结点能直接访问到它的孩子。 一、二叉链表 　　二叉树一般多采用二叉链表（binary linked list）存储，其基本思想是：令二叉树的每一个结点对应一个链表结点链表结点除了存放与二叉树结点有关的数据信息外，还要设置指示左右孩子的指针。二叉链表的结点结构如下图所示： 二叉树结点结构...
sc.rar_二叉树_链表
09-24
在IT领域，数据结构是计算机科学的基础，而二叉树和链表是其中最核心的概念。本压缩包“sc.rar”包含对这两种数据结构的深入理解和实现，让我们逐一解析。 首先，我们来看二叉树。二叉树是一种特殊的树形数据结构，...
链表创建二叉树
06-02
在计算机科学领域，数据结构是研究的重点之一，而链表和二叉树作为两种基本的数据结构，在算法设计、系统开发等方面有着广泛的应用。本篇文章将详细介绍如何通过链表来创建二叉树，并探讨其相关功能的实现。 #### ...
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
本题主要涉及二叉树的链式存储方式以及基于链表的二叉树的基本操作，包括先序遍历、计算二叉树的高度、节点总数、叶子节点数、层次遍历以及左右子树的交换等。下面我们将逐一探讨这些知识点。 首先，二叉链表存储的...
使用链表实现二叉树
08-30
通过以上代码，我们可以使用C++的链表实现一个完整的二叉树，包括创建、销毁、查询、插入、删除和遍历等基本操作。在实际应用中，二叉树的性能和效率取决于其特定的实现和操作。例如，平衡二叉树如AVL树和红黑树能...
数据结构 三叉链表表示的二叉树
06-11
传统的二叉树在内存中通常用链表来实现，每个节点包含一个数据元素、一个指向左子节点的指针和一个指向右子节点的指针。然而，三叉链表的引入是为了优化某些特定操作，比如遍历。在三叉链表中，每个节点除了包含数据...
数据结构15——建立二叉树的二叉链表存储结构（严6.70）
chengchencheng的博客
06-08 7462
Description如果用大写字母标识二叉树结点，则一颗二叉树可以用符合下面语法图的字符序列表示。试编写递归程序，由这种形式的字符序列，建立相应的二叉树的二叉链表存储结构(附图见《严蔚敏：数据结构题集（C语言版）》第45页6.70)。Input输入如图所示的字符序列。Output建立相应二叉树的二成叉链表存储结构，并先序遍历输出。Sample Input A(B(#,D),C(E(#,F),#)...
用C语言实现二叉树的结构和常用操作
yudejiao的博客
11-27 7659
#include#include typedef float ElemType;typedef struct S_BiTNode//定义结点类型结构体{ElemType data;//数据域struct S_BiTNode * lchild;//左子树struct S_BiTNode * rchild;//右子树struct S_BiTNode * parent;//父结点}BiTNode;/**
C语言实现二叉树（二叉链表）
Arithmetic-logic
07-30 8871
文章目录定义结构体初始化先序遍历创建二叉树测试递归遍历中序前序后序非递归遍历中序前序后序其他方法 定义结构体 初始化 先序遍历创建二叉树 //1按照先序次序输入二叉树中结点的值，构造二叉链表表示的二叉树bt void CreateBinTree_1(BinTree *bt) { CreateBinTree_1(bt, &(bt->root));//参数的传递都需要地址 } void CreateBinTree_1(BinTree *bt, BinTreeNode **t) {//*t代表根节
结构体数组二叉树
一个懒惰的程序员
07-31 415
#include<stdio.h> #include<iostream> #include<stdlib.h> using namespace std; class TreeNode{ public: int left; int right; float data; public : TreeNode(){ this->lef...
数据结构之二叉树的创建
热门推荐
顾小豆的博客
02-24 9万+
文章开头首先要感谢一下国嵌嵌入式教育的工作者们。创建二叉树 二叉树不仅比通用树结构简练，而且同时拥有通用树相同的操作。要想创建二叉树，首先就得了解一下二叉树的存储结构。已知二叉树的存储结构分为顺序存储结构和链式存储结构。其中链式存储结构又分为二叉链表和三叉链表。1. 顺序存储结构：按照顺序存储结构的定义，在此约定用一组地址连续的存储单元一次自上而下、自左至右存储完全二叉树上的节点元素，即将完全二叉...
创建二叉树的二叉链表存储结构
AnalogElectronic的博客
06-07 2万+
#include<stdio.h> #include<stdlib.h> #include<string.h> #define MAXLEN 100 typedef char ElemType; typedef char DataType; //二叉链表存储结构 typedef struct BiTNode { DataType data; stru...
数据结构__基本概念和算法评价
LIUUGNAY的博客
09-27 908
数组 数组是一种①线性表数据结构，它是一组②连续的内存空间，来存储一组③具有相同类型的数据。 数组的特点 高效的随机访问 低效的插入和删除 链表 物理存储单元上非连续 、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针连接次序实现的。链表由一系列结点组成，节点可以在运行时动态生成。每个节点包括：一是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 LinkedList和ArrayList比较 ArrayList的实现基于数组，LinkedList的实现基于双向链表 对于随机访问，Array
二叉链表存储二叉树
weixin_34032792的博客
08-20 4537
链式存储结构 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。其结点结构为： 其中，data域存放某结点的数据信息；lchild与rchild分别存放指向左孩子和右孩子的指针，当左孩子或右孩子不存在时，相应指针域值为空（用...
二叉树链表存储结构体结点代码示意图
04-26
这是一个二叉树链表存储结构体结点的代码示意图： ``` struct BTNode { int data; // 节点的值 BTNode* leftChild; // 左子节点 BTNode* rightChild; // 右子节点 }; ``` 每个节点包含一个值 data 和两个指针 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值