常见重要算法

已于 2023-10-26 00:06:19 修改
阅读量119 收藏 1
点赞数 1
分类专栏： 算法 文章标签： 算法 stack dfs queue bfs
于 2021-07-06 12:44:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47251999/article/details/118518042
版权

重要算法

排序

package review.sort;

import java.util.Arrays;

/**
 * @Author: xiang
 * @Date: 2021/7/5 14:20
 */
public class BaseSort {

    public static void main(String[] args) {
        int[] array = {4,3,5,8,1,5,6,10,14,3,21,100};
        System.out.println(Arrays.toString(array));
        quickSort(array,0, array.length-1);
        System.out.println(Arrays.toString(array));
    }

    // 冒泡排序
    public static void bubbleSort(int[] array){
        if (array == null || array.length<2) return;
        boolean change = false;
        for (int i=array.length-1; i > 0;i--){
            for (int j=0;j<i;j++){
                if (array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    change = true;
                }
            }
            if (!change) return;
        }
    }

    //插入排序
    public static void insertSort(int[] array){
        if (array == null || array.length<2) return;
        for (int i=0;i<array.length;i++){
            int value = array[i];
            int j=i-1;
            for (;j>-1;j--){
                if (array[j] > value)
                    array[j+1] = array[j];
                else
                    break;
            }
            array[j+1] = value;
        }
    }

    // 归并排序
    public static void mergeSort(int[] array,int begin,int end){
        if (begin >= end) return;
        int mid = (begin+end)/2;
        mergeSort(array,begin,mid);
        mergeSort(array,mid+1,end);
        merge(array,begin,mid,end);
    }

    private static void merge(int[] array, int begin, int mid, int end) {
        int[] tmp = new int[end-begin+1];
        int left = begin;
        int right = mid+1;
        int i=0;
        while (left < mid+1 && right<end+1){
            if (array[left] <= array[right])
                tmp[i++] = array[left++];
            else
                tmp[i++] = array[right++];
        }
        if (left == mid+1)
            System.arraycopy(array,right,tmp,i,end-right+1);
        else
            System.arraycopy(array,left,tmp,i,mid-left+1);
        System.arraycopy(tmp,0,array,begin,end-begin+1);
    }

    // 快速排序
    public static void quickSort(int[] array,int begin,int end){
        if (end - begin < 1) return;
        int i = partition(array,begin,end);
        quickSort(array,begin,i);
        quickSort(array,i+1,end);
    }

    private static int partition(int[] array,int begin,int end) {
        int i = begin;
        int j = begin;
        while (j<=end){
            // 分区点
            int value = array[end]; //选取最后一个元素作为分区点
            if (array[j] <= value){
                int tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
                i++;
            }
            j++;
        }
        return i==j ? i-2:i-1;
    }
}

归并算法时间复杂度计算分析

在这里插入图片描述

二分查找

package review.search;

import java.util.Arrays;

/**
 * @Author: xiang
 * @Date: 2021/7/5 17:03
 */
public class BinarySearch {
    public static void main(String[] args) {
        int[] array = {4,3,5,8,1,5,6,3,3,10,14,3,21,100};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
        System.out.println(searchFist(array,3));
        System.out.println(searchLast(array,3));
        System.out.println(searchFirstLargest(array,3));
        System.out.println(searchLastLeast(array,3));
    }

    /**
     * 二分查找
     * 未查找到返回-1
     *
     * 注：求什么 就在该条件下 if ( (mid == ?) || a[mid +/- 1] ? dest)
     */
    // 查找元素第一个位置
    public static int searchFist(int[] a,int dest){
        int left = 0;
        int right = a.length-1;
        while (left<=right){
            int mid = (left+right)>>1;
            if (a[mid] < dest){
                left = mid+1;
            }else if (a[mid] > dest){
                right = mid-1;
            }else {
                if ((mid == 0) || a[mid-1] != dest)
                    return mid;
                else
                    right = mid-1;
            }
        }
        return -1;
    }

    // 查找元素最后一个位置
    public static int searchLast(int[] a,int dest){
        int left = 0;
        int right = a.length-1;
        while (left<=right){
            int mid = (left+right)>>1;
            if (a[mid] < dest){
                left = mid+1;
            }else if (a[mid] > dest){
                right = mid-1;
            }else {
                if ((mid == a.length-1) || (a[mid+1] != dest))
                    return mid;
                else
                    left = mid+1;
            }
        }
        return -1;
    }

