【刷题】 - 数据结构与算法的实现_数据结构写多维信号的均值滤波

刷题 - 数据结构与算法

---

---

前言

无

---

一、数据结构

1.单链表

• C语言 - 单链表实现

2.二叉树

• 树的概念与实现

• 二叉搜索树

• 二叉搜索树：概念、结构、复杂度，查询、插入、删除以及其C++实现

• 二叉树的非递归前、中、后序遍历

 /**
     * 统一一下
     * @param root
     * @return
     */
    //前序
    public static List<Integer> preOrder(TreeNode root){
         List<Integer> list = new ArrayList();
         Stack<TreeNode> stack = new Stack();
         TreeNode cur = root;
         while(cur!=null || !stack.isEmpty()){
             //一直往左压入栈
             while(cur!=null){
                 list.add(cur.val);
                 stack.push(cur);
                 cur = cur.left;
             }
             cur = stack.pop();
             cur = cur.right;
         }
         return list;
    }

    //中序
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root == null){
            return new ArrayList();
        }
        List<Integer> list = new ArrayList();
        Stack<TreeNode> stack = new Stack();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur!=null){
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            list.add(cur.val);
            cur = cur.right;
        }
        return list;
    }


    //后序遍历，非递归
    public static List<Integer> postOrder(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> list = new ArrayList<>();
        TreeNode cur = root;
        TreeNode p = null;//用来记录上一节点
        while(!stack.isEmpty() || cur != null){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.peek();
//            后序遍历的过程中在遍历完左子树跟右子树cur都会回到根结点。所以当前不管是从左子树还是右子树回到根结点都不应该再操作了，应该退回上层。
//            如果是从右边再返回根结点，应该回到上层。
            //主要就是判断出来的是不是右子树，是的话就可以把根节点=加入到list了
            if(cur.right == null || cur.right == p){
                list.add(cur.val);
                stack.pop();
                p = cur;
                cur = null;
            }else{
                cur = cur.right;
            }

        }
        return list;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

3.哈西表

例题

• _1. 两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashtable;
        for (int i = 0; i < nums.size(); ++i) {
            auto it = hashtable.find(target - nums[i]);
            if (it != hashtable.end()) {
                return {it->second, i};
            }
            hashtable[nums[i]] = i;
        }
        return {};
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

二、算法

1、排序

分类

性能

• C++排序算法代码汇总
• C语言实现八大排序算法（一）

1.1 冒泡排序

• 基本思想：
  相邻元素两两比较，反序则交换，正序则对大元素重复相邻比较操作，一轮比较完毕，最大元素浮到数组顶端；第二轮，次大元素浮到剩余数组顶端；直至排序结束。
• 方法步骤:
  a.从第一个数开始，将其与下一元素做比较，反序则将二者交换；
  b.始终对大数进行比较操作，直至最大数浮到数组顶端；
  c.重复步骤，次大数浮到剩余数组顶端，直至数组排序结束；

//冒泡排序
//平均时间复杂度:O(N^2)
//最坏情况复杂度:O(N^2)
//空间复杂度:O(1)
//稳定排序
void bubblesort(vector<int>& a)
{
    int n = a.size();
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (a[j] > a[j+1])
                swap(a[j], a[j+1]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.2 堆排序

• C++实现

2、递归

• 递归

3、查找

3.1二分查找

• 二分查找使用 mid=(low+high)/2 可能会发生溢出，因此写为 mid=low+(high-low)/2 这种写法。（虽然数学上是一样的）

3.2三分查找

public class Solution extends GuessGame {
    public int guessNumber(int n) {
        int low = 1;
        int high = n;
        while (low <= high) {
            int mid1 = low + (high - low) / 3;
            int mid2 = high - (high - low) / 3;
            int res1 = guess(mid1);
            int res2 = guess(mid2);
            if (res1 == 0)
                return mid1;
            if (res2 == 0)
                return mid2;
            else if (res1 < 0)
                high = mid1 - 1;
            else if (res2 > 0)
                low = mid2 + 1;
            else {
                low = mid1 + 1;
                high = mid2 - 1;
            }
        }
        return -1;
    }
}
复杂度分析
    时间复杂度：O(log⁡3n)，为三分查找所需的时间复杂度。
    空间复杂度：O(1)，没有使用额外的空间。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

三、数据结构与算法错误

1.单链表

C语言写链表

//链表销毁
void DestorySlinkList(SLinkList** ppHead)
{
    SLinkList* cur = *ppHead;
    SLinkList* Dest;
    
    ///错误，先让指针指向空，避免不进入循环的情况
    /*正确答案
    SLinkList* del=NUll;
    */
    assert(ppHead);
    while(cur!=NULL)
    {
        Dest=cur;
        free(Dest);
        Dest=NULL;
        cur=cur->_pNext;
        
        ///严重错误，先让cur指向下一位置，否则找不到下一位置
        /*正确答案
        del = cur;
        cur = cur->_pNext;

        free(del);
        del = NULL;
        */
    }
    ppHead==NULL;
    return;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

---

总结

无