C++数据结构-实验4-查找和排序算法实现

最新推荐文章于 2023-11-11 23:11:58 发布
最新推荐文章于 2023-11-11 23:11:58 发布
阅读量2.1k 收藏 26
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hrd535523596/article/details/112506834
版权

实验四 查找和排序算法实现

1、各种排序算法的实现

用随机函数生成 16 个 2 位正整数(10~99)，实现插入排序、希尔排序、冒泡排序、
快速排序、选择排序、堆排序、二路归并排序等多种排序算法，输出排序中间过程、统
计关键字的比较次数和记录的移动次数。
比较次数和移动次数，其实我也不懂的，经供参考

#include<iostream>
#include<iomanip>
#include<cstdio>
using namespace std;
//插入排序，从数组下标1开始
void swap(int& a, int& b) {
    int t = a;
    a = b;
    b = t;
}
void show(int* a, int n) {
    for (int i = 1; i <= n; i++)
        cout << a[i] << " ";
    cout << endl;
}
//插入排序
void insertion_sort(int* a, int n) {
    int compare = 0, move = 0;
    for (int i = 2; i <= n; i++) {
        int key = a[i], j = i - 1;
        while (j > 0 && a[j] > key) {
            a[j + 1] = a[j];
            compare++;
            --j;
        }
        a[j + 1] = key;
        compare++;
        move++;
        cout << "第" << move << "次移动的中间过程:";
        show(a, n);
    }
    cout << "关键字的比较次数:" << compare << endl;
    cout << "记录的移动次数:" << 3 * move << endl;
}
//希尔排序，将待排序序列分为若干子序列（每个子序列的元素在原始数组中间距相同）；
//对这些子序列进行插入排序；减小每个子序列中元素之间的间距，重复上述过程直至间距减少为 1。
void shell_sort(int* a, int n) {
    int compare = 0, move = 0, cnt = 0, h = 1;
    while (h < n / 3) h = 3 * h + 1;
    while (h >= 1) {
        for (int i = h; i < n; i++) {
            for (int j = i; j >= h && a[j] < a[j - h]; j -= h) {
                compare++;
                swap(a[j], a[j - h]);
                move++;
            }
            cnt++;
            cout << "第" << cnt << "次移动的中间过程:";
            for (int i = 0; i < n; i++)cout << a[i] << " ";
            cout << endl;
        }
        h = h / 3;
    }
    cout << "关键字的比较次数:" << compare << endl;
    cout << "记录的移动次数:" << 3 * move << endl;
}
//冒泡排序，从数组下标1开始
//每次检查相邻两个元素，如果前面的元素与后面的元素满足给定的排序条件，就将相邻两个元素交换
void bubble_sort(int* a, int n) {
    int compare = 0, move = 0, flag = 1;
    while (flag) {
        flag = 0;
        for (int i = 1; i <= n - 1; i++) {
            if (a[i] > a[i + 1]) {
                flag = 1;
                swap(a[i], a[i + 1]);
                move++;
                cout << "第" << move << "次移动的中间过程:";
                show(a, n);
            }
            compare++;
        }
    }
    cout << "关键字的比较次数:" << compare << endl;
    cout << "记录的移动次数:" << 3 * move << endl;
}
//双向冒泡
void debubble_sort(int* a, int n) {
    int compare = 0, move = 0, cnt = 0;
    int left = 1, right = n,shift=1;
    while (left < right) {
        for (int i = left; i < right; i++) {
            if (a[i] > a[i + 1]) {
                swap(a[i], a[i + 1]);
                move++;
                shift = i;
            }
            compare++;
        }
        right = shift;
        for (int i = right - 1; i >= left; i--) {
            if (a[i] > a[i + 1]) {
                swap(a[i], a[i + 1]);
                move++;
                shift = i + 1;
            }
            compare++;
        }
        left = shift;
        cout << "第" << ++cnt << "次移动的中间过程:";
        show(a, 16);    
    }
    cout << "关键字的比较次数:" << compare << endl;
    cout << "记录的移动次数:" << 3 * move << endl;
}
//快速排序
//要把数列分成两个部分，可选择一个特殊下标的值为基准，然后保证前一个子数列中的数都小于后一个子数列中的数，即是可交换
//后再分成前后两个序列，而是在分的过程中要保证相对大小关系，分别进行快速排序，且不用合并，因为此时数列已经完全有序
int quick_sort_compare = 0, quick_sort_move = 0, quick_sort_cnt = 0;
void quick_sort(int* &a, int left, int right) {
    if (left >= right)return;
    int i = left, j = right, base = a[left];
    while (i < j) {
        while (a[j] >= base && i < j)j--, quick_sort_compare++;
        while (a[i] <= base && i < j)i++, quick_sort_compare++;
        if (i < j) {
            swap(a[i], a[j]);
            quick_sort_move++;
        }
    }
    a[left] = a[i];
    a[i] = base;
    cout << "第" << ++quick_sort_cnt << "次中间过程输出:";
    show(a, 16);
    quick_sort(a, left, i - 1);
    quick_sort(a, i + 1, right);
}
//选择排序，从数组下标1开始，每次找出第 i小的元素然后将这个元素与数组第 i个位置上的元素交换。
void selection_sort(int* a, int n) {
    int compare = 0, move = 0;
    for (int i = 1; i <= n - 1; i++) {
        int k = i;
        for (int j = i + 1; j <= n; j++) {
            if (a[j] < a[k]) {
                k = j;
            }
            compare++;
        }
        if (i != k) {
            swap(a[i], a[k]);
            move++;
            cout << "第" << move << "次移动的中间过程:";
            show(a, n);
        }
    }
    cout << "关键字的比较次数:" << compare << endl;
    cout << "记录的移动次数:" << 3 * move << endl;
}
//堆排序,从上往下把左右孩子和邻接根节点交换的成当前子树的根节点
int heap_sort_compare = 0, heap_sort_move = 0;
void max_heapmodify(int* a, int l, int r) {
    int fa = l, son = 2 * fa + 1, temp = a[l];
    while (son < r) {
        heap_sort_compare++;
        if (son + 1 < r && a[son] < a[son + 1])son++;
        heap_sort_compare++;
        if (a[son] < a[fa])return;   //子树中较大的节点都小于当前子树的根节点
        else {
            swap(a[son], a[fa]);  //子树中最大的节点与当前子树的根节点进行交换
            fa = son;             //转移根节点的下标到下一层
            son = fa * 2 + 1;
            cout << "第" << heap_sort_move++ << "次移动的中间过程:";
            for (int i = 0; i < 16; i++)cout << a[i] << " ";
            cout << endl;
        }
    }
}
//堆排序，利用 "堆" 这种数据结构所设计的一种排序算法
void heap_sort(int* a, int n) {
    //对原数列建大根堆
    for (int i = n / 2 - 1; i >= 0; i--)max_heapmodify(a, i, n);
    //逆序递减下标，交换堆顶元素下标为0和当前未再次调整堆最底的元素，再次重新向上调整
    for (int i = n - 1; i >= 1; i--) {
        swap(a[0], a[i]);
        max_heapmodify(a, 0, i);
    }
    //for (int i = 0; i < n; i++)cout << a[i] << " ";
    cout << "关键字的比较次数:" << heap_sort_compare << endl;
    cout << "记录的移动次数:" << 3 * heap_sort_move << endl;
}
//二路归并排序
//把数列分划为两部分，直到数列长度为1；递归地分别对两个子序列进行交换排序；再把当前已经排好序的数列合并成一个子序列
int merge_compare = 0, merge_move = 0, merge_cnt = 0, merge_ans = 0, t[17];
void merge(int*&a,int left, int right) {
    if (right - left <= 1) return;
    int mid = (left + right) / 2;
    //把数列分划为两部分
    merge(a,left, mid);
    merge(a,mid, right);
    cout << "第" << ++merge_cnt << "次中间过程输出:";
    show(a, 16);
    //递归地分别对两个子序列进行交换排序
    int p = left, q = mid, s = left;
    while (s < right) {
        if (p >= mid || (q < right && a[p] > a[q])) {
            t[s++] = a[q++];
            merge_ans += mid - p;
            merge_move++;
        }
        else t[s++] = a[p++];
        merge_compare++;
    }
    //再把当前已经排好序的数列合并成一个子序列
    for (int i = left; i < right; ++i) a[i] = t[i];
}

