数据结构刷题笔记

最新推荐文章于 2023-01-10 15:38:36 发布

爱吃鱼的荔果果

最新推荐文章于 2023-01-10 15:38:36 发布

阅读量203

点赞数

本文链接：https://blog.csdn.net/longqiancao1/article/details/110121310

版权

1.单链表的反转

解题思路：1. 判断是否为空，空则返回null；

2.定义三个点，名为前中后，中指向头，表示当前节点，其他均为空；

3.next保存mid.next当前节点的下一个节点，就可以把当前节点的下一个节点指向前面的节点，mid.next = pre；

4.前中两个节点往后移，循环结束，返回pre。

public class Solution {
    public ListNode ReverseList(ListNode head) {
        // 1.先判断是否为空
        if(head == null){
            return null;
        }

        // 定义三节点，名为前中后，中指向head，表示当前节点
        // 当前节点是mid，pre为当前节点的前一节点，next为当前节点的下一节点
        // 需要pre和next的目的是让当前节点从pre->mid->next1->next2变成pre<-mid next1->next2
        // 即pre让节点可以反转所指方向，但反转之后如果不用next节点保存next1节点的话，此单链表就此断开了
        //所以需要用到pre和next两个节点
        //1->2->3->4->5
        //1<-2<-3 4->5
        ListNode pre = null;
        ListNode mid = head;
        ListNode next = null;
        
        while(mid != null) {

            //做循环，如果当前节点不为空的话，始终执行此循环，此循环的目的就是让当前节点从指向next到指向pre
            //如此就可以做到反转链表的效果
            //先用next保存head的下一个节点的信息，保证单链表不会因为失去head节点的原next节点而就此断裂
            next = mid.next;
            //保存完next，就可以让head从指向next变成指向pre了
            mid.next = pre;
            //head指向pre后，就继续依次反转下一个节点
            //让pre，head，next依次向后移动一个节点，继续下一次的指针反转
            pre = mid;
            mid = next;
        }
         //如果head为null的时候，pre就为最后一个节点了，但是链表已经反转完毕，pre就是反转后链表的第一个节点
        //直接输出pre就是我们想要得到的反转后的链表
        return pre;
    }
}

2.螺旋矩阵

将一个（m,n）的矩阵转换为螺旋矩阵。

分成4步，每步只移动一个坐标，用for循环遍历一行或一列。整体用while循环，判断条件是起始坐标小于等于结束坐标。

1.右走

2.下走

3.左走，注意判断首尾是否相等

4.上走，注意判断首尾是否相等

import java.util.*;
public class Solution {
    public ArrayList<Integer> spiralOrder(int[][] matrix) {
        
        ArrayList<Integer> result = new ArrayList<Integer>();
        
        if(matrix.length == 0){
            return result;
        }
        
        int rowBegin = 0;
        int rowEnd = matrix.length - 1;
        int colBegin = 0;
        int colEnd = matrix[0].length - 1;
        
        while(rowBegin <= rowEnd && colBegin <= colEnd){
            for(int j = colBegin; j <= colEnd; j++){
                result.add(matrix[rowBegin][j]);
            }
            rowBegin++;
            for(int i = rowBegin; i <= rowEnd; i++){
                result.add(matrix[i][colEnd]);
            }
            colEnd--;
            if(rowBegin <= rowEnd){
                for(int j = colEnd; j >= colBegin; j--){
                    result.add(matrix[rowEnd][j]);
                }
            }
            rowEnd--;
            if(colBegin <= colEnd){
                for(int i = rowEnd; i >= rowBegin; i--){
                    result.add(matrix[i][colBegin]);
                }
            }
            colBegin++;
        }
        return result;
    }
}

3.判断单链表是否有环

采用“快慢指针”的方法，一开始都指向head，fast走两步，slow走一步，当快慢指针相等时，表示有环。循环条件：fast != null && fast.next != null。

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null){
            return false;
        }
        ListNode fast = head;
        ListNode slow = head;
        
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                return true;
            }
        }
        return false;
    }
}

