数据结构 - 排序与查找

最新推荐文章于 2022-05-31 10:18:33 发布
最新推荐文章于 2022-05-31 10:18:33 发布
阅读量315 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haoke_cn/article/details/110449837
版权

文章目录

使用场景

了解各个排序的特性，针对排序好的序列进行查找

稳定排序

C 实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define swap(a, b) { \
    a ^= b; b ^= a; a ^= b; \
}

// 宏书写，方便测试
#define TEST(arr, n, func, args...) { \
    int *num = (int *) malloc(sizeof(int) * n); \
    memcpy(num, arr, sizeof(int) * n); \
    output(num, n); \
    printf("%s= ", #func); \
    func(args); \
    output(num, n); \
    free(num); \
}

// O(N^2)
void insert_sort(int *num, int n) {
    for (int i = 1; i < n; ++i) {
        for (int j = i; j > 0 && num[j] < num[j - 1]; --j) {
            swap(num[j], num[j - 1]);
        }
    }
    return ;
}

// O(N^2)
void bubble_sort(int *num, int n) {
    int times = 1;
    for (int i = 1; i < n && times; i++) {
    	// 帮助提前退出
        times = 0;
        for (int j = 0; j < n - i; ++j) {
            if (num[j] <= num[j + 1]) continue;
            swap(num[j], num[j + 1]);
            times++;
        }
    }
    return;
}

// O(NlgN) S(N)
void merge_sort(int *num, int l, int r) {
    // 递归条件
    if (r - l <= 1) {
        if (r - l == 1 && num[r] < num[l]) {
            swap(num[r], num[l]);
        }
        return;
    }
    int mid = (l + r) / 2;
    merge_sort(num, l, mid);
    merge_sort(num, mid + 1, r);
    int *temp = (int *) malloc(sizeof(int) * (r - l + 1));
    int p1 = l, p2 = mid + 1, k = 0;
    // 左右两块肯定都没到头
    while (p1 <= mid || p2 <= r) {
        if (p2 > r || (p1 <= mid && num[p1] < num[p2])) {
            temp[k++] = num[p1++];
        } else {
            temp[k++] = num[p2++];
        }
    }
    memcpy(num + l, temp, sizeof(int) * (r - l + 1));
    free(temp);
    return;
}

void randint(int *num, int n) {
    while (n--) num[n] = rand() % 100;
    return;
}

void output(int *num, int n) {
    printf("[");
    for (int i = 0; i < n; ++i) {
        printf("%d ", num[i]);
    }
    printf("]\n");
    return;
}

int main() {
	// 演示
    srand(time(0));
    #define max_n 20
    int arr[max_n];
    randint(arr, max_n);
    TEST(arr, max_n, insert_sort, num, max_n);
    TEST(arr, max_n, bubble_sort, num, max_n);
    TEST(arr, max_n, merge_sort, num, 0, max_n - 1);
    #undef max_n
    return 0;
}

C++ 实现

class Vector {
private:
    int size, length;
    int *data;
public:
    Vector(int input_size) {
        size = input_size;
        length = 0;
        data = new int[size];
    }
    ~Vector() {
        delete[] data;
    }
    bool insert(int loc, int value) {
        if (loc < 0 || loc > length) {
            return false;
        }
        if (length >= size) {
            return false;
        }
        for (int i = length; i > loc; --i) {
            data[i] = data[i - 1];
        }
        data[loc] = value;
        length++;
        return true;
    }
    void print() {
        for (int i = 0; i < length; ++i) {
            if (i > 0) {
                cout << " ";
            }
            cout << data[i];
        }
        cout << endl;
    }
    void insert_sort() {
		for (int i = 0; i < length; ++i) {
            for (int j = i - 1; j >= 0; --j) {
                if (data[j] > data[j + 1]) {
                    swap(data[j], data[j + 1]);
                } else {
                    break;
                }
            }
        }
	}
	void bubble_sort() {
        for (int i = 0; i < length - 1; ++i) {
            bool swapped = false;
            for (int j = 0; j < length - i - 1; ++j) {
                if (data[j] > data[j + 1]) {
                    swap(data[j], data[j + 1]);
                    swapped = true;
                }
            }
            if (swapped == false) {
                break;
            }
        }
    }
    void merge_sort(int l, int r) {
        if (l == r) {
            return;
        }
        int mid = (l + r) / 2;
        merge_sort(l, mid);
        merge_sort(mid + 1, r);
        int x = l, y = mid + 1, loc = l;
        while (x <= mid || y <= r) {
            if (x <= mid && (y > r || data[x] <= data[y])) {
                temp[loc] = data[x];
                x++;
            } else {
                temp[loc] = data[y];
                y++;
            }
            loc++;
        }
        for (int i = l; i <= r; ++i) {
            data[i] = temp[i];
        }
    }
}

