DSA on pipo's site

Queue

Sun, 29 Sep 2024 00:00:00 +0000

队列

队列(Queue)是遵循先进先出(FIFO)规则的线性数据结构,正如同它的名字一样，先进入队列排队的元素会首先离开队列，像在羽毛球桶里的羽毛球一样，先放进去的球会从下面先取出来。

如图所示，删除队首元素的过程叫做出队，将新元素加入队尾的过程叫做入队。

栈的实现

STL中队列的使用

使用标准库中队列前首先应引入头文件**<queue>**,下面将简单介绍队列简单的使用。

#include <queue>
//队列的声明
std::queue<data_type> q1;
std::queue<data_type> q2;

//向队列中添加元素
q1.push(val);

//删除队首元素
q1.pop();

//复制队列
q1 = q2;

//访问队首和队尾元素
q1.front();
q1.back();

//检查队列是否为空与获取元素
q1.empty();
q1.size();

应注意的一点是，pop()没有返回值，需要先使用front()再次使用pop().

基于链表的实现

class Queue{
	private:
		Node* front;
		Node* back;
		int quesize;
	public:
		Queue(){
			front = nullptr;
			back = nullptr;
			quesize = 0;
		}
		~Queue(){
			freeMemoryNode(front);
		}
    
    	int getSize(){
            return quesize;
        }
    	
    	bool isEmpty(){
			return quesize == 0;
        }
    
    
		void push(int val){
			Node* node = new Node(val);
			if(front == nullptr){
				front = node;
				back = node;
			}
            
            else{
            	back->next = node;
				back = node;
            }
			quesize++;
		}
    	
    	void pop(){
            if(isEmpty()) throw std::runtime_error("队列为空");
            Node* tmp = front->next;
            delete front;
            front = tmp;
            quesize--;
        }
    
    	int peek(){
			if(isEmpty()) throw std::runtime_error("队列为空");
            return back->val;
        }
    	
    	
};

基于数组的实现

为能专注于对队列的实现和理解，我们这里使用标准库中的**<vector>**实现。

在数组中删除元素的操作时间复杂度为$O(n)$,如果我们直接删除的话就不等于队列删除元素的操作时间复杂度$O(1)$了，所以我们这里使用front和back作为队列的首尾，每次删除只将front后移一位，而不删除元素。

#include <vector>
class Queue{
	private:
		std::vector<int> queue;
		int front;
		int back;
		int quesize;
	public:
		Queue(){
			front = -1;
			back = -1;
			quesize = 0;
		}
		~Queue(){
			//vector自动管理内存
		}
		
		int getSize(){
            return quesize;
        }
    	
    	bool isEmpty(){
			return quesize == 0;
        }
    
    
		void push(int val){
			queue.push_back(val);
			if(front == -1){
				front = 0;
				back = 0;
			}
            
            else{
            	back = queue.size()-1;
            }
			quesize++;
		}
    	
    	void pop(){
            if(isEmpty()) throw std::runtime_error("队列为空");
            front++;
            quesize--;
        }
    
    	int peek(){
			if(isEmpty()) throw std::runtime_error("队列为空");
            return queue[front];
        }
		
};

*为什么不使用C风格数组

如果不使用vector，则需要预制数组大小，并且在即将超出数组大小限制时进行扩容操作，或者将back再次指向那些被`删除`元素的下标，但这样依旧会面临扩容操作，这两种操作方式较为复杂此处不再赘述。

队列各操作效率

操作名	时间复杂度
pop()	$O(1)$
push()	$O(1)$
peek()	$O(1)$

队列相关题目

二叉树迭代法实现层序遍历：102. 二叉树的层序遍历 - 力扣（LeetCode）

Stack 基础总结

Sun, 29 Sep 2024 00:00:00 +0000

栈

栈(Stack)属于线性数据结构，它遵循着先进后出(FILO)原则,就像是在杠铃上的杠铃片，要想拿到最开始放进去的片必须把在它之后的所有杠铃片全部弹出(pop),而每次加新片只能在末尾压入(push),通常我们把最后一个入栈元素的位置叫做`栈顶`,最先入栈的元素叫做`栈底`.

栈的实现

在CPP中有内置的栈包含在stack头文件中，但这里我们分别用数组和链表来模拟栈的基本功能。

基于数组的实现方式

class Stack{
    private:
        std::vector<int> st;
        
