数据结构查找排序代码部分总结

已于 2023-09-07 16:03:14 修改
阅读量1.5k 收藏 16
点赞数 9
文章标签： 数据结构 排序算法 算法
于 2021-12-08 21:54:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kanzwienhoff/article/details/121801746
版权

数据结构查找排序代码部分总结

折半查找和顺序查找

三种简单排序

冒泡排序

//冒泡排序
void BubblSort(int arr[],int length)
{
    for(int i=0; i<length-1; i++)
    {
        for(int j=0; j<length-i; j++)
        {
            if(arr[j]>arr[j+1])
            {
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }

    }
}

选择排序

//选择排序
void SelectSort(int arr[],int length)
{
    while(length>1)
    {
        int Count=findMax(arr,length);
        int temp=arr[Count];
        arr[Count]=arr[length-1];
        arr[length-1]=temp;
        length--;
    }
}

插入排序

//插入排序
void Insert(int arr[],int n)
{
    int key=arr[n];
    int i=n;
    while(key<arr[i-1])
    {
        arr[i]=arr[i-1];
        i--;
        if(i==0)
        {
            break;
        }
    }
    arr[i]=key;
}

void InsertSort(int arr[],int length)
{
    for(int i=1;i<length;i++)
    {
        Insert(arr,i);
    }
}

完整代码

#include <iostream>

using namespace std;

template <typename T>//类模板 用来自适应传入形参的类型

//获取数组长度
int length(T& arr)
{
    return sizeof(arr)/sizeof(arr[0]);
}

//冒泡排序
void BubblSort(int arr[],int length)
{
    for(int i=0; i<length-1; i++)
    {
        for(int j=0; j<length-i; j++)
        {
            if(arr[j]>arr[j+1])
            {
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }

    }
}

//寻找最大值
int findMax(int arr[],int length)
{
    int Max=arr[0];
    int Count;
    for(int i=0;i<length;i++)
    {
        if(arr[i]>=Max)
        {
            Max=arr[i];
            Count=i;
        }

    }
    return Count;
}

//选择排序
void SelectSort(int arr[],int length)
{
    while(length>1)
    {
        int Count=findMax(arr,length);
        int temp=arr[Count];
        arr[Count]=arr[length-1];
        arr[length-1]=temp;
        length--;
    }
}

//插入排序
void Insert(int arr[],int n)
{
    int key=arr[n];
    int i=n;
    while(key<arr[i-1])
    {
        arr[i]=arr[i-1];
        i--;
        if(i==0)
        {
            break;
        }
    }
    arr[i]=key;
}

void InsertSort(int arr[],int length)
{
    for(int i=1;i<length;i++)
    {
        Insert(arr,i);
    }
}

int main()
{
    int arr[]= {5,6,0,2,1,9};
    SelectSort(arr,length(arr));
    cout<<length(arr)<<endl;
    for(int i=0;i<length(arr);i++)
    {
        cout<<arr[i]<<" ";
    }
    return 0;
}

折半查找和顺序查找

折半查找

//折半查找（只能顺序表，因为顺序表可以随机存储）
int BinarySearch(int arr[],int length,int e)
{
    int index=-1;
    int low=0;
    int high=length-1;
    while(low<=high)
    {
        int Mid=(low+high)/2;
        if(arr[Mid]>e)
        {
            high=Mid-1;
        }
        if(arr[Mid]<e)
        {
            low=Mid+1;
        }
        if(arr[Mid]==e)
        {
            index=Mid;
            break;
        }
    }
    return index;
}

顺序查找

//顺序查找（顺序表链表都可）
int Search(int arr[],int length,int e)
{
    int index=-1;
    for(int i=0; i<length; i++)
    {
        if(arr[i]==e)
        {
            index=i;
        }
    }
    return index;//注:这里并没有实现数组中出现相同元素时，循环输出位置
}

完整代码

#include <iostream>

/*
本代码仅仅为两种查找方式的思想，做题时应结合顺序表链表和树的结构定义
写出对应类型的代码
*/

using namespace std;

template<typename T>

int getLength(T& arr)
{
    return sizeof(arr)/sizeof(arr[0]);
}

//顺序查找（顺序表链表都可）
int Search(int arr[],int length,int e)
{
    int index=-1;
    for(int i=0; i<length; i++)
    {
        if(arr[i]==e)
        {
            index=i;
        }
    }
    return index;//注:这里并没有实现数组中出现相同元素时，循环输出位置
}

//折半查找（只能顺序表，因为顺序表可以随机存储）
int BinarySearch(int arr[],int length,int e)
{
    int index=-1;
    int low=0;
    int high=length-1;
    while(low<=high)
    {
        int Mid=(low+high)/2;
        if(arr[Mid]>e)
        {
            high=Mid-1;
        }
        if(arr[Mid]<e)
        {
            low=Mid+1;
        }
        if(arr[Mid]==e)
        {
            index=Mid;
            break;
        }
    }
    return index;
}

int main()
{
    int arr[]= {11,22,55,57,64,67,97,99};
    cout<<Search(arr,getLength(arr),99);
    return 0;
}

希尔排序和折半插入排序

希尔排序

//希尔排序
void ShellSort(int arr[],int n)
{
    for(int d=n/2;d>=1;d/=2)
    {
        for(int i=d;i<n;i++)
        {
            if(arr[i-d]>arr[i])
            {
                int j;
                int temp=arr[i];
                for(j=i-d;j>=0&&arr[j]>temp;j-=d)
                {
                    arr[j+d]=arr[j];
                }
                arr[j+d]=temp;
            }
        }
    }
}

折半插入排序

//折半插入排序
void BinaryInsertSort(int arr[],int n)
{
    for(int i=1; i<n; i++)
    {
        int key=arr[i];
        int Left=0;
        int Right=i-1;
        while(Left<=Right)
        {
            int Mid=(Right+Left)/2;
            if(arr[Mid]<key)
            {
                Left=Mid+1;            
            }
            else
            {
                Right=Mid-1;
            }
        }
        for(int j=i-1; j>Right; j--)
        {
            arr[j+1]=arr[j];
        }
        arr[Right+1]=key;
    }
}

完整代码

#include <iostream>

using namespace std;

template<typename T>
//获取数组长度
/*这里为什么加引用(普通函数里数组会退化成指针，传的是数组地址。
模板函数里加上‘&’后就可以把整个数组传进来了)
*/
int getLength(T& arr)
{
    return sizeof(arr)/sizeof(arr[0]);
}

//折半插入排序
void BinaryInsertSort(int arr[],int n)
{
    for(int i=1; i<n; i++)
    {
        int key=arr[i];
        int Left=0;
        int Right=i-1;
        while(Left<=Right)
        {
            int Mid=(Right+Left)/2;
            if(arr[Mid]<key)
            {
                Left=Mid+1;            }
            else
            {
                Right=Mid-1;
            }
        }
        for(int j=i-1; j>Right; j--)
        {
            arr[j+1]=arr[j];
        }
        arr[Right+1]=key;
    }
}

//希尔排序
/*
函数内千万不能调用getlength函数，因为数组在是以地址的方式传进
普通函数内的，所以根本得不到数组的长度
简而言之：普通函数内的数组不能使用sizeof
*/
void ShellSort(int arr[],int n)
{
    for(int d=n/2;d>=1;d/=2)
    {
        for(int i=d;i<n;i++)
        {
            if(arr[i-d]>arr[i])
            {
                int j;
                int temp=arr[i];
                for(j=i-d;j>=0&&arr[j]>temp;j-=d)
                {
                    arr[j+d]=arr[j];
                }
                arr[j+d]=temp;
            }
        }
    }
}

int main()
{
    int arr[]= {7,5,4,9,8,2,6};
    ShellSort(arr,getLength(arr));
    for(int i=0; i<getLength(arr); i++)
    {
        cout<<arr[i]<<" ";
    }
    return 0;
}

快速排序（qSort）

#include <iostream>
#include <stdlib.h>

using namespace std;

/*
特别注意：以下代码注释中指代的“指针”并非真正的指针，本质为数组下标。
但因C++中数组传参的特殊性（数组在函数传参时默认传的是地址，并非整个数组。如
果想在函数中得到整个数组，则需在函数中额外定义一个数组，然后挨个赋值）因此
在函数中传递数组时，只需加数组符号，不需要加引用“&”即可达到引用参数的效果

在目前来写代码的用法中，数组传参和用指针传参效果其实是一样的（用法不一样，
数组“.”，指针“->”），不一样的地方是关于内存分配，此处不为考试内容，故了解即可。
*/

template<typename T>

//获取数组长度
int getLength(T& arr)
{
    return sizeof(arr)/sizeof(arr[0]);
}

//找第一次“中分”
int getMid(int arr[],int Left,int Right)
{
    int pivot=arr[Left];
    while(Left<Right)
    {
        while(arr[Right]>pivot&&Left<Right)
            Right--;
        arr[Left]=arr[Right];
        while(arr[Left]<pivot&&Left<Right)
            Left++;
        arr[Right]=arr[Left];
    }
    //当左指针和右指针相遇时，第一次排序结束
    arr[Left]=pivot;
    return Left;
}

//快速排序——递归
void qSort(int arr[],int Left,int Right)
{
    if(Left<Right)//当左指针大于或等于右指针时，递归结束
    {
        int Mid=getMid(arr,Left,Right);
        qSort(arr,Left,Mid-1);
        qSort(arr,Mid+1,Right);
    }
}

int main()
{
    int arr[]= {9,8,4,5,2,3,1};
    qSort(arr,0,getLength(arr)-1);
    for(int i =0; i<getLength(arr); i++)
    {
        cout<<arr[i]<<" ";
    }
    return 0;
}

归并排序（mergeSort）

#include <iostream>
#include <stdlib.h>
#define Elemtype int
using namespace std;

void mergeTry(Elemtype arr[],int l,int m,int r)
{
    int left_MAX=m-l;
    int right_MAX=r-m+1;
    int i,j,k;
    Elemtype * left= (Elemtype *)malloc(left_MAX*sizeof(Elemtype));
    Elemtype * right=(Elemtype *)malloc(right_MAX*sizeof(Elemtype));
    for(i = l;i<m;i++)
    {
        left[i-l] = arr[i];
    }
    for(i = m;i<=r;i++)
    {
        right[i-m]=arr[i];
    }
    i=0,j=0,k=l;
    while(i<left_MAX&&j<right_MAX)
    {
        if(left[i]<right[j])
        {
            arr[k]=left[i];
            i++;
            k++;
        }
        else
        {
            arr[k]=right[j];
            j++;
            k++;
        }
    }
    while(i<left_MAX)
    {
        arr[k]=left[i];
        i++;
        k++;
    }
    while(j<right_MAX)
    {
        arr[k]=right[j];
        j++;
        k++;
    }
}
void mergeSort(Elemtype arr[],int l,int r)
{
    if(l==r)
    {
        return;
    }
    else{
    int m=(r+l)/2;
    mergeSort(arr,l,m);
    mergeSort(arr,m+1,r);
    mergeTry(arr,l,m+1,r);
    }
}
int main()
{
    Elemtype arr[]={2,5,6,9,8,1,3,4};
    mergeSort(arr,0,7);
    for(int i = 0;i<8;i++)
    {
        cout<<arr[i]<<endl;
    }
    return 0;
}

大小根堆

大根堆（HeapSort）

#include <iostream>

using namespace std;

//数组内关键字交换
void swapTry(int tree[],int i ,int Max)
{
    int temp=tree[i];
    tree[i]=tree[Max];
    tree[Max]=temp;
}

//父节点的关键值替换为最大
void heapify(int tree[],int n ,int i)
{
    if(i>=n) return;
    int CLeft=2*i+1;
    int CRight=2*i+2;
    int Max=i;
    if(CLeft<n&&tree[CLeft]>tree[Max])
        Max=CLeft;
    if(CRight<n&&tree[CRight]>tree[Max])
        Max=CRight;
    if(Max!=i)
    {
        swapTry(tree,i,Max);
        heapify(tree,n,Max);
    }
}

//构造大根堆
void buildHeapify(int tree[],int n)
{
    for(int i=n-1;i>=0;i--)
    {
        int parent=(i-1)/2;
        heapify(tree,n,parent);
    }
}

//堆排序
void heapifySort(int tree[],int n)
{
    for(int i= n-1;i>=0;i--)
    {
        buildHeapify(tree,i+1);
        swapTry(tree,0,i);
    }
}

int main()
{
    int tree[]={1,3,4,7,9,5,97,31,41};
    heapifySort(tree,9);
    for(int i = 0; i<9;i++)
    {
        cout<<tree[i]<<endl;
    }
    return 0;
}

小根堆（LittleHeapSort）

注意：这里小根堆结果是逆序输出的递增序列。

#include <iostream>

using namespace std;

//交换元素
void swapTry(int tree[],int i,int Min)
{
    int temp=tree[i];
    tree[i]=tree[Min];
    tree[Min]=temp;
}

//找出根节点最小
void heapify(int tree[],int n,int i)
{
    if(i>=n) return;
    //int parent = (i-1)/2;
    int CLeft=2*i+1;
    int CRight=2*i+2;
    int Min=i;
    if(tree[CLeft]<tree[Min]&&CLeft<n)
        Min=CLeft;
    if(tree[CRight]<tree[Min]&&CRight<n)
        Min=CRight;
    if(i!=Min)
    {
        swapTry(tree,i ,Min);
        heapify(tree,n,Min);
    }
}

//建立小根堆
void buildHeapify(int tree[],int n)
{
    for(int i = n-1;i>=0;i--)
    {
        int parent=(i-1)/2;
        heapify(tree,n,parent);
    }
}

//小根堆排序
void heapifySort(int tree[],int n)
{
    for(int i = n-1;i>=0;i--)
    {
        buildHeapify(tree,i+1);
        swapTry(tree,0,i);
    }
    //数组逆序，从小到大
    int p=0,q=n-1;
    while(p<q)
    {
        swapTry(tree,p,q);
        p++;
        q--;
    }
}

int main()
{
    int tree[]={11,88,33,55,22};
    heapifySort(tree,5);
    for(int i = 0; i<5;i++)
    {
        cout<<tree[i]<<endl;
    }
    return 0;
}
kanzwienhoff
关注
  • 9
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构-＞9.1顺序查找和二分查找
dev_cc_的博客
05-27 125
【代码】数据结构-＞9.1顺序查找和二分查找。
数据结构源代码系统包括线性表、停车场管理系统、二叉树等
10-01
数据结构源代码系统 [1]-线性表子系统 [2]-停车场管理系统 [3]-二叉树子系统 [4]-图子系统 [5]-查找子系统 [6]-排序子系统 [7]-退出系统
大话数据结构—顺序表、有序表、线性索引查找_大话数据结构顺序表代码(1)
最新发布
2401_84586417的博客
05-15 463
有序表查找的三种方法中，二分进行加法与除法运算，插值查找进行复杂的四则运算，而斐波那契查找只是进行最简单加减法运算，在海量数据的查找过程中，这种细微的差别可能会影响最终的查找效率。二分基础上修改，low+1/2(high-low)中1/2–>(key-a[low])/(a[high]-a[low])（插值公式）由于不是有记录来确定属性值，而是有属性值来确定记录的位置，因而叫倒排索引。根据要查找的关键字key与查找表中最大最小记录的关键字比较后的查找方法。查找时，可用二分，插值等从索引表中查找关键码。
排序和查找算法（完整代码）
Tresson_A的博客
03-22 1278
/定义外层循环变量i 内层循环变量j 临时变量tempfor(i=0;i
数据结构-查找（顺序查找与二分查找的讲解与代码实现）
weixin_73612682的博客
05-25 1456
前提条件是有序序列，即每次从序列的中间开始于所要查找的元素比较，如果中间元素小于key（要查找的元素）则从中间元素的右边查找（以中间元素+1为首元素，尾元素不变，再去求mid于key相比）。顺序查找概念：从表的另一端开始，一次将记录的关键字和给定值进行比较，若某个记录的关键字和给定的值相等，则查找成功，反之则查找失败。查找1的次数为1概率为1/3，2为两次概率1/3，3的次数为3概率1/3。所以顺序查找的ASL为：n*（n+1）/2*（1/n）=(n+1)/2。每次查找的概率为1/n。
C语言 数据结构 之 顺序查找法
java_open的博客
12-01 2727
数据结构的顺序查找，C语言
数据结构--顺序表的查找
m0_60593173的博客
06-26 1138
目标：GetElem(L,i):按位查找操作。获取表L中第i个位置的元素的值。
数据结构查找题目及代码
12-20
查找算法则是数据结构中的重要组成部分，用于在数据集合中寻找特定元素。本实验主要涵盖了三种查找方法：顺序查找、二分查找以及二叉判定树的构建。以下是这些知识点的详细说明： 1. **顺序查找**：顺序查找是最...
西南科技大学SWUST OJ 数据结构 查找排序相关题解 查找排序.zip
01-01
数据结构与查找排序是计算机科学中的基础且关键的领域，它们在编程竞赛和在线判题系统（如SWUST OJ）中占据着重要的地位。西南科技大学的这些在线判题题目涵盖了多个查找和排序算法的应用，旨在帮助学生深入理解和...
数据结构链表树图查找排序
09-20
链表、树、图、查找和排序是数据结构领域内的五个关键知识点，它们在编程和算法设计中起着至关重要的作用。 1. **链表**：链表是一种线性数据结构，与数组不同，它不连续存储元素。每个元素称为节点，包含数据和...
常见数据结构、查找、排序 c++实现
04-10
本资料包专注于使用C++实现常用的数据结构以及查找和排序算法，这对于理解和提升编程能力至关重要。 首先，我们来看数据结构部分： 1. **栈（Stack）**：栈是一种后进先出（LIFO）的数据结构，常用于表达式求值、...
数据结构重要代码（查找 堆栈 排序）
07-25
本压缩包包含的关键知识点聚焦于查找、堆栈和排序，这些都是数据结构中的关键元素。 **查找**： 查找是指在数据集合中寻找特定元素的过程。在程序设计中，高效的查找算法是必不可少的。常见的查找算法有线性查找、...
17-数据结构-查找-（顺序、折半、分块）
奔心小韩的博客
09-10 1160
查找-顺序，分块，折半
数据结构_顺序查找(C语言)
热门推荐
小黯
07-18 1万+
从表的一端开始，依次将表中的关键字和给定的值进行比较，若表中的关键字和给定的值相等，则查找成功，反之查找失败。
数据结构---顺序查找算法详解（C语言）
weixin_51781852的博客
11-21 1万+
顺序查找的实现 顺序查找的一般过程为：从表的一段开始，依次将记录的关键字和给定的值进行比较，若某个记录的关键字和给定值相等，则查找成功；反之，若扫描整个表后，仍未找到关键字和给定值相等的记录，则查找失败。 数据元素类型定义如下： typedef struct{ keytype key;//关键字域 InfoType otherinfo;//其他域 ｝ElemType; 顺序表的定义如下： typedef struct{ ElemType *R;//存储空间基地址 .
数据结构-顺序表详解（含完整代码）
qq_65641647的博客
09-10 6615
数据结构：顺序表详解，里面含有完整代码，对算法的分析，简单明了，一看就会哦。
C语言实现顺序查找
hou19975418的博客
01-25 2389
带哨兵位的顺序查找是将0号位置用来存储目标值，从最后一位开始往回查找，找到则返回位置索引，如果一直没找到会遍历到0号位置，返回索引值为0。时间复杂度为O（n）。顺序查找针对顺序表实现，普通顺序查找需要判断两个条件，是否读取越界和元素是否和目标相等。衡量指标：ASL衡量查找算法的效率。顺序查找是在顺序表中按照索引顺序依次查找。
【数据结构】查找排序_复习笔记总结
Texcavator的博客
06-18 1277
二叉排序树是一颗空树，或者满足：左子树比根小，右子树比根大，且左右子树都是二叉排序树中序遍历一棵二叉排序树可以得到递增的有序序列。
数据结构—查找（顺序查找和折半查找）
m0_51769031的博客
06-22 2772
2、顺序查找的主要代码 其时间复杂度为O(n)；其对于顺序表和链表都适用。 4、折半查找的主要代码（对于升序的顺序表） 其时间复杂度为O(logn)；但是其只能对于有序的顺序表，因为链表不具备随机存储的特性。折半查找的过程是一棵平衡二叉树。如果当前Low和high之间的元素个数是奇数个，则左右两边元素个数相等，否则就是左半部分比右半部分少一个元素（针对于mid=(low+high)/2，也即是向下取整时，若向上取整，则相反）。...
数据结构二叉排序树查找代码
05-30
下面是一个简单的二叉排序树查找的代码实现，仅供参考： ```c // 定义二叉排序树结点 typedef struct BSTNode { int key; // 关键字 struct BSTNode *left; // 左子节点 struct BSTNode *right; // 右子节点 } BSTNode; // 插入一个结点到二叉排序树中 void insertBSTNode(BSTNode **root, int key) { if (*root == NULL) { // 如果根节点为空，则创建新结点 BSTNode *newNode = (BSTNode*)malloc(sizeof(BSTNode)); newNode->key = key; newNode->left = NULL; newNode->right = NULL; *root = newNode; } else { // 根节点不为空，则插入到左子树或右子树中 if (key < (*root)->key) { // 插入到左子树中 insertBSTNode(&(*root)->left, key); } else if (key > (*root)->key) { // 插入到右子树中 insertBSTNode(&(*root)->right, key); } } } // 在二叉排序树中查找指定关键字的结点 BSTNode* searchBSTNode(BSTNode *root, int key) { if (root == NULL) { // 未找到结点 return NULL; } else if (root->key == key) { // 找到结点 return root; } else if (key < root->key) { // 在左子树中查找 return searchBSTNode(root->left, key); } else { // 在右子树中查找 return searchBSTNode(root->right, key); } } ``` 使用时，可以先创建一个空的二叉排序树，然后逐个插入结点，最后在树中查找指定关键字的结点。例如： ```c int main() { BSTNode *root = NULL; // 插入结点 insertBSTNode(&root, 8); insertBSTNode(&root, 3); insertBSTNode(&root, 10); insertBSTNode(&root, 1); insertBSTNode(&root, 6); insertBSTNode(&root, 14); insertBSTNode(&root, 4); insertBSTNode(&root, 7); insertBSTNode(&root, 13); // 查找结点 BSTNode *node = searchBSTNode(root, 6); if (node != NULL) { printf("Found node: %d\n", node->key); } else { printf("Node not found.\n"); } return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值