    // 查找第一个大于等于给定值的元素
    public static int searchFirstLargest(int[] a, int dest){
        int left = 0;
        int right = a.length-1;
        while (left<=right){
            int mid = (left+right)>>1;
            if (a[mid] >= dest){
                if ( (mid == 0) || a[mid-1] < dest)
                    return mid;
                else
                    right = mid-1;
            }else {
                left = mid+1;
            }
        }
        return -1;
    }

    // 查找最后一个小于等于给定值的元素
    public static int searchLastLeast(int[] a, int dest){
        int left = 0;
        int right = a.length-1;
        while (left <= right){
            int mid = (left + right)>>1;
            if (a[mid] <= dest){
                if ((mid == a.length-1) || a[mid+1] > dest)
                    return mid;
                else
                    left = mid+1;
            }else {
                right = mid-1;
            }
        }
        return -1;
    }
}

非递归遍历二叉树

记住：

    for root != nil || len(stack) > 0 {
		for root != nil {
			......	
            stack = append(stack,root)
            root = root.Left
        }
        ......
   }

前序遍历

func preorderTraversal(root *TreeNode) []int {
    var res []int
    stack := []*TreeNode{}
    for root != nil || len(stack) > 0 {
        for root != nil {
            res = append(res,root.Val)
            stack = append(stack,root)
            root = root.Left
        }
        root = stack[len(stack)-1].Right
        stack = stack[:len(stack)-1]
    }
    return res
}

中序遍历

func inorderTraversal(root *TreeNode) []int {
    var res []int
    stack := []*TreeNode{}
	for root != nil || len(stack) > 0 {
		for root != nil {
			stack = append(stack, root)
			root = root.Left
		}
		root = stack[len(stack)-1].Right
		res = append(res, stack[len(stack)-1].Val)
        stack = stack[:len(stack)-1]
	}
	return res
}

后续遍历(多一个变量：上一个被记录的节点)

func postorderTraversal(root *TreeNode) []int {
    var res []int
    stack := []*TreeNode{}
    var pre *TreeNode //上一个被记录的元素
    for root != nil || len(stack) > 0 {
        for root != nil {
            stack = append(stack,root)
            root = root.Left
        }
        node := stack[len(stack)-1]
        if node.Right != nil && node.Right != pre {
            root = node.Right
        }else{
            res = append(res,node.Val)
            pre = node //该节点已被记录
            stack = stack[:len(stack)-1]
        }
    }
    return res
}

    // 层次遍历
    public static void levelOrder(TreeNode<Integer> root){
        if (root == null) return;
        Queue<TreeNode<Integer>> deque = new LinkedList<>();
        deque.add(root);
        while (!deque.isEmpty()){
            TreeNode<Integer> tmp = deque.poll();
            System.out.print(tmp.date + " ");
            if (tmp.left != null){
                deque.add(tmp.left);
            }
            if (tmp.right != null){
                deque.add(tmp.right);
            }
        }
    }
}

Graph图

package review.graph;

import java.util.ArrayList;

/**
 * @Author: xiang
 * @Date: 2021/7/6 10:24
 *
 * 邻接表实现图
 */
public class Graph {
    private ArrayList<ArrayList<Integer>> graph;
    private int size; //图中有多少种元素(节点数)
    private boolean direction; //是否为有向图

    // 构造图
    public Graph(int size,boolean direction) {
        graph = new ArrayList<>(size);
        for (int i=0;i<size;i++){
            graph.add(new ArrayList<>());
        }
        this.size = size;
        this.direction = direction;
    }

    // 获取邻接表中的一条数据
    public ArrayList<Integer> getAround(int n){
        return graph.get(n);
    }

    // 添加元素
    public void add(int start,int end){
        graph.get(start).add(end);
        if (!direction) graph.get(end).add(start);
        size++;
    }

    // 删除元素
    public void delete(int start,int end){
        graph.get(start).remove((Integer) end);
        if (!direction) graph.get(end).remove((Integer) start);
        size--;
    }

    // 图中元素个数
    public int getSize() {
        return size;
    }
}

在这里插入图片描述

package review.graph;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author: xiang
 * @Date: 2021/7/6 10:43
 */
public class Traversal {

    public static void main(String[] args) {
        Graph graph = new Graph(6, false); //六个节点(从0~5的数字)
        graph.add(0,1);
        graph.add(0,2);
        graph.add(1,3);
        graph.add(1,2);
        graph.add(2,3);
        graph.add(2,4);
        graph.add(3,4);
        graph.add(3,5);
        BFS(graph,1);
        System.out.println();
        DFS(graph,1);
    }

