数据结构与算法之排序、查找、哈希表

最新推荐文章于 2024-07-15 11:08:21 发布
最新推荐文章于 2024-07-15 11:08:21 发布
阅读量138 收藏 1
点赞数 1
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 java 排序 哈希
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48465257/article/details/119056675
版权

排序算法 查找算法 时间复杂度 空间复杂度 Java实现
关键词由CSDN通过智能技术生成

文章目录

  • 时间复杂度顺序：O(1) < O(log2n) < O(n) < O(nlog2n) < O(n2) < O(n3) < O(nk) < O(2n)

排序

排序算法平均时间复杂度最好情况最坏情况空间复杂度稳定性
冒泡排序O(n2)O(n)O(n2)O(1)稳定
选择排序O(n2)O(n2)O(n2)O(1)不稳定
插入排序O(n2)O(n)O(n2)O(1)稳定
希尔排序O(nlog2n)O(n1.3)O(n2)O(1)不稳定
归并排序O(nlog2n)O(nlog2n)O(nlog2n)O(n)稳定
快速排序O(nlog2n)O(nlog2n)O(n2)O(log2n)不稳定
堆排序O(nlog2n)O(nlog2n)O(nlog2n)O(1)不稳定
基数排序O(n*k)O(n*k)O(n*k)O(n+k)稳定

冒泡排序