int main() {
    int* a = new int[18],*b=new int[18];
    for (int i = 1; i <= 16; i++) {
        a[i] = rand() % 90 + 10;
        b[i] = a[i];
    }
    cout << "插入排序：" << endl;
    insertion_sort(b, 16);
    cout << endl;
    
    for (int i = 0; i < 16; i++) b[i] = a[i+1];
    cout << "希尔排序：" << endl;
    shell_sort(b, 16);
    cout << endl;
    cout << "冒泡排序：" << endl;
    for (int i = 1; i <= 16; i++) b[i] = a[i];
    bubble_sort(b, 16);
    cout << endl;
    cout << "双向冒泡排序：" << endl;
    for (int i = 1; i <= 16; i++) b[i] = a[i];
    debubble_sort(b, 16);
    cout << endl;
    cout << "快速排序：" << endl;
    for (int i = 1; i <= 16; i++) b[i] = a[i];
    quick_sort(b,1,16);
    cout << "关键字的比较次数:" << quick_sort_compare << endl;
    cout << "记录的移动次数:" << 3 * quick_sort_move << endl;
    cout << endl;
    for (int i = 1; i <= 16; i++) b[i] = a[i];
    cout << "选择排序：" << endl;
    selection_sort(b, 16);
    cout << endl;
    cout << "堆排序：" << endl;
    for (int i = 0; i < 16; i++) b[i] = a[i + 1]; b[16] = 0;
    heap_sort(b, 16);
    cout << endl;
    cout << "二路归并排序：" << endl;
    for (int i = 1; i <= 16; i++) b[i] = a[i];
    merge(b, 1, 16);
    cout << "关键字的比较次数:" << merge_compare << endl;
    cout << "记录的移动次数:" << 3 * merge_move << endl;
    cout << "记录的逆序对的个数:" << merge_ans << endl;
	return 0;
}