    public: 
        //获取栈的大小
        int getSize(){
            return st.size();
        }

        //检查是否为空
        bool isEmpty(){
            return st.empty();
        }

        //返回栈顶元素
        int peek(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            return st.back();        
        }

        //添加元素
         void push(int val){
            st.push_back(val);
         }

         //弹出元素
         void pop(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            st.pop_back();
         }


};

基于链表的实现方式

class Stack{
    private:
        Node* st;
    
    public:

        Stack() : st(nullptr) {} 

    // 析构函数，防止内存泄漏
    ~Stack() {
        while (!isEmpty()) {
            pop(); 
        }
    }
        //获取栈的大小
        int getSize(){
            Node* tmp = st;
            int size;
            for(size = 0; tmp != nullptr; size++){
                tmp = tmp->next;
            }
            return size;
        }

        //检查是否为空
        bool isEmpty(){
            if(st == nullptr) return true;

            else return false;
        }

        //返回栈顶元素
        int peek(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            return st->val;        
        }

        //添加元素
        void push(int val){
            Node* nd = new Node(val);
            nd->next = st;
            st = nd;
            
         }
        

         //弹出元素
         void pop(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            auto tmp = st->next;
            delete st;
            st = tmp;
         }


};

Node的详细实现详见链表,此处只简单实现。

class Node{
	public:
		int val;
		Node* next;
		Node(int value): val(value), next(nullptr) {}
}

值得注意的是此处新元素的插入与链表直接在尾部插入不同，而是在头部插入，并将新的节点作为头节点。

*两种实现的对比

支持操作

两种实现都支持栈定义中的各项操作。数组实现额外支持随机访问，但这已超出了栈的定义范畴，因此一般不会用到。

时间效率

在基于数组的实现中，入栈和出栈操作都在预先分配好的连续内存中进行，具有很好的缓存本地性，因此效率较高。然而，如果入栈时超出数组容量，会触发扩容机制，导致该次入栈操作的时间复杂度变为 O(n) 。

在基于链表的实现中，链表的扩容非常灵活，不存在上述数组扩容时效率降低的问题。但是，入栈操作需要初始化节点对象并修改指针，因此效率相对较低。不过，如果入栈元素本身就是节点对象，那么可以省去初始化步骤，从而提高效率。

综上所述，当入栈与出栈操作的元素是基本数据类型时，例如 int 或 double ，我们可以得出以下结论。

基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高。

基于链表实现的栈可以提供更加稳定的效率表现。

空间效率

在初始化列表时，系统会为列表分配“初始容量”，该容量可能超出实际需求；并且，扩容机制通常是按照特定倍率（例如 2 倍）进行扩容的，扩容后的容量也可能超出实际需求。因此，基于数组实现的栈可能造成一定的空间浪费。

然而，由于链表节点需要额外存储指针，因此链表节点占用的空间相对较大。

综上，我们不能简单地确定哪种实现更加节省内存，需要针对具体情况进行分析。

栈相关练习题

二叉树的迭代法进行前中后序遍历

链表基础总结

Sat, 28 Sep 2024 00:00:00 +0000

链表

链表基本组成

链表(linked list)属于线性数据结构，其主要由数据本身和指向下一节点的指针构成。

在一般的链表中，头节点为第一个节点，在某些实现中，头节点本身不包含元素，尾节点的next指针指向'空’，其本身为null，nullptr或者None。

graph LR subgraph head A`[next] end head-->1 subgraph 1 B[1] B`[next] end 1-->2 subgraph 2 C[2] C`[next] end 2-->3 subgraph 3 D[3] D`[next] end 3-->4 subgraph 4 E[4] E`[next] end 4 -->None subgraph None F`[null] end

其基本组成单位是节点(node),与数组不同，每个节点在计算机的内存中都是随机存放的，所有要找到下一个节点所在的位置就需要存储下一节点位置的指针，因此通常情况下链表所占用的内存空间要大于数组。

class Node{
	public:
		int val;
		Node* next;
		Node(int value): val(value), next(nullptr) {} //构造函数 赋值
};

链表的基础操作

1. 链表初始化

链表初始化分为两步，先将节点赋值，再构建节点之间的关系，当链表正确初始化之后便可以从头节点开始遍历所有元素了。