    // 广度优先搜索   (1.遍历标识  2.队列)
    public static void BFS(Graph graph,int start){
        // 1.标志未访问
        boolean[] visited = new boolean[graph.getSize()];
        // 2.广度搜索 ==> 队列 (类似二叉树的按层遍历)
        Queue<Integer> queue = new LinkedList<>();
        // 注意：在放入队列中后 应立即修改为已遍历
        // 3.放入将查找的初始节点
        queue.add(start);
        visited[start] = true;
        while (!queue.isEmpty()){
            // 4.取出队首元素输出 并将其未遍历的邻接点加入队列中
            Integer v = queue.poll();
            System.out.print(v + " --> ");
            for (Integer n: graph.getAround(v)){
                if (!visited[n]){
                    queue.add(n);
                    visited[n] = true; //注意：加入队列就代表已遍历了！！！
                }
            }
        }
    }

    // 深度优先搜索  (1.遍历标识  2.栈)
    public static void DFS(Graph graph,int start){
        // 1.标志未访问
        boolean[] visited = new boolean[graph.getSize()];
        // 2.深度优先搜索 ==> 栈
        Deque<Integer> stack = new ArrayDeque<>();
        // 3.将查找的初始节点放入栈中 (同样 入栈立即为已遍历)
        stack.push(start);
        visited[start] = true;
        while (!stack.isEmpty()){
            // 4.取出栈顶元素输出 并将其未遍历的邻接点压入栈中
            Integer v = stack.pop();
            System.out.print(v + " ==> ");
            for (Integer n: graph.getAround(v)){
                if (!visited[n]){
                    stack.push(n);
                    visited[n] = true; //注意：压入栈就代表已遍历了！！！
                }
            }
        }
    }
}

Java杂记（忽略）

  1. 先过滤掉特殊值 ⭐
  2. 重要数据结构及常用方法 ⭐⭐⭐⭐⭐
     // 队列
     Queue<Integer> queue = new LinkedList<>();
     queue.add(1);
     queue.poll();
     queue.peek(); //返回队首元素但不弹出
     queue.contains(1); //注意！！！
     queue.size();
     queue.clear();
     queue.isEmpty();
     
     // 栈
     Deque<Integer> stack = new ArrayDeque<>();
     stack.push(1);
     stack.pop();
     stack.peek(); //返回队首元素但不弹出
     stack.contains(1); //注意！！！
     stack.size();
     stack.clear();
     stack.isEmpty();
     
     /**
     * 注意：堆不能存重复元素
     **/
     // 小顶堆 
     PriorityQueue<Integer> heap = new PriorityQueue<>();
     heap.add(1);
     heap.poll();
     heap.peek(); //返回队首元素但不弹出
     heap.contains(1); //注意！！！
     heap.size(); 
     heap.clear();
     heap.isEmpty();

	// 大顶堆
	PriorityQueue<Integer> heap = new PriorityQueue<>((x,y) -> y-x);
  1. int[] intArray = arrayList.stream().mapToInt(Integer::intValue).toArray();
  2. 数组copy只记这个就行了System.arraycopy(stones,0,stones,0,length);
  3. 没有汉字的字符串利用数组下标计数。
  4. int max = Integer.MIN_VALUE;
  5. 拷贝返回一个新数组：copyOfRange(T[] original, int from, int to) 【左闭右开】