不稳定排序

排序后原来等值元素前后顺序不一定保持

C 实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define swap(a, b) { \
    __typeof(a) __temp = a; \
    a = b; b = __temp; \
}

#define TEST(arr, n, func, args...) { \
    int *num = (int *) malloc(sizeof(int) * n); \
    memcpy(num, arr, sizeof(int) * n); \
    output(num, n); \
    printf("%s=", #func); \
    func(args); \
    output(num, n); \
    free(num); \
}

// O(N^2)
void select_sort(int *num, int n) {
    for (int i = 0; i < n - 1; ++i) {
        int ind = i;
        for (int j = i + 1; j < n; ++j) {
            if (num[ind] > num[j]) ind = j;
        }
        swap(num[i], num[ind]);
    }
    return;
}

// O(NlgN) S(lgN) 使用栈空间
// 选头个元素为枢轴，逆序的情况下会退化，时间复杂度 O(N^2)
// 枢轴可以选随机
void quick_sort(int *num, int l, int r) {
    if (l > r) return;
    int x = l, y = r, z = num[x];
    while (x < y) {
        while(x < y && num[y] > z) y--;
        if (x < y) num[x++] = num[y];
        while(x < y && num[x] < z) x++;
        if (x < y) num[y--] = num[x];
    }
    num[x] = z;
    quick_sort(num, l, x - 1);
    quick_sort(num, x + 1, r);
    return;
}

// 快速排序另外一种写法，逆序情况下优化
void quick_sort(int *num, int l, int r) {
    while (l < r) {
        int x = l, y = r, z = num[(l + r) / 2];
        do {
            while (x <= y && num[x] < z) x++;
            while (x <= y && num[y] > z) y--;
            if (x <= y) {
                swap(num[x], num[y]);
                x++, y--;
            }
        } while (x <= y);
        quick_sort(num, x, r); // 这里右边继续划分
        r = y; // 左边继续划分 
    }
    return ;
}

void randint(int *num, int n) {
    while (n--) num[n] = rand() % 100;
    return;
}

void output(int *num, int n) {
    printf("[");
    for (int i = 0; i < n; ++i) {
        printf("%d ", num[i]);
    }
    printf("]\n");
    return;
}

int main() {
    srand(time(0));
    #define max_n 20
    int arr[max_n];
    randint(arr, max_n);
    TEST(arr, max_n, select_sort, num, max_n);
    TEST(arr, max_n, quick_sort, num, 0, max_n - 1);
    #undef max_n
    return 0;
}

C++ 实现