Node* node1 = new Node(1);
Node* node2 = new Node(2);
Node* node3 = new Node(3);
Node* node4 = new Node(4);
//创建节点并赋值
node1->next = node2;
node2->next = node3;
node3->next = node4;
//连接节点

2. 插入

链表的插入本质上是在内存中开辟一个单位的Node空间，赋值后将插入位置的前一个节点Node(n)的next指针指向这块内存，将该节点next指针指向原链表之后的节点Node(n+1),相比数组更快，因此时间复杂度仅为$O(1)$.

Node* insert(Node* node, Node* head){
     //直接在尾节点处插入
	if(head == nullptr) return node;
	Node* curr = head;
	while(curr->next && curr){   //在尾节点插入复杂度为O(n)
		curr = curr->next;
		}
	curr->next = node;
	return head;
}

Node* insert2(Node* node, Node* p){
	//在p节点之后插入
    Node* tmp = p->next;
	p->next = node;
	node->next = tmp;
	return node;
}

3. 删除

删除与插入的逻辑基本相同，找到待删除节点，与其前驱，将前驱的next节点指向待删除结点的next节点，然后删去该节点。

void deletenode(Node* n){
	//删去n之后的首个节点
	Node* tmp;
	if(n == nullptr || n ->next == nullptr) return;
	tmp = n->next->next;
	delete(n->next);
	n->next = tmp;
}

4. 访问与查找节点

在链表中访问节点的速度较慢，每次必须从头节点开始遍历直到找到，其时间复杂度为$O(n)$, 而数组的访问为$O(1)$.

Node* access(Node* head, int index){
	Node* curr = head;
	for(int i = 0; i < index; i++){
		if(curr == nullptr) return curr;
		curr = curr->next;
	}
	return curr;
}
Node* find(Node* head, int val){
    //查找第一个值为val的节点
	Node* curr = head;
    while(curr != nullptr){
		if(curr->val == val) return curr;
        curr = curr->next;
    }
    return nullptr;
}

常见的链表

单向链表 ：即上述介绍的链表，只能单方向地从头节点遍历到尾节点，在进行插入删除等操作时，需要随时保存前驱节点。
双向链表 : 相比单向链表增加了prev指针用于保存上一个节点，在使用时更加灵活，但是也加大了内存开销。

graph LR subgraph head A`[next] end head-->1 subgraph 1 B[1] B`[next] end 1-->2 1-->head 2-->1 subgraph 2 C[2] C`[next] end 2-->3 3-->2 subgraph 3 D[3] D`[next] end 3-->4 4-->3 subgraph 4 E[4] E`[next] end 4 -->None None-->4 subgraph None F`[null] end
```
class ListNode{
public:
//双向链表
  int val;
  Node* next;
  Node* prev;
  Node(int value): val(value), next(nullptr), prev(nullptr) {} //构造函数 赋值
};
```
环形链表 : 即将单向链表的尾节点next指针指向头节点而不再指向`空`，在环型链表中任意节点都可以视作头节点。

graph LR subgraph 1 B[1] B`[next] end 1-->2 subgraph 2 C[2] C`[next] end 2-->3 subgraph 3 D[3] D`[next] end 3-->4 subgraph 4 E[4] E`[next] end 4 -->1

哈希表基础总结

Sat, 10 Aug 2024 00:00:00 +0000

哈希表

哈希表(hash table)又称作散列表,它是基于键值对(key-value pair)存储和访问数据的一种非线性数据结构。

哈希表通过哈希函数将键(key)映射到特定位置来实现对数据的快速存取与访问。

哈希表虽然只要知道键通过哈希函数就可以找到值，但是在哈希表内通常同时存储着键和值。其主要原因是当出现哈希冲突(hash collision)时需要通过键来确定多个值具体属于哪个键。

可以用函数对应关系理解 $f(key) = address$, $array[address] = value$。

访问查询	$O(1)$
添加元素	$O(1)$
删除元素	$O(1)$

哈希表的实现

STL中哈希表的使用