咕噜咕噜崩
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见算法思想.pptx
06-11
对于计算机科学而言，算法是一个非常重要的概念。它是程序设计的灵魂，是将实际问题同解决该问题的计算机程序建立起联系的桥梁。接下来，我们来看看一些常用的算法思想。 （一）穷举法思想 　穷举法，又称为强力法...
常见算法介绍.docx
07-10
常见算法在计算机科学中扮演着重要角色，它们在数据处理、搜索、排序、图形处理等领域有广泛的应用。下面介绍一些常见的算法，包括排序算法、搜索算法、图算法和动态规划算法。 1. 排序算法 冒泡排序 (Bubble Sort) ...
一些重要的算法
热门推荐
陈皓专栏　【空谷幽兰，心如皓月】
07-22 10万+
本文罗列了一些比较重要的算法，有的我们经常在用，有的基本不用。有的很常见，有的有点偏。不过了解一下也是好事。也欢迎你留下你觉得有意义的算法。（原文：http://coolshell.cn/?p=2583）
十种重要算法
u011707992的专栏
06-25 460
算法一：快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法（Divide and conquer）策
算法的博客
qwlong007的专栏
02-03 1180
http://blog.csdn.net/v_JULY_v 奥地利符号计算研究所（Research Institute for Symbolic Computation，简称RISC）的Christoph Koutschan博士在自己的页面上发布了一篇文章，提到他做了一个调查，参与者大多数是计算机科学家，他请这些科学家投票选出最重要的算法，以下是这次调查的结果，按照英文名称字母顺序排序。
计算机科学中最重要的32个算法
掉下个小石头
08-06 1万+
英文原址：http://www.risc.jku.at/people/ckoutsch/stuff/e_algorithms.html奥地利符号计算研究所（Research Institute for Symbolic Computation，简称RISC）的Christoph Koutschan博士在自己的页面上发布了一篇文章，提到他做了一个调查，参与者大多数是计算机科学家，他请这些科学家投票选出
一个老程序员PHP程序员说的话(什么是境界，我想我应该好好想想了)
weixin_34365417的博客
12-19 949
我，一个老程序员，也是一个学生，把玩过甚多语言，大多不精。我既非名牌学校，也不是高学历，仅代表一部分比较蛋疼的人。接触PHP也是很早了，从04年的OFSTAR开始的，到现在六年了，期间也接触过不少的语言。从脚本JS到底层的C语言。坦诚的说，我不是个高手，但是我相信自己比大多数人接触的知识面要宽广，深刻些吧。同时我也是一名学生，从东南大学到西电，对计算机的爱好一波三折。 ...
常见加密算法常见加密算法
05-29
总的来说，加密算法在现代信息技术中扮演着至关重要的角色，它们确保了数据在传输过程中的安全，防止了未经授权的访问和篡改。对于Python开发者来说，理解和掌握这些加密算法及其在Python中的实现，是提升系统安全性...
机器学习常见算法分类
12-28
在机器学习领域，算法众多，了解每种算法的特点和应用场景至关重要。根据学习方式和算法类似性，可以将机器学习算法分为几大类。 一、学习方式 机器学习的学习方式可以分为四类：监督式学习、非监督式学习、半监督...
ALG.zip_alg算法_常见算法
09-24
空间复杂度则表示算法执行过程中所占用的内存空间，这对于内存受限的环境至关重要。 在这个压缩包中，"算法设计与分析"很可能是书籍的电子版或者课程笔记，涵盖了各种基础和进阶的算法知识。可能包括了排序算法（如...
算法的五个重要特性
沐烬
09-07 2万+
输入(Input) 一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件； 输出(Output) 一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的； 确定性(Definiteness) 算法中的每一条指令必须有确切的含义，不能产生多义性： 可行性(Effectiveness)
十大重要算法（转载）
IMmicheal的博客
04-22 487
算法一：快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。快速排序使用分治法（Divide and conquer）策略来把一个串行
大数据等最核心的关键技术：32个算法
java、c++、机器学习方向King
01-12 4177
http://bigdata.51cto.com/art/201701/527588.htm?utm_source=tuicool&utm_medium=referral 合并查找算法(Union-find)——给定一组元素，该算法常常用来把这些元素分为多个分离的、彼此不重合的组。不相交集(disjoint-set)的数据结构可以跟踪这样的切分方法。 奥地利符号计算研究所(Rese
真正统治世界的十大算法
Embeded system Development
06-10 4568
本文由 伯乐在线 - Justin Wu 翻译自 Marcos Otero。欢迎加入技术翻译小组。转载请参见文章末尾处的要求。 不久前的某一天，我在浏览Reddit发现了一篇有趣的文章《统治世界的十大算法》，作者George Dvorsky在那篇文章中试图解释算法之于当今世界的重要性，以及哪些算法对人类文明最为重要。 此时此刻，如果你已经学过算法的话，那么在你阅读那篇文章时
很重要很底层又很难的算法-2-如何“玩”算法
weixin_40805079的博客
09-12 707
既然是“玩”算法，首先要会玩，否则只会被算法“玩死”。很多朋友啃完了《算法》、《算法导论》或其他算法书籍，对各种排序、搜索、遍历等常用算法了如指掌，但是遇到实际的问题时还是束手无策，这与智力无关，这其实就是经验和方法集的问题。很多啃过算法书的朋友都知道堆排序和最大最小堆，但是却不能有效地应用到实际问题中。例如，某算法书介绍 Dijkstra 算法时，提到当问题规模比较大时，每次查找 dist 数...
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 241
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
插入和选择排序
最新发布
c23856的博客
07-20 224
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 220
完全二叉树的节点个数-递归
常见加密算法 使用场景
08-03
常见的加密算法在不同的场景中有不同的应用。对称加密算法通常用于保护大量数据的传输和存储，例如在网络通信中使用的...总的来说，常见的加密算法在保护数据的传输、存储和身份验证等方面发挥着重要的作用。[1][2][3]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值