2、各种查找算法实现

(1) 顺序查找：使用数组或链表结构。用随机函数生成 16 个不重复的字母(’a’~’z’)，
键盘输入待查找的字母，返回查找成功与否，若成功则返回该字母所在的位置(序号)，
并计算比较次数。
(2) 折半查找：用数组实现，查找前元素先排序。计算比较次数。分别用查找成功、
不成功进行测试。
(3) 二叉查找树：手工输入 10 个字母，生成一棵二叉查找树，用递归算法打印树结
构或分别输出先序和中序遍历序列以确认其结构。键盘输入待查找的字母，计算比较次
数，并删除该字母。分别用查找成功、不成功进行测试。

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
//顺序链表
struct List {
    char c;
    List* next;
}*head;
int compare = 0;
//判断数据tc是否在顺序链表中
bool inexistence(List*& head, char tc) {
    bool flag = true;
    List* list = head->next;
    while (list != NULL) {
        if (list->c == tc) {
            flag = false; break;
        }
        list = list->next;
    }
    return flag;
}
//顺序表初始化
void sequence_init(List*& head) {
    List* list = head;
    int cnt = 0;
    while (1) {
        char tc = 'a' + rand() % 26;
        if (inexistence(head, tc)) {
            List* node = new List();
            node->c = tc;
            list->next = node;
            list = node;
            cout << tc << " ";
            cnt++;
        }
        if (cnt >= 16) {
            break;
        }
    }
    list->next = NULL;
    cout << endl;
}
//顺序查找
bool sequence_search(List*& head, char tc) {
    List* list = head->next;
    bool flag = false;
    while (list != NULL) {
        compare++;
        if (list->c == tc) {
            flag = true; break;
        }
        list = list->next;
    }
    return flag;
}
//折半查找初始化
void binary_seacher_init(int*& a, int n) {
    for (int i = 1; i <= n; i++) {
        a[i] = rand() % 100 + 1;
        cout << a[i] << " ";
    }
    cout << endl;
}
//折半查找前需排序
void binary_seacher_sort(int*& a, int n) {
    for (int i = 1; i <= n - 1; i++) {
        int k = i;
        for (int j = i + 1; j <= n; j++)
            if (a[j] < a[k]) k = j;
        int temp = a[i];
        a[i] = a[k];
        a[k] = temp;
    }
    for (int i = 1; i <= n; i++)cout << a[i] << " ";
    cout << endl;
}
//折半查找
bool binary_search(int*& a, int n, int ta) {
    bool flag = false;
    int left = 1, right = n;
    while (left < right) {
        compare++;
        int mid = (left + right) >> 1;
        if (a[mid] == ta) {
            flag = true; break;
        }
        else if (a[mid] > ta) {
            right = mid - 1;
        }
        else if (a[mid] < ta) {
            left = mid + 1;
        }
    }
    return flag;
}