class Vector {
private:
    int size, length;
    int *data;
public:
    Vector(int input_size) {
        size = input_size;
        length = 0;
        data = new int[size];
    }
    ~Vector() {
        delete[] data;
    }
    bool insert(int loc, int value) {
        if (loc < 0 || loc > length) {
            return false;
        }
        if (length >= size) {
            return false;
        }
        for (int i = length; i > loc; --i) {
            data[i] = data[i - 1];
        }
        data[loc] = value;
        length++;
        return true;
    }
    void print() {
        for (int i = 0; i < length; ++i) {
            if (i > 0) {
                cout << " ";
            }
            cout << data[i];
        }
        cout << endl;
    }
    void select_sort() {
        int temp;
        for (int i = 0; i < length - 1; ++i) {
            temp = i;
            for (int j = i + 1; j < length; ++j) {
                if (data[temp] > data[j]) {
                    temp = j;
                }
            }
            if (i != temp) {
                swap(data[i], data[temp]);
            }
        }
    }
	void quick_sort(int left, int right) {
        if (left > right) {
            return;
        }
        int pivot = data[left], low = left, high = right;
		while (low < high) {
            while (low < high && data[high] >= pivot) {
                high--;
            }
            data[low] = data[high];
            while (low < high && data[low] <= pivot) {
                low++;
            }
            data[high] = data[low];
        }
        data[low] = pivot;
        quick_sort(left, low - 1);
        quick_sort(low + 1, right);
    }
};

查找

主要是二分查找，1100 情况（小于目标元素的最大值），0011 情况 （大于目标元素的最小值）

三分查找对于凸性函数序列找最大值或者最小值

C 语言实现

#include <stdio.h>

#define P(func) { \
    printf("%s = %d\n", #func, func); \
}

int binary_search1(int *num, int n, int x) {
    int head = 0, tail = n - 1, mid;
    while (head <= tail) {
        mid = (head + tail) >> 1;
        if (num[mid] == x) return mid;
        if (num[mid] < x) head = mid + 1;
        else tail = mid - 1;
    }
    return -1;
}

// 111111000000
int binary_search2(int *num, int n) {
    int head = -1, tail = n - 1, mid;
    while (head < tail) {
        mid = (head + tail + 1) >> 1;
        if (num[mid] == 1) head = mid;
        else tail = mid - 1;
    }
    return head;
}

// 000000111111
int binary_search3(int *num, int n) {
    int head = 0, tail = n, mid;
    while (head < tail) {
        mid = (head + tail) / 2;
        if (num[mid] == 1) tail = mid;
        else head = mid + 1;
    }
    return head == n ? -1 : head;
}

int main() {
    int arr1[10] = {1,3,5,7,9,11,13,17,19,20};
    int arr2[10] = {1,1,1,1,0,0,0,0,0,0};
    int arr3[10] = {0,0,0,0,0,1,1,1,1,1};
    P(binary_search1(arr1, 10, 7));
    P(binary_search2(arr2, 10));
    P(binary_search3(arr3, 10));
    return 0;
}

C++ 实现