双指针技巧汇总

双指针技巧还可以分为两类，一类是「快慢指针」，另一类是「左右指针」。前者解决主要解决链表中的问题，比如典型的判定链表中是否包含环；后者主要解决数组（或者字符串）中的问题，比如二分查找。

https://www.cnblogs.com/kyoner/p/11087755.html

快慢指针

1、判定链表中是否含有环

2、已知链表中含有环，返回这个环的起始位置

3、寻找链表的中点

当链表的长度是奇数时，slow 恰巧停在中点位置；如果长度是偶数，slow 最终的位置是中间偏右。寻找链表中点的一个重要作用是对链表进行归并排序。

4、寻找链表的倒数第 k 个元素

左右指针

1、二分查找

2、数组内两数之和 只要数组有序，就应该想到双指针技巧。这道题的解法有点类似二分查找，通过调节 left 和 right 可以调整 sum 的大小：

3、反转数组

4、滑动窗口算法

4.判断二叉树是否对称（镜像）

递归【参考代码，神操作啊】

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return bool布尔型
     */
    public boolean isSymmetric (TreeNode root) {
        // write code here
        return check(root, root);
    }
    public boolean check(TreeNode x, TreeNode y) {
        if (x == null && y == null) return true;
        if ((x == null && y != null) || (x != null && y == null)) return false;
        return x.val == y.val && check(x.left, y.right) && check(x.right, y.left);
    }
}

5.将二叉树转换成其镜像

递归

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    
    public TreeNode Mirror (TreeNode pRoot) {
        // write code here
        if (pRoot == null || (pRoot.left == null && pRoot.right == null))
            return pRoot;
        TreeNode temp = pRoot.left;
        pRoot.left = pRoot.right;
        pRoot.right = temp;
        
        Mirror(pRoot.left);
        Mirror(pRoot.right);
        return pRoot;
    }
}

常用的十大算法

1.二分查找算法

2.分治法

分而治之，把一个复杂的问题分成两个或多个相同或相似的子问题，再把子问题分成更多的子问题，知道最后子问题可以简单的直接求解，原问题的解就是子问题的解的合并。

经典问题：

二分搜索
大整数乘法
棋盘覆盖
合并排序
快速排序
线性时间选择
最接近点对问题
循环赛日程表
汉诺塔

汉诺塔

代码分三步：

把 n-1 号盘子移动到缓冲区
把1号从起点移到终点（也可直接打印1号，效率更快）
然后把缓冲区的n-1号盘子也移到终点

public class Hanoitower {

	public static void main(String[] args) {

		hanoitower(3,'from','buffer','to');
	}

	public static void hanoitower(int num,char from,char buffer,char to) {

		// 如果只有一个
		if(num == 1) {
			System.out.println("the "+ num +" from " + from + "->" + to);
		} else {
			// 1.先把最上面的 n-1 号盘子移动到缓冲区
			hanoitower(num - 1, from, to, buffer);
			// 2.把1号从起点移到终点
			hanoitower(1, from, buffer,to);
            // 直接打印效率更快
			// System.out.println("the " + num + " from " + from + "->" + to);
			// 3.然后把缓冲区的n-1号盘子也移到终点
			hanoitower(num - 1, buffer, from,to);
		}
	}
}

3.动态规划

https://blog.csdn.net/hollis_chuang/article/details/103045322?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161853078016780264025942%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=161853078016780264025942&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-103045322.first_rank_v2_pc_rank_v29&utm_term=%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92

爱吃鱼的荔果果

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构刷题笔记

1.单链表的反转public class Solution { public ListNode ReverseList(ListNode head) { // 1.先判断是否为空 if(head == null){ return null; } // 定义三节点，名为前中后，中指向head，表示当前节点 //当前节点是mid，pre为当前节点的前一节点，next为当前节点的下一节点 .
复制链接

扫一扫