public class Bubble {
    public static void main(String[] args) {
        int[] ints = new int[100000];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = (int) (Math.random() * 100000000);
        }
        long start = System.currentTimeMillis();
        for (int i = 0; i < ints.length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < ints.length - 1 - i; j++) {
                if (ints[j + 1] > ints[j]) {
                    flag = true;
                    int temp = ints[j + 1];
                    ints[j + 1] = ints[j];
                    ints[j] = temp;
                }
            }
            if (!flag) {
                break;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

选择排序

public class Select {
    public static void main(String[] args) {
        int[] ints = new int[100000];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = (int) (Math.random() * 100000000);
        }
        long start = System.currentTimeMillis();
        for (int i = 0; i < ints.length - 1; i++) {
            int min = ints[i];
            int pos = i;
            for (int j = i + 1; j < ints.length; j++) {
                if (ints[j] < min) {
                    min = ints[j];
                    pos = j;
                }
            }
            int temp = ints[pos];
            ints[pos] = ints[i];
            ints[i] = temp;
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

插入排序

public class Insert {
    public static void main(String[] args) {
        int[] ints = new int[100000];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = (int) (Math.random() * 100000000);
        }
        long start = System.currentTimeMillis();
        for (int i = 1; i < ints.length; i++) {
            int value = ints[i];
            int index = i - 1;
            while (index >= 0 && value < ints[index]) {
                ints[index + 1] = ints[index];
                index--;
            }
            ints[index + 1] = value;
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

希尔排序

交换法

public class Shell01 {
    public static void main(String[] args) {
        int[] ints = new int[100000];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = (int) (Math.random() * 100000000);
        }
        long start = System.currentTimeMillis();
        for (int step = ints.length / 2; step > 0; step /= 2) {
            for (int j = step; j < ints.length; j++) {
                for (int k = j - step; k >= 0; k -= step) {
                    if (ints[k] > ints[k + step]) {
                        int temp = ints[k];
                        ints[k] = ints[k + step];
                        ints[k + step] = temp;
                    }
                }
            }
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

移位法

public class Shell02 {
    public static void main(String[] args) {
        int[] ints = new int[100000];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = (int) (Math.random() * 100000000);
        }
        long start = System.currentTimeMillis();
        for (int step = ints.length / 2; step > 0; step /= 2) {
            for (int i = step; i < ints.length; i++) {
                int pos = i; 
                int value = ints[i];
                while (pos - step >= 0 && value < ints[pos - step]) {
                    ints[pos] = ints[pos - step];
                    pos -= step;
                }
                ints[pos] = value;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

快速排序

public class Quick {

    public static void main(String[] args) {
        int[] ints = new int[100000];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = (int) (Math.random() * 100000000);
        }
        long start = System.currentTimeMillis();
        quick(0, ints.length - 1, ints);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    public static void quick(int left, int right, int[] ints) {
        if (left > right) {
            return;
        }
        int l = left;
        int r = right;
        int pivot = ints[left];
        while (l < r) {
            while (pivot <= ints[r] && l < r) {
                r--;
            }
            while (pivot >= ints[l] && l < r) {
                l++;
            }
            if (l < r) {
                int temp = ints[l];
                ints[l] = ints[r];
                ints[r] = temp;
            }
        }
        ints[left] = ints[l];
        ints[l] = pivot;
        quick(left, r - 1, ints);
        quick(r + 1, right, ints);
    }
}

基数排序

public class Radix {
    public static void main(String[] args) {
        List<Queue<Integer>> list = new ArrayList<>(10);
        for (int i = 10; i > 0; i--) {
            list.add(new LinkedList<>());
        }
        int[] ints = new int[100000];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = (int) (Math.random() * 100000000);
        }
        int max = ints[0];
        for (int anInt : ints) {
            if (anInt > max) {
                max = anInt;
            }
        }
        long start = System.currentTimeMillis();
        int maxLength = (max + "").length();
        for (int i = 0, n = 1; i <= maxLength; i++, n *= 10) {
            for (int anInt : ints) {
                int element = (anInt / n) % 10;
                list.get(element).add(anInt);
            }
            int index = 0;
            for (Queue<Integer> queue : list) {
                while (!queue.isEmpty()) {
                    ints[index] = queue.poll();
                    index++;
                }
            }
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

查找

折半查找

public class Binary {
    public static void main(String[] args) {
        int[] ints = {1,5,96,478,569,789,1234,4896,5896,6781,6781,6781,6781,8985};
        System.out.println(search(ints, 6781, 0, ints.length - 1));
    }

    public static List<Integer> search(int[] ints, int value, int low, int high) {
        List<Integer> list = new ArrayList<>();
        while (low <= high) {
            int mid = (low + high) / 2;
            int temp = ints[mid];
            if (value < temp) {
                high = mid - 1;
            } else if (value > temp) {
                low = mid + 1;
            } else {
                list.add(mid);
                int left = mid - 1;
                while (left >= 0 && ints[left] == value) {
                    list.add(left);
                    left--;
                }
                int right = mid + 1;
                while (right <= ints.length - 1 && ints[right] == value) {
                    list.add(right);
                    right++;
                }
                break;
            }
        }
        return list;
    }
}

插值查找

//关键字分布均匀，速度较快
public class Insert {
    public static void main(String[] args) {
        int[] ints = {1,5,96,478,569,789,1234,4896,5896,6781,6781,6781,6781,8985};
        System.out.println(search(ints, 6781, 0, ints.length - 1));
    }

    public static List<Integer> search(int[] ints, int value, int low, int high) {
        if (low > high || value < ints[0] || value > ints[ints.length - 1]) {
            return null;
        }
        int mid = low + (high - low) * (value - ints[low]) / (ints[high] - ints[low]);
        int temp = ints[mid];
        if (value < temp) {
            return search(ints, value, low, mid - 1);
        } else if (value > temp) {
            return search(ints, value, mid + 1, high);
        } else {
            List<Integer> list = new ArrayList<>();
            list.add(mid);
            int left = mid - 1;
            while (left >= 0 && ints[left] == value) {
                list.add(left);
                left--;
            }
            int right = mid + 1;
            while (right <= ints.length - 1 && ints[right] == value) {
                list.add(right);
                right++;
            }
            return list;
        }
    }
}

斐波那契查找

public class Fibonacci {
    public static void main(String[] args) {
        int[] ints = {1,5,96,478,569,789,1234,4896,5896,6781,6781,6781,6781,8985,8985};
        System.out.println(search(ints, 8985));
    }

    public  static int[] fib() {
        int[] f = new int[20];
        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i < 20; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }
        return f;
    }

    public static List<Integer> search(int[] ints, int value) {
        List<Integer> list = new ArrayList<>();
        int low = 0;
        int high = ints.length - 1;
        int k =0;
        int mid = 0;
        int[] f = fib();
        while (high > f[k] - 1) {
            k++;
        }
        int[] temp = Arrays.copyOf(ints, f[k]);
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = ints[high];
        }
        while (low <= high) {
            mid = low + f[k - 1] - 1;
            if (value < temp[mid]) {
                high = mid - 1;
                k--;
            } else if (value > temp[mid]) {
                low = mid + 1;
                k -= 2;
            } else {
                if (mid <= high) {
                    list.add(mid);
                    int left = mid - 1;
                    while (left >= 0 && ints[left] == value) {
                        list.add(left);
                        left--;
                    }
                    int right = mid + 1;
                    while (right <= high && ints[right] == value) {
                        list.add(right);
                        right++;
                    }
                } else {
                    list.add(high);
                    int left = high - 1;
                    while (left >= 0 && ints[left] == value) {
                        list.add(left);
                        left--;
                    }
                }
                break;
            }
        }
        return list;
    }
}

哈希表

public class User {
    private int id;
    private String name;

    public User() {
    }

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

public class HashTab {

    private List<List<User>> list;
    private int size;

    public HashTab(int size) {
        this.size = size;
        list = new ArrayList<>(size);
        for (int i = 0; i < size; i++) {
            list.add(new ArrayList<>());
        }
    }

    public int hashFun(int id) {
        return id % size;
    }

    public void addUser(User user) {
        int num = hashFun(user.getId());
        list.get(num).add(user);
    }

    public void show() {
        for (List<User> users : list) {
            System.out.println(users);
        }
    }

    public User find(int id) {
        User user = null;
        int num = hashFun(id);
        for (int i = 0; i < list.get(num).size(); i++) {
            if (list.get(num).get(i).getId() == id) {
                user = list.get(num).remove(i);
            }
        }
        return user;
    }
}

public class HashTest {
    public static void main(String[] args) {
        HashTab hashTab = new HashTab(10);
        hashTab.addUser(new User(1564, "张三"));
        hashTab.addUser(new User(4587, "李四"));
        hashTab.addUser(new User(9874, "王五"));
        hashTab.show();
        System.out.println(hashTab.find(1));
        System.out.println(hashTab.find(4587));
        hashTab.show();
    }
}
独守丶轩
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法---希尔排序
weixin_51451819的博客
08-11 182
希尔排序 由插入排序可以知道当插入的数是较小的数时，后移的次数明显增多，对效率有影响。 什么是希尔排序： 希尔排序也是一种插入排序。它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。 基本思想： 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件被分成一组，算法便终止。 希尔排序在排序的过程中按从小到大或从大到小的原则（我们选择），将小（大）的数往左边靠，避免了特别小（大）的数出现在最后导致需要移动
数据结构与算法-查找和排序
weixin_56262931的博客
08-24 422
数据 经过 哈希函数 计算出数据再哈希表中的位置，然后标记位置，方便之后的查找，它的时间复杂度可以达到O(1)，但是该算法有很大的局限性，不适合负数、浮点型数据、字符型数据的查找，还需要额外申请存储空间，空间复杂度高，是一种典型的以空间换时间的算法。冒泡：数据左右进行比较，把最大的数一直交换到最后，特点是该算法对数据的有序性敏感，在排序过程中发现有序可以立即停止排序，如果待排序的数据基本有序，则冒泡的效率非常高。根据数据的值存储到不同的桶中，然后再调用其它的排序算法，对桶中的数据进行排序，
详解java排序、查找和哈希表算法
Waiting的博客
03-03 254
java排序及查找算法汇总 排序 1)内部排序：指将需要处理的所有数据都加载到**内部存储器（内存）中进行排序。 2）外部排序： 数据量过大，无法全部加载到内存中，需要借助外部存储（文件等）**进行排序。 3）常见的排序算法分类： （一）冒泡排序 1.算法思想：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。 优化：因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列
数据结构（六）：查找和排序-哈希表的设计
奔跑吧蚂蚁呀
08-20 181
【算法系列 | 9】深入解析查找算法之—哈希表查找
热门推荐
颜淡慕潇
10-12 2万+
哈希表查找算法在许多应用中具有高效的性能，但它也有一些限制，如哈希冲突和不适合有序数据。 选择哈希表作为查找数据结构时，需要权衡其优点和缺点，并确保选择合适的哈希函数和冲突解决方法。
【数据结构与算法】查找和排序的程序
03-14
这里的“【数据结构与算法】查找和排序的程序”显然涵盖了这两个核心概念在实际编程中的应用，特别是通过C语言实现。下面我们将深入探讨哈希表和快速排序这两种重要的数据结构和算法。 首先，哈希表是一种高效的...
C语言 算法 排序 数据结构 哈希表等
12-07
在IT领域，特别是软件开发和计算机科学中，掌握C语言、算法、数据结构以及哈希表等基础知识至关重要。这些概念是构建高效程序的基础，对于理解计算机如何处理信息有着深远的影响。 首先，我们来深入探讨一下C语言。...
数据结构与算法之美.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
武汉理工大学数据结构与算法综合实验之景区
10-08
数据结构与算法是计算机科学的基础，对于理解和解决复杂问题至关重要。武汉理工大学的这门数据结构与算法综合实验课程，旨在让学生深入理解并实践这些核心概念。在这个实验中，"景区"可能是一个比喻，用于帮助学生...
026-数据结构与算法之美026-数据结构与算法之美026-数据结构与算法之美026-数据结构与算法之美
12-27
比如，哈希表用于高效查找，二叉搜索树用于保持数据有序，堆可以实现优先队列，图数据结构则在社交网络、路由算法等领域有着广泛应用。 此外，理解和掌握数据结构与算法之美，还能帮助我们更好地理解和使用各种高级...
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 439
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 206
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 398
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 218
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 956
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
hanmo22357的博客
07-12 844
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
摩尔投票算法
qq_55846232的博客
07-14 465
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 307
手撕七大排序 （三）
【JavaScript 算法】哈希表：快速查找与存储
最新发布
Allen-
07-15 773
哈希表（Hash Table）是一种非常高效的数据结构，用于实现快速的查找和存储操作。通过使用哈希函数将数据映射到数组中的某个位置，哈希表能够在常数时间内完成插入、删除和查找操作。
哈希表查找算法与堆数据结构解析
总结来说，哈希表提供快速的查找功能，而堆则是一种具有特定性质的数据结构，常用于实现优先队列和高效的排序算法。两者都是数据结构和算法中不可或缺的部分，尤其在C语言这样的编程环境中，理解和熟练运用这些数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值