//二叉查找树
struct TreeNode {
    unsigned char c;
    TreeNode* left, * right;
    TreeNode() {
        left = NULL; right = NULL;
    }
    char getc() { return c; }
};
//二叉查找树插入数据
TreeNode* InsertTree(TreeNode*& T, unsigned char tc) {
    if (T == NULL) {
        TreeNode* tmpNode = new TreeNode();
        tmpNode->c = tc;
        T = tmpNode;
        return T;
    }
    else if (tc < T->c)
        T->left = InsertTree(T->left, tc);
    else if (tc > T->c)
        T->right = InsertTree(T->right, tc);
    return T;
}
//二叉查找树先序遍历
void PreOrder(TreeNode* T) {
    if (T != NULL) {
        cout << T->getc() << " ";
        PreOrder(T->left);
        PreOrder(T->right);
    }
}
//二叉查找树中序遍历
void InOrder(TreeNode* T) {
    if (T != NULL) {
        InOrder(T->left);
        cout << T->c << " ";
        InOrder(T->right);
    }
}
//二叉查找树后序遍历
void PostOrder(TreeNode* T) {
    if (T != NULL) {
        PostOrder(T->left);
        PostOrder(T->right);
        cout << T->c << " ";
    }
}
//二叉查找树查找某结点
TreeNode* binaryTree_search(TreeNode* T, unsigned char key) {
    compare++;
    if (T == NULL || T->c == key)return T;
    else if (T->c > key) return binaryTree_search(T->left, key);
    else return binaryTree_search(T->right, key);
    return T;
}
//二叉查找树查找某结点的父节点
TreeNode* binaryTree_search_father(TreeNode* T, TreeNode* fa, unsigned char key) {
    if (T == NULL || T->c == key)return fa;
    else if (T->c > key) return binaryTree_search_father(T->left, T, key);
    else return binaryTree_search_father(T->right, T, key);
}
//二叉查找树删除某结点(数据)
void binaryTree_remove(TreeNode*& T, unsigned char key) {
    TreeNode* p = binaryTree_search(T, key); //找到需要删除的当前节点
    TreeNode* fa = binaryTree_search_father(T, T, key); //找到需要删除当前节点的父节点
    if (p == NULL) {
        cout << "删除失败";
        return;
    }
    //左右子树都空
    if (p->left == NULL && p->right == NULL) {
        if (fa->left->c == p->c)fa->left = NULL;
        else fa->right = NULL;
        delete p;
    }
    //左子树空
    else if (p->left == NULL) {
        p->c = p->right->c;
        p->right = p->right->right;
    }
    //右子树空
    else if (p->right == NULL) {
        p->c = p->left->c;
        p->left = p->left->left;
    }
    //左右子树都不空
    else {
        TreeNode* pre = p, * node = p->left;
        //找到左子树中最右的节点
        while (node->right) {
            pre = node;
            node = node->right;
        }
        if (pre == p) {
            p->c = node->c;
            p->left = node->left;
        }
        else {
            pre->right = node->left;
            p->c = node->c;
        }
        delete node;
    }
    cout << "删除成功";
}
int main() {
    //链式顺序查找
    head = new List();
    head->next = NULL;
    cout << "顺序查询的原数组：";
    sequence_init(head);
    char tc = 'a';
    compare = 0;
    cout << "顺序查询\"" << tc << "\":";
    if (sequence_search(head, tc))
        cout << "存在，序号为：" << compare - 1 << "比较次数：" << compare;
    else cout << "不存在";
    cout << endl;
    tc = 'z';
    compare = 0;
    cout << "顺序查询\"" << tc << "\":";
    if (sequence_search(head, tc))
        cout << "存在，序号为：" << compare - 1 << "比较次数：" << compare;
    else cout << "不存在";
    cout << endl;
    cout << endl;

    //折半查找
    int* a = new int[11];
    cout << "折半查找的原数组：";
    binary_seacher_init(a, 10);
    cout << "折半查找排序后的数组：";
    binary_seacher_sort(a, 10);
    int ta = 22;
    compare = 0;
    cout << "折半查找\"" << ta << "\":";
    if (binary_search(a, 10, ta))
        cout << "存在，比较次数：" << compare;
    else cout << "不存在";
    cout << endl;
    ta = 24;
    compare = 0;
    cout << "折半查找\"" << ta << "\":";
    if (binary_search(a, 10, ta))
        cout << "存在";
    else cout << "不存在";
    cout << endl;
    cout << endl;

    //二叉查找树
    //tree = new TreeNode();
    TreeNode* tree = NULL;
    cout << "输出原始字符数据：";
    //初始化二叉查找树
    for (int i = 0; i < 10; i++) {
        char c = char('a' + rand() % 26);
        cout << c << " ";
        InsertTree(tree, c);
    }
    cout << endl;
    cout << "二叉查找树先序遍历：";
    PreOrder(tree);
    cout << endl;
    cout << "二叉查找树中序遍历：";
    InOrder(tree);
    cout << endl;
    cout << "二叉查找树后序遍历：";
    PostOrder(tree);
    cout << endl;
    char key = 'b';    compare = 0;
    cout << "待查找的字符" << key << "：";
    if (binaryTree_search(tree, key))
        cout << "存在，比较次数：" << compare;
    else cout << "不存在";
    cout << endl;
    key = 'd';     compare = 0;
    cout << "待查找的字符" << key << "：";
    if (binaryTree_search(tree, key))
        cout << "存在，比较次数：" << compare;
    else cout << "不存在";
    cout << endl;
    key = 'n';
    cout << "待删除的字符" << key << "：";
    binaryTree_remove(tree, key);
    cout << endl;
    cout << "二叉查找树删除后的先序遍历：";
    PreOrder(tree);
    cout << endl;
    key = 'a';
    cout << "待删除的字符" << key << "：";
    binaryTree_remove(tree, key);
    cout << endl;
    cout << "二叉查找树删除后的先序遍历：";
    PreOrder(tree);
    cout << endl;
    return 0;
}
丶di
关注
专栏目录
广州大学 数据结构实验报告 实验四 查找和排序算法实现
05-23
实验四 查找和排序算法实现 1、各种排序算法的实现 2、各种查找算法实现 1、各种排序算法的实现 用随机函数生成16个2位正整数（10~99），实现插入排序、选择排序、冒泡排序、双向冒泡、快速排序、二路归并排序等多种排序算法，输出排序中间过程、统计关键字的比较次数和记录的移动次数。
[源码和文档分享]基于C++实现的二叉排序树
qq_38474647的博客
12-11 211
一、使用说明 1.1 项目简介 依次输入关键字并建立二叉排序树，实现二叉排序树的插入和查找功能。 1.2 项目功能要求 二叉排序树就是指将原来已有的数据根据大小构成一棵二叉树，二叉树中的所有结点数据满足一定的大小关系，所有的左子树中的结点均比根结点小，所有的右子树的结点均比根结点大。 二叉排序树查找是指按照二...
【数据结构】查找和排序算法实现
weixin_51633776的博客
12-09 2460
一、实验目的： 1、各种排序算法的实现 2、各种查找算法实现 二、使用仪器、器材 微机一台 操作系统：WinXP 编程软件：C++ 三、实验内容及原理 实验内容： 1、各种排序算法的实现 用随机函数生成16个2位正整数（10~99），实现插入排序、选择排序、冒泡排序、双向冒泡、快速排序、二路归并排序等多种排序算法，输出排序中间过程、统计关键字的比较次数和记录的移动次数。 各种查找算法实现 （1）顺序查找：使用数组或链表结构。用随机函数生成16个不重复的字母（’a’~’z’），键盘输入待
广州大学数据结构实验报告四《查找和排序算法实现》
最新发布
Software_Star的博客
11-11 1113
广州大学数据结构实验完整报告，包含错误调试过程。
C++实现二叉排序树
Jinyao的博客
12-20 923
C++实现二叉排序树 1.定义 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； ...
(完整word版)数据结构实验-排序算法C++实现.doc
11-16
排序算法 C++ 实现实验报告 本实验报告的主要目的是学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。实验内容包括使用简单数组实现各种排序算法，并进行比较。 一、实验要求 1.1...
数据结构实验报告-查找与排序算法22.doc
07-28
数据结构实验报告-查找与排序算法 本实验报告的主要目的是为了掌握顺序表的查找算法、冒泡排序算法、折半查找算法、选择排序算法等基本算法，并通过 C++ 语言编写实现这些算法。 一、顺序表的查找算法 顺序表的...
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中的一部分，它提供了丰富的容器、迭代器、算法和函数对象等组件，极大地简化了数据结构和算法的实现。余文溪的《C++ STL--数据结构与算法...
C++数据结构实验五：查找排序
01-16
一．实验项目要求 实验目的： 1．掌握哈希表的定义，哈希函数的构造方法。 2．掌握并比较各种排序算法。...2、排序：分别按学生的学号、成绩进行排序（要求至少用实现直接插入排序、冒泡排序、简单选择排序算法）。
数据结构——排序查找算法实现
langtaol的成长记
08-18 1701
前面转载了一篇讲排序算法的文章，这几天将排序和查找算法进行了实现，在这里贴出代码来。
数据结构--实验四:查找和排序
OMTE910的博客
12-09 878
一、顺序查找、快速排序、二分查找 #include<stdio.h> #include<stdlib.h> #define MAXSIZE 1000 struct LNode{ int Data[MAXSIZE]; //Data为待排序序列数组 int Last; //Last为最后一个元素的数组下标 }; typedef struct LNode *List; //void quicksort(List L,int Left,int Right); List
数据结构-排序算法（C语言实现）
m0_69597277的博客
04-17 673
排序稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。编译环境：vs2013对于所有排序，统一以数组array[size-1]为待排序对象。
C++ 实现二叉排序树（二叉查找树）
qq_41220807的博客
06-15 3663
C++ 实现二叉排序树（二叉查找树） 二叉排序树( Binary Sort Tree)，又称为二叉查找树。它或者是一棵空树，或者是具有下列性质的二叉树。 若它的左子树不空，则左子树上所有结点的值均小于它的根结构的值; 若它的右子树不空，则右子树上所有结点的值均大于宫的根结点的值; 它的左、右子树也分别为二叉排序树。 查找、插入与生成操作 #include <iostream&...
【C++】数据结构-二叉树之二叉排序树的查找
孑然的个人博客
12-12 2103
一、 实验题目 1、应用随机函数生成100个随机数，数据控制在1-1000之间，并保存到一个数组中。 2、在上一题的基础上，编写代码实现二分查找，例如对用户输入的某个数据，能够进行二分查找，显示找到或没找到，如果找到，请给出查找时的比较次数。 3、在第1题的基础上，编写代码实现二叉排序树的创建，并输出中序遍历该二叉排序树的结果。 4、在第3题的基础上，编写代码实现二叉排序树上的查找，例如对用户输入的某个数据，能够进行查找，显示找到或没找到，如果找到，请给出查找时的比较次数。 头文件的定义： #inclu
c++实现顺序查找，折半查找
Baron_ccy
07-21 3547
#include #include using namespace std; #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int typedef struct{ ElemType *elem; int length; int listsize; }SqList; //建顺序表 void Ini
数据结构之查找（顺序查找、折半查找）
weixin_44835249的博客
05-16 7745
相关概念： 关键字：关键字是数据元素中某给数据项的值，用来标识一个数据元素（具有一定的辨识功能）。 主关键字：可以识别唯一的一个数据元素的关键字； 次关键字：能识别若干记录的关键字。 查找：给定一个值，在查找表中确定一个其关键字与给定值得数据元素（或记录）。 查找包含有一下几种操做： 1、查询某个“特定”的数据元素是否在查找表当中； 2、检索某个“特定”的数据元素的相关属性； 3、在查找中插入数据...
C++ 数据结构 二叉排序树/二叉查找树
weixin_44062380的博客
06-16 3323
数据结构 二叉排序树前言概念介绍二叉排序树存在意义的思考操作以及代码展示插入元素查找元素删除元素二叉排序树的优缺点及解决方法优点缺点解决方案 前言 今天在学习红黑树的时候，看到了引导课拿二叉排序树举例，想到之前还没写过二叉排序树的代码，所以这次特地写了一下，这里把二叉排序树的性质和写代码时出现的问题做一个分享。 概念 介绍 在写之前，要先了解什么是二叉排序树 二叉查找树，它有一个根节点，且每个节点下最多有只能有两个子节点，左子节点的值小于其父节点，右子节点的值大于其父节点。 我们依次插入数据：43,98,
查找算法--二叉排序树算法（C++实现完整代码）
weixin_45482422的博客
08-31 1438
如下图所示是某个排序二叉树，什么是排序二叉树？。。。 下面的算法实现的是查找某个关键字是否在这棵树上的某个节点中。算法分为俩个部分，第一部分为二叉排序树的创建，第二部分是二叉排序树查找算法； #include <iostream> using namespace std; typedef struct BTNode { int key; struct BTNode *lchild; struct BTNode *rchild; }BTNode; void createBST(BTNode
数据结构与算法(Python语言)----顺序查找
redrose2100的博客
01-11 565
顺序查找 顺序查找，也叫线性查找，从列表第一个元素开始，顺序进行搜索，直到找到元素或搜索到列表最后一个元素为止 顺序查找代码 def linear_search(li,value): for index,val in enumerate(li): if val==value: return index return None if __name__=="__main__": li=[1,2,3,4,5,6,7,8,9,0] inde
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值