class Vector {
private:
    int size, length;
    int *data;
public:
    Vector(int input_size) {
        size = input_size;
        length = 0;
        data = new int[size];
    }
    ~Vector() {
        delete[] data;
    }
    bool insert(int loc, const int &value) {
        if (loc < 0 || loc > length) {
            return false;
        }
        if (length >= size) {
            return false;
        }
        for (int i = length; i > loc; --i) {
            data[i] = data[i - 1];
        }
        data[loc] = value;
        length++;
        return true;
    }
    // 三分查找
	int find_max() {
        int left = 0, right = length - 1;
        while (right - left >= 2) {
            int m1 = left + (right - left) / 3;
            int m2 = right - (right - left + 2) / 3;
            // 结合图
            if (data[m1] >= data[m2]) {
                right = m2;
            } else {
                left = m1 + 1;
            }
        }
        if (data[left] > data[right]) {
            return left;
        } else {
            return right;
        }
    }
};
haoke_cn
关注
专栏目录
数据结构4--查找和排序
木槿花开
11-28 546
1.顺序查找 顺序查找是最基本的查找顺序，时间复杂度为O(n)，查找过程为：从表中第一个元素开始按顺序逐个进行遍历，若查找到记录则返回，若直到最后一个没有查到，则查找失败。 2.二分查找 折半查找（Binary Search）技术，又称为二分查找，它的前提是线性表中的记录必须是关键码有序（通常从小到大有序），线性表必须采用顺序存储，其时间复杂度为O(logn)。 基本思想：在有序表中，
数据结构课程设计--排序与查找.doc
06-30
"数据结构课程设计--排序与查找" 本课程设计的主要目的是通过实践使学生对各种排序算法和查找算法有更深入的了解，并学会使用这些算法解决实际问题。课程设计的内容包括使用不同的排序算法对随机产生的20个整数进行...
数据结构 排序和查找
weixin_34380781的博客
06-17 99
#include <stdio.h> #include <stdlib.h> #include <time.h> const int ITEMNUM = 100; #define ElemType int //冒泡排序 void Bubblesort(ElemType R[],int n,int &a...
数据结构 | 5. 排序与查找
明朗晨光的专栏
10-03 649
排序算法可以有几种分类方式，根据 是否稳定 可以分为 稳定排序 和 不稳定排序；如果输入的数据全部都要装入内存进行排序就是 内部排序，而如果数据量太大装不进内存，必须在磁盘或磁带上完成的排序叫做 外部排序。 例如，有一份30G大小的数据，程序运行需要加载到内存中，冒泡和插入排序都是内部排序，假设内存只有16G，所以使用冒泡和插入加载不了，于是要使用外部排序——归并排序，先将15G加载到内存中，排完序后将数据放到磁盘中，再加载另外的15G数据到内存中进行排序。 1、稳定排序（插入、冒泡、归并） 1.1 插入排
数据结构中的排序和查找
梁凉的博客
06-16 479
数据结构中算法 选择排序 简单选择排序 private static void SelectionSort(int[] numbers, int length) { for (int i = 0; i < length - 1; i++) { int temp = i; for (int j = i + 1; j < length; j++) if (numbers[j] < numbers[temp]) temp = j;
[数据结构] 4. 排序与查找
savior
11-23 283
排序与查找
汽车牌照的排序与查找问题-数据结构与算法课程设计报告.pdf
11-04
汽车牌照的排序与查找问题-数据结构与算法课程设计报告.pdf 这篇报告主要是关于汽车牌照的排序与查找问题，使用数据结构与算法来实现对汽车牌照的排序和快速查找。报告中首先对问题进行了分析和任务定义，然后选择...
数据结构实验报告-查找与排序算法17.doc
07-28
数据结构实验报告-查找与排序算法17.doc 本实验报告涵盖了数据结构中两个重要的知识点：查找算法和排序算法。通过实验，学生可以掌握顺序表的查找算法、冒泡排序算法、折半查找算法和选择排序算法等。 一、顺序表...
哈工大-数据结构与算法-实验作业5 查找结构与排序方法.zip
最新发布
06-01
在这个哈工大的课程实验作业中，主题聚焦在查找结构与排序方法，这些都是数据结构与算法领域的核心概念。实验作业通常旨在让学生通过实践来深入理解这些理论知识。 查找结构是数据存储和检索的关键组成部分。常见的...
数据结构-知识点-查找.pdf
08-22
在计算机科学中，数据结构是...总结来说，查找和排序是数据结构中核心的内容，它们对于数据的操作和处理有着重要的意义。掌握各种查找和排序算法的特点、效率和适用场景，对于软件开发和数据处理有着极其重要的作用。
数据结构经典算法-多种排序和查找
12-03
用数据结构的经典算法-查找折半，直接。排序有冒泡，希尔，快速，堆排序等都是必须知道的。本程序将上面所有的算法都结合在一起。并且以成绩查询系统将其全部实现。本程序全部以C++编写。
数据结构 作业报告 实验5查找排序 源代码
06-11
数据结构 作业报告 实验5查找排序 源代码 自己认真做的作业 希望对大家有帮助！
数据结构：查找与排序
Zengqh-0417
04-28 877
查找 查找的基本概念 查找是指，在数据结构中寻找满足给定条件的数据元素，也成为检索或搜索 1.查找条件、查找操作和查找结果 查找条件：数据元素（包含关键字key）。 查找操作：比较元素相等，T类的equals(Object) 查找结果：查找成功，查找不成功。 表现形式： 如果判断数据结构是否包含某个特定元素，则查找结果为是/否两种状态 如果根据关键字查找以期望获得特定元素的其他属性，则查找结果为特定元素 如果数据结构中包含多个关键字相同的数据元素，那么，还需要约定是否返回首次出现的元素或者是返回元素集合等
数据结构之查找与排序
weixin_45990434的博客
09-22 2308
数据结构中的排序方法 冒泡排序 冒泡排序要对一个列表多次重复遍历。它要比较相邻的两项，并且交换顺序排错的项。每对列表实行一次遍历，就有一个最大项排在了正确的位置。大体上讲，列表的每一个数据项都会在其相应的位置“冒泡”。 它们的顺序是否正确。如果列表有n项，第一次遍历就要比较n-1对数据。需要注意，一旦列表中最大（按照规定的原则定义大小）的数据是所比较的数据对中的一个，它就会沿着列表一直后移，直到这次遍历结束。 说人话：每次比较一个数的左右两项，直到将最大值放在最后（或者将最小值放在最前面）。 不管
数据结构之排序和查找
测试
01-06 272
最近要忙于找实习找工作了，复习下数据结构基础，列出了常见排序和查找快速排序快速排序是一种不稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动该方法的基本思想是： 1．先从数列中取出一个数作为基准数。 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。 3．再对左右区间重复第二步，直到各区间只有一个数。 以一个数组作...
【数据结构】排序和查找
黑猫几绛的博客
05-31 449
排序算法 稳定排序 稳定与非稳定指的是：在一串数列中，…ai…aj…，ai==aj，在经过排序后，他俩的相对位置不变，则为稳定排序。 插入排序 将我们的整个待排序数组分成两个区域，一个叫已排序区，一个叫待排序区。 已排序区在前方，待排序区在后方。 每次将待排序区中的第一个元素取出来，在已排序区中进行比较，逐个交换位置，找到符合条件的位置进行放入。 形象点可以理解为： 一个人排队的时候一直往前拱，每次拱的时候，正前方那位向后移动一位（交换）。 遇到老大哥的时候害怕了不敢继续往前了，于是就在那呆着了。 举例
再谈数据结构（四）：排序与查找
HHH_ANS的博客
12-12 390
1 - 引言 虽然C++中的STL库中提供了许多排序和查找的方法。但是我们还是需要了解一下排序和查找内部的原理，下面让我们学习一下各类排序与查找算法 2 - 归并排序 第一种高效的排序算法是归并排序,按照分治三步法，对归并排序算法介绍如下： 划分问题：把序列分成元素个数尽量相等的两半。 递归求解：把两半元素分别排序 合并问题：把两个有序表合并成一个 前两部分是很容易完成的，关键在于如何把两个有...
数据结构与算法--查找与排序（一）
热门推荐
opera95的博客
04-22 1万+
Top 线性查找二分查找冒泡排序插入排序选择排序快速排序归并排序 1 线性查找 1.1 问题 线性查找，又称为顺序查找，是指在所有给定的值中从一端开始逐个检查每个元素是否为要查找的对象，直到找到为止的过程。 1.2 步骤 实现此案例需要按照如下步骤进行。 步骤一：逐个查找要查找的对象 代码如下： #include stdio.h>typ
数据结构之排序查找
qaz540411484的专栏
04-18 369
主要介绍二分查找，插值查找，斐波那契查找，起泡排序，归并排序 算法描述请见注释 归并排序算法描述可以参考http://www.cnblogs.com/jillzhang/archive/2007/09/16/894936.html/** * 数组结构 * 先排序，后查找 * @author asdc * */ public class Array { public final
数据结构-有序表查找详解
"有序表查找-数据结构讲义" 这篇讲义主要涵盖了数据结构中的有序表查找技术。有序表查找是一种在已排序的数据序列中寻找特定元素的算法，它利用了序列的有序性来提高查找效率。以下是相关知识点的详细说明： **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值