在cpp中哈希表通常是用unordered_map实现

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;
int main(){
	//初始化
	unordered_map<string, int> hashmap;
	unordered_map<string, int> hashtable =
	{
		{"num1", 1},
		{"num2", 2},
		{"num3", 3}

	};
		
	//访问
	hashtable["num3"];
	hashtable["num3"] = 1;
	hashtable.at("num3");


	//插入
	hashmap.insert({"key", 123});
	hashmap.emplace("key2", 1234);//无条件更新
	hashmap.try_emplace("key2", 1234);//如果键存在则不会更新

	//删除
	hashmap.erase("key2");
	hashmap.erase(hashmap.begin());
	hashmap.clear(); //清空容器

	//查找
	auto it = hashtable.find("num1");
	if (it != hashtable.end()){ //存在则返回所在位置迭代器，否则返回尾后迭代器
		cout<<it->first<<" "<<it->second;
	}

	if(hashtable.count("num2") == 0){
		return false;
	}

	bool exists = hashmap.contains("num3");

	//其他操作
	auto isempty = hashmap.empty();
	hashmap.size();

	return 0;
}

基于数组的简单实现

此处只是简单实现，为方便计算hash值key规定为int型。

对于哈希表来说哈希函数可以是其核心所在，因此哈希函数的设计尤为重要，常见的哈希函数有以下几种：

直接寻址法：取关键字或关键字的某个线性函数值为散列地址。即$hash(k)=k$或$hash(k)=a⋅k+b$，其中$a,b$为常数（这种散列函数叫做自身函数）

数字分析法：假设关键字是以r为基的数，并且哈希表中可能出现的关键字都是事先知道的，则可取关键字的若干数位组成哈希地址。

平方取中法：取关键字平方后的中间几位为哈希地址。通常在选定哈希函数时不一定能知道关键字的全部情况，取其中的哪几位也不一定合适，而一个数平方后的中间几位数和数的每一位都相关，由此使随机分布的关键字得到的哈希地址也是随机的。取的位数由表长决定。

折叠法：将关键字分割成位数相同的几部分（最后一部分的位数可以不同），然后取这几部分的叠加和（舍去进位）作为哈希地址。

随机数法

除留余数法：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即$hash(k)=k\ mod\ p$, $ p≤m$。不仅可以对关键字直接取模，也可在折叠法、平方取中法等运算之后取模。对p的选择很重要，一般取素数或m，若p选择不好，容易产生冲突。

struct Pair{	
	public:
		string value;
		int key;
		Pair(int key, string val) {
			this->key = key;
			this->value = val;
		}
};

class hashtable{
	private:
		vector<Pair*> buckets;
	public:
		hashtable(){
			buckets = vector<Pair*>(100);//申请大小为100的空间
		}
		~hashtable(){
			for(const auto& bucket:buckets){
				delete bucket;
			}
			buckets.clear();
		}
    
    
		int hashFunction(int key){
            //哈希函数
			int index = key % buckets.size(); //对key取模后作为下标索引便于访问键值对
			return index;
		}
		void insert(int key, string val){
			int index = hashFunction(key);
			Pair* pair = new Pair(key, val);
			buckets[index] = pair;
		}
		
		string search(int key){
			int index = hashFunction(key);
            //如果不为空，且key值相等返回value
			if (buckets[index] != nullptr && buckets[index]->key == key) {
				return buckets[index]->value;
			}
			return "";
		}
    	
		void remove(int key){
			int index = hashFunction(key);
			delete buckets[index];
			buckets[index] = nullptr;
		}
    
		void print(){
			for(const auto& bucket:buckets){
				if(bucket != nullptr){
					cout<<bucket->key<<" "<<bucket->value<<endl;
				}
			}
		}
};

可能你会有疑问，如果我输入的是相同的key值，那哈希函数计算出的index岂不是相同了吗？

又或者我存入的数据很多超过了预先申请的桶大小该怎么办，如果它能够自动扩容，那么因为容器大小发生了变化哈希函数的计算方式又会变化，这可能又会引发冲突。

哈希冲突

哈希冲突(hash collision)发生的原因是因为我们输入的内容要远远大于输出的内容，我们有无限的输入通过哈希函数转换成一个固定长度的索引，因此发生哈希冲突是不可避免的。

从图中我们可以猜想，如果桶的数量越大那么发生冲突的概率越低，于是我们可以通过扩容来降低哈希冲突的概率。

于是我们引入了负荷因子(load factor)用它来衡量哈希表的冲突程度。 $$ (负荷因子)α = 哈希表元素数 / 桶容量 $$ 一般选择$α$为0.7~0.8作为触发扩容的条件。

哈希冲突的常见几种解决方法为开放地址法、链式探测法和多次哈希法。