算法记录 & 牛客网 & leetcode刷题记录

解题思路

从最简单的case开始想，一般能找到规律。

如果从最简单的case不能找到思路，那么一般人不会，也不用死扎着这道题。

STL容器

map<type,type2> ：有序的，如果不指定排序，最后一个元素最大
unordered_map：无序的
set：有序的
unordered_set：无序的
vector
priority_queue <int,vector,greater > q：从小到大排列
priority_queue <int,vector,less >q：从大到小排列

常用算法模板

堆排序

小顶堆：每次都把最大的调整到根部，最后把最大的放在数组末尾，最终形成的堆根部是最小的
大顶堆：每次都把最小的调整到根部，最后把最小的放在数组末尾，最终形成的堆根部是最大的

在优先队列里，

//小顶堆，top的时候返回元素最小的那个
priority_queue <int,vector<int>,greater<int> > q;
//大顶堆，top的时候返回元素最大的那个
priority_queue <int,vector<int>,less<int> >q;
``


堆排序每次调整成大顶/小顶堆后，把堆顶元素放到数组末尾，然后继续调整大顶/小顶堆
```cpp
class HeapSort {
   
public:
	void heapSort(vector<int>& arr) {
   
		if (arr.size() == 0) {
   
			return;
		}
		int len = arr.size();
		// 构建大顶堆，这里其实就是把待排序序列，变成一个大顶堆结构的数组
		buildMaxHeap(arr, len);
 
		// 交换堆顶和当前末尾的节点，重置大顶堆
		for (int i = len - 1; i > 0; i--) {
   
			swap(arr, 0, i);
			len--;
			heapify(arr, 0, len);
		}
	}
 
	void buildMaxHeap(vector<int>& arr, int len) {
   
		// 从最后一个非叶节点开始向前遍历，调整节点性质，使之成为大顶堆
		for (int i = (int)floor(len / 2) - 1; i >= 0; i--) {
   
			heapify(arr, i, len);
		}
	}
 
	void heapify(vector<int>& arr, int i, int len) {
   
		// 先根据堆性质，找出它左右节点的索引
		int left = 2 * i + 1;
		int right = 2 * i + 2;
		// 默认当前节点（父节点）是最大值。
		int largestIndex = i;
		if (left < len && arr[left] > arr[largestIndex]) {
   
			// 如果有左节点，并且左节点的值更大，更新最大值的索引
			largestIndex = left;
		}
		if (right < len && arr[right] > arr[largestIndex]) {
   
			// 如果有右节点，并且右节点的值更大，更新最大值的索引
			largestIndex = right;
		}
 
		if (largestIndex != i) {
   
			// 如果最大值不是当前非叶子节点的值，那么就把当前节点和最大值的子节点值互换
			swap(arr, i, largestIndex);
			// 因为互换之后，子节点的值变了，如果该子节点也有自己的子节点，仍需要再次调整。
			heapify(arr, largestIndex, len);
		}
	}
 
	void swap (vector<int>& arr, int i, int j) {
   
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
};

插入排序

插入排序其实是冒泡排序的反向，插入排序从数组第二个元素开始，每加入一个元素，都将其和前面已有的元素进行比较，然后不断调整位置。

void insertionSort(vector<int> & data) {
   
	for (int i = 1; i < data.size(); i++) {
   
		for (int j = i; j >= 1; j--) {
   
			if (data[j] < data[j - 1]) {
   
				int tmp = data[j];
				data[j] = data[j - 1];
				data[j - 1] = tmp;
			}
		}
	}
	return;
}

快速排序

原理：每次随机将数组中的一个数，放到他指定的排序后的位置。
比如，把一个数A，放到数组的位置i，那么[0,i-1]的位置都是比A小的数，[i+1,size-1]都是比A大的数

class Solution {
   
public:
    void qsort(vector<int>& nums,int start,int end,int k){
   
    int size=nums.size();
    int i=start,j=end,base=nums[start];
    if(size<=0) return;
    
    
    while(i<j){
   
        while(nums[j]<=base && i<j){
   
            j--;    
        }
        
        if(i<j) nums[i]=nums[j];
        
        while(nums[i]>=base && i<j) i++;
        
        if(i<j) nums[j]=nums[i];
     }
    
     
     nums[i]=base;
    
    if(i+1>k) qsort(nums,start,i-1,k);
    else if(i+1==k) return ;
    else qsort(nums,i+1,end,k);
}
    
    int findKthLargest(vector<int>& nums, int k) {
   
        int size=nums.size();
        qsort(nums,0,size-1,k);
        return nums[k-1];
    }
    
    
    
};

BFS层序遍历

二叉树的层序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
   
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
   
        vector<vector<int>> res;
        if(root == nullptr){
   
            return res;
        }

        queue<TreeNode*> q;

        q.push(root);

        while(!q.empty()){
   
            int level_size = q.size();
            vector<int> v;

            while(level_size--){
   
                TreeNode* tmp_node = q.front();
                if (!(tmp_node->left== nullptr)){
   
                    q.push(tmp_node->left);
                }
                if(!(tmp_node->right == nullptr)){
   
                    q.push(tmp_node->right);
                }
                q.pop();
                v.push_back(tmp_node->val);
            } 
            
            res.push_back(v);
        }
        return res;
    }
};

二叉树

JZ55 二叉树的深度

关键词：二叉树、深度优先遍历、递归

自己写的笨蛋方法：

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
   
public:
    int max_depth = 0;
    int now_depth = 0;
    int TreeDepth(TreeNode* pRoot) {
   
        if(pRoot == NULL){
   
            return max_depth;
        }
        this->now_depth++;
        if(now_depth>max_depth){
   
            max_depth=now_depth;
        }
        this->TreeDepth(pRoot->left);
        this->TreeDepth(pRoot->right);
        this->now_depth--;
        return max_depth;
    }
};

优秀解答：

1. 递归解法

class Solution {
   
public:
	int TreeDepth(TreeNode* pRoot){
   
	    if(!pRoot) return 0 ;
            return max(1+TreeDepth(pRoot->left), 1+TreeDepth(pRoot->right));
	}
};

2. BFS解法

i