实验六——数据的查找与排序

最新推荐文章于 2024-05-31 19:04:21 发布
最新推荐文章于 2024-05-31 19:04:21 发布
阅读量1k 收藏 25
点赞数 18
分类专栏： 头歌实验平台 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/T19583553694/article/details/135099549
版权

数据结构-查找的实现及其应用

第1关：顺序查找

测试说明

可在右侧文件夹中查看step1/Main.cpp文件，以便于你的操作。

平台会对你编写的代码进行测试。

输入说明： 第一行输入若干记录的关键字，以-1标志结束。 第二行输入待查找的关键字。 输出说明： 第一行输出静态查找表L中各记录的关键字。 第二行输出查找的结果，如果找到，则输出该记录在表中的位置，否则输出not find!

测试输入: 37 21 75 55 64 19 -1 55 //待查找的关键字为55

预期输出： 37 21 75 55 64 19 4 //末尾换行

/*************************************************************
    顺序查找  实现文件    
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "search.h"

int Search_Seq(SSTable L, KeyType key) 
{/*在静态查找表L中采用顺序查找法，查找其关键字等于key的记录，若找到返回该记录在表中位置，否则返回0*/
	// 请在这里补充代码，完成本关任务
    /********** Begin *********/
	int i=0;
    int index=0;
    for(i==1;i<=L.length;i++)
    {
        if(L.r[i].key==key)
            index=i;
    }
    return index;	
    /********** End **********/	
}
void SSTableInput(SSTable &L) /*输入若干记录的关键字，存放到静态查找表L中*/
{
	int i=1; KeyType x;
	scanf("%d",&x);
	while(x!=-1)
	{
		L.r[i++].key=x; scanf("%d",&x);
	}
	L.length=i-1;
}
void SSTableOutput(SSTable L) /*输出静态查找表L中各记录的关键字*/
{
	int i;
	for(i=1;i<=L.length;i++)
		printf("%d ",L.r[i].key);
	printf("\n");
}

 第2关：折半查找

折半查找

算法思想：先确定待查元素所在范围；然后找中间元素；将中间元素与给定值 x 比较：若相等，则查找成功；若 x 小，则缩小至左半区；若 x 大，则缩小至右半区；直到相等或范围的下界﹥上界为止。 适用：有序的顺序表。

编程要求

在右侧编辑器中补充代码，完成Search_Bin函数，以实现顺序查找。具体要求如下：

* Search_Bin：在递增或递减有序的表中查找其关键字等于key的记录，若找到返回该记录在表中位置，否则返回0。

/*************************************************************
    折半查找  实现文件  
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "search.h"	

int Search_Bin(SSTable L, KeyType key)/*在递增有序的顺序表L中折半查找其关键字等于key的记录*/
{
	// 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int i=1;
    int left=1;
    int right=L.length;
    int mid=(left+right)/2;
	while(left<=right)	
    {
        if(key>L.r[mid].key)
        {
            left=mid+1;
            mid=(left+right)/2;
        }
        else if(key<L.r[mid].key)
        {
            right=mid-1;
            mid=(left+right)/2;
        }
        else
            return mid;
    }
    return 0;
    /********** End **********/
}
void SSTableInput(SSTable &L) /*输入若干记录的关键字，存放到静态查找表L中*/
{
	int i=1; KeyType x;
	scanf("%d",&x);
	while(x!=-1)
	{
		L.r[i++].key=x; scanf("%d",&x);
	}
	L.length=i-1;
}
void SSTableOutput(SSTable L) /*输出静态查找表L中各记录的关键字*/
{
	int i;
	for(i=1;i<=L.length;i++)
		printf("%d ",L.r[i].key);
	printf("\n");
}

 第3关：二叉排序树的查找

输入说明： 第一行输入若干记录的关键字，以-1标志结束。 第二行输入待查找的关键字。 输出说明： 第一行输出二叉排序树先序遍历的结果。 第二行输出二叉排序树中序遍历的结果。 第三行输出查找的结果，如果找到，则输出该结点的双亲结点的关键字，否则输出not find!

测试输入: 19 14 66 21 83 27 55 13 10 50 -1 55 //待查找的关键字为55

预期输出： PreOrder:19 14 13 10 66 21 27 55 50 83 //先序遍历的结果 InOrder:10 13 14 19 21 27 50 55 66 83 //中序遍历的结果 27 //末尾换行

/*************************************************************
    二叉排序树的查找  实现文件
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "search.h"	

BiTree Search_BST(BiTree T, KeyType key, BiTree &parent)
{/*在二叉排序树T上查找其关键字等于key的记录结点。若找到返回该结点指针，parent指向其双亲；否则返回空指针，parent指向访问路径上最后一个结点。*/
	// 请在这里补充代码，完成本关任务
    /********** Begin *********/
    while(T)
    {
        if(T->data.key==key)
            return T;
        else
        {
            parent=T;
            T=(key>T->data.key)?T->rchild:T->lchild;
        }
    }
    return NULL;

    /********** End **********/	
}
void Insert_BST(BiTree &T, RedType r)/*若二叉排序树T中没有关键字为r.key的记录，则插入*/
{
	BiTree p,q,parent;
	parent=NULL;
	p=Search_BST(T,r.key,parent); /*查找*/
	if(p) printf("BST中有结点r，无需插入\n");
	else
	{
		p=parent;
		q=(BiTNode *)malloc(sizeof(BiTNode)); q->data=r; q->lchild=q->rchild=NULL;
		if(T==NULL) T=q; /*若T为空，则q为新的根*/
		else if(r.key<p->data.key) p->lchild=q;
		else p->rchild=q;
	}
}
void Create_BST(BiTree &T ) /*二叉排序树的构造*/
{/*输入若干记录的关键字（以-1标志结束），生成一棵BST，采用二叉链表存储，返回其根指针T*/
    RedType r;
	T=NULL; /*建空树*/
	scanf("%d",&r.key);
	while(r.key!=-1)
	{
		Insert_BST(T, r);
		scanf("%d",&r.key);
	}
}
void PreOrder(BiTree bt) /*先序遍历*/
{
	if(bt)
	{
		printf("%d ",bt->data.key);
		PreOrder(bt->lchild);
		PreOrder(bt->rchild);
	}
}
void InOrder(BiTree bt) /*中序遍历*/
{
	if(bt)
	{
		InOrder(bt->lchild);
		printf("%d ",bt->data.key);
		InOrder(bt->rchild);
	}
}

 数据结构-排序的实现及其应用

第1关：直接插入排序

输入说明： 输入若干记录的关键字，以-1标志结束。

输出说明： 前三行输出前三趟排序后的关键字序列。 最后一行输出排序之后的关键字序列。

平台会对你编写的代码进行测试。

测试输入: 7 1 4 6 8 9 5 2 3 10 -1

预期输出： 1 7 4 6 8 9 5 2 3 10 1 4 7 6 8 9 5 2 3 10 1 4 6 7 8 9 5 2 3 10 1 2 3 4 5 6 7 8 9 10 //末尾换行

/*************************************************************
    直接插入排序  实现文件  
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sort.h"
	
void InsertSort(SeqList  &L) /*直接插入排序*/
{	
	int i,j;
	for(i=2;i<=L.length;i++)
	// 请在这里补充代码，完成本关任务
    /********** Begin *********/
	{
        int temp=L.r[i].key;
        j=i-1;
        while(j>0 && L.r[j].key>temp){
            L.r[j+1].key=L.r[j].key;
            j--;
        }
        L.r[j+1].key=temp;
        if(i<=4)
            SeqListOutput(L);
        
        
    }
    /********** End **********/	
}
void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
	int i=1; KeyType x;
	scanf("%d",&x);
	while(x!=-1)
	{
		L.r[i++].key=x; scanf("%d",&x);
	}
	L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
	int i;
	for(i=1;i<=L.length;i++)
		printf("%d ",L.r[i].key);
	printf("\n");
}

 第2关：希尔排序

输入说明： 输入若干记录的关键字，以-1标志结束。

输出说明： 第一行输出排序之前的各记录的关键字。 第二行输出排序之后的各记录的关键字。

平台会对你编写的代码进行测试。

测试输入: 49 38 65 97 76 13 27 49 -1

预期输出： 49 38 65 97 76 13 27 49 13 27 38 49 49 65 76 97 //末尾换行

/*************************************************************
    希尔排序  实现文件    
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sort.h"
	
void ShellInsert(SeqList &L, int d) /*对顺序表L作一趟增量为d的希尔插入排序*/
{
	// 请在这里补充代码，完成本关任务
    /********** Begin *********/
	int i,j,temp;
    for(i=d+1;i<=L.length;i++){
        temp=L.r[i].key;
        j=i-d;

        while(j>0 && L.r[j].key>temp){
            L.r[j+d].key=L.r[j].key;
            j-=d;
        }
        L.r[j+d].key=temp;
    }
	/********** End **********/	
}
void ShellSort(SeqList &L) /*希尔排序*/
{
	int d;
	d=L.length/2;
	while(d!=0)  /*调用一趟增量为d的希尔插入排序*/
	{
		ShellInsert(L,d); d=d/2;
	}
}
void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
	int i=1; KeyType x;
	scanf("%d",&x);
	while(x!=-1)
	{
		L.r[i++].key=x; scanf("%d",&x);
	}
	L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
	int i;
	for(i=1;i<=L.length;i++)
		printf("%d ",L.r[i].key);
	printf("\n");
}

 第3关：快速排序

算法思想：首先在待排记录中任取一个记录（通常取第一个记录）作为枢轴，将枢轴放入适当的位置后，待排记录被枢轴分割成两部分，并使得枢轴左边记录的关键字均小于枢轴，右边的均大于枢轴；然后分别对这两部分继续进行快速排序，以达到整个序列有序。

/*************************************************************
    快速排序  实现文件    
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sort.h"
	
void QuickSort(SeqList &L, int low, int high) {
    if (low < high) {
        int i = low, j = high;
        KeyType pivot = L.r[low].key; // Choose the first element as the pivot

        while (i < j) {
            while (i < j && L.r[j].key >= pivot)
                j--;
            if (i < j)
                L.r[i++] = L.r[j];

            while (i < j && L.r[i].key <= pivot)
                i++;
            if (i < j)
                L.r[j--] = L.r[i];
        }

        L.r[i].key = pivot; // Put the pivot in its correct position

        QuickSort(L, low, i - 1);  // Recursively sort the left subarray
        QuickSort(L, i + 1, high); // Recursively sort the right subarray
    }
}

void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
	int i=1; KeyType x;
	scanf("%d",&x);
	while(x!=-1)
	{
		L.r[i++].key=x; scanf("%d",&x);
	}
	L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
	int i;
	for(i=1;i<=L.length;i++)
		printf("%d ",L.r[i].key);
	printf("\n");
}

 第4关：堆排序

(1) Ki​≤K2i​ 且 Ki​≤K2i+1​ ,i=1，2，...，⌊ n/2 ⌋，称为小顶堆；

(2) Ki​≥K2i​ 且 Ki​≥K2i+1​ ，i=1，2，...，⌊ n/2 ⌋，称为大顶堆。

  • 如果用一维数组存放该序列，并把此数组看成是一棵完全二叉树的顺序存储结构，则堆实质上是满足如下性质的完全二叉树：树中所有分支结点的关键字值 Ki​ 均不大于（或不小于）其左右孩子结点的关键字值 K2i​ 和K2i+1​。

  • 若序列{ k1，k2，…，kn }是堆，则堆顶元素必为序列中最小值（或最大值）。

算法思想：首先将待排序列建成一个堆，得到关键字最小（或最大）的记录，输出堆顶的最小（大）值；然后将剩余的n-1个元素重新建成一个堆，得到次小值，输出堆顶；如此反复执行，便能得到一个有序序列。这一过程称为“堆排序”。

/*************************************************************
    堆排序  实现文件    
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sort.h"
	
void HeapAdjust(SeqList &L, int low, int high) {
    /*已知L.r[low..high]中记录的关键字除L.r[low].key之外均满足堆的定义，*/
    /*调整L.r[low].key，使L.r[low..high]成为一个新大顶堆。*/

    // 请在这里补充代码，完成本关任务
    /********** Begin **********/
    int i = low, j = 2 * i; // 左孩子结点
    RedType temp = L.r[i];

    while (j <= high) {
        // 比较左右孩子，找到较大的孩子
        if (j < high && L.r[j].key < L.r[j + 1].key) {
            j++;
        }

        // 如果父结点大于等于较大的孩子，调整结束
        if (temp.key >= L.r[j].key) {
            break;
        }

        // 将较大的孩子上移
        L.r[i] = L.r[j];
        i = j;
        j = 2 * i;
    }

    L.r[i] = temp; // 将原先的L.r[i]放入正确位置
    /********** End **********/
}

void HeapSort(SeqList &L) /*堆排序*/
{
	int i;
	for(i=L.length/2;i>0;i--)/*从最后一个分支结点(编号为L.length/2)开始调整，建立初始堆*/
		HeapAdjust(L,i,L.length);
	for(i=L.length;i>1;i--)
	{
		L.r[0]=L.r[1];L.r[1]=L.r[i];L.r[i]=L.r[0];/*将堆顶L.r[1]和当前最后一个记录L.r[i]交换*/
		HeapAdjust(L,1,i-1);/*将剩余记录L.r[1..i-1]重新调整为堆*/
	}
}
void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
	int i=1; KeyType x;
	scanf("%d",&x);
	while(x!=-1)
	{
		L.r[i++].key=x; scanf("%d",&x);
	}
	L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
	int i;
	for(i=1;i<=L.length;i++)
		printf("%d ",L.r[i].key);
	printf("\n");
}

 第5关：冒泡排序

冒泡排序重复地遍历待排序的数列，每次比较两个相邻元素，如果它们的顺序错误就把它们交换。重复地进行遍历直到没有再需要交换时表示数列已经排序完成。

  • 算法步骤：
  1. 比较相邻的元素：若第一个比第二个大，则交换；
  2. 遍历开始第一对到结尾最后一对，执行步骤1；
  3. 重复步骤1~`2`，直到排序完成。
  • 可改进的冒泡排序：第一趟排序之后最后一个元素是最大的，因此下一趟遍历只需执行到倒数第二对。
  • 本关任务：实现冒泡排序算法，并将乱序数列变成升序。要求输出前三趟排序结果和最后一趟排序结果。

 

/*************************************************************
    冒泡排序  实现文件  
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "BubbleSort.h"

void BubbleSort(SeqList &L) {
    /*冒泡排序，输出前三趟排序后的关键字序列*/

    // 请在这里补充代码，完成本关任务
    /********** Begin **********/
    int i, j;
    int time=3;
    for (i = 1; i <L.length; i++) {

        for (j = 1; j <= L.length - i; j++) {
            if (L.r[j].key > L.r[j + 1].key) {
                // 如果前一个元素大于后一个元素，交换它们
                KeyType temp = L.r[j].key;
                L.r[j].key = L.r[j + 1].key;
                L.r[j + 1].key = temp;

            }
        }
        // 输出本趟排序后的结果
        if(time>0){
            SeqListOutput(L);
            time--;
        }

    }
    /********** End **********/
}
void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
	int i=1; KeyType x;
	scanf("%d",&x);
	while(x!=-1)
	{
		L.r[i++].key=x; scanf("%d",&x);
	}
	L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
	int i;
	for(i=1;i<=L.length;i++)
		printf("%d ",L.r[i].key);
	printf("\n");
}

 第6关：选择排序

本关任务：实现选择排序算法，并将乱序数列变成升序，要求输出前三趟排序结果和最后的排序结果。

选择排序算法

选择排序是一种简单直观的排序算法，首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

  • 算法步骤：

  1. 初始状态：无序序列为R[0,n−1]，长度n，有序区为空；

  2. 第i=1,..,n−1趟排序从当前无序区R[i−1,n−1]中选出最小的元素R[k]，并将它与无序区的第1个记录R[i−1]交换，则R[0,i−1]变为元素个数增加1的新有序区，R[i,n−1]变为元素个数减少1的新无序区；

  3. n−1趟选择交换后结束。

 

/*************************************************************
    选择排序  实现文件  
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "SelectSort.h"
void SelectSort(SeqList &L) {
    /*选择排序，并输出前三次选择操作后的序列*/

    // 请在这里补充代码，完成本关任务
    /********** Begin **********/
    int i, j, minIndex;

    for (i = 1; i <= L.length; i++) {
        minIndex = i; // 假设当前位置的元素最小

        // 从未排序部分选择最小的元素
        for (j = i + 1; j <= L.length; j++) {
            if (L.r[j].key < L.r[minIndex].key) {
                minIndex = j;
            }
        }

        // 交换找到的最小元素与当前位置元素
        KeyType temp = L.r[i].key;
        L.r[i].key = L.r[minIndex].key;
        L.r[minIndex].key = temp;

        // 输出前三次选择操作后的序列
        if (i <= 3) {
            SeqListOutput(L);
        }
    }
    /********** End **********/
}
void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
	int i=1; KeyType x;
	scanf("%d",&x);
	while(x!=-1)
	{
		L.r[i++].key=x; scanf("%d",&x);
	}
	L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
	int i;
	for(i=1;i<=L.length;i++)
		printf("%d ",L.r[i].key);
	printf("\n");
}

Swallow__smile
关注
  • 18
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构——查找(二叉排序树)
weixin_47924016的博客
09-15 955
二叉排序树查找定义二叉排序树构造二叉排序树查找递归和非递归算法二叉排序树插入递归和非递归算法二叉排序树删除递归和非递归算法二叉排序树查找定义二叉排序树构造二叉排序树查找递归和非递归算法二叉排序树插入递归和非递归算法二叉排序树删除递归和非递归算法。
头歌数据结构 第1关：顺序表的实现之查找功能
m0_73938781的博客
04-23 697
【代码】头歌数据结构 第1关：顺序表的实现之查找功能。
数据结构——查找与排序
weixin_46067095的博客
03-29 2746
查找 静态查找表 顺序查找(Sequential Search) 原理： 对于任意一个序列以及一个给定的元素，将给定元素与序列中元素依次比较，直到找出与给定关键字相同的元素，或者将序列中的元素与其都比较完为止。 代码实现类似于数组遍历，理解即可。 顺序查找的平均查找长度ASL = (n + 1)/2 折半查找( Binary Search ) 定义：折半查找也叫二分查找。要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。 查找过程：表中元素按照一定顺序进行排列，将需要查找的元素与表中间位置元素
算法练习-常用查找算法复现
weixin_62075168的博客
03-24 939
对于任意一个序列，从一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。 折半查找的前提条件是需要有序表顺序存储，对于静态查找表，一次排序后不再变化，折半查找能得到不错的效率。但对于需要频繁执行插入或删除操作的数据集来说，维护有序的排序会带来不小的工作量，那就不建议使用。 ——《大话数据结构》 插值查找基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，差值查找也属于有序查找
数据结构实验报告（四）——查找和排序算法
热门推荐
半岛铁盒里
01-14 1万+
数据结构实验报告——查找和排序
数据结构实验——查找算法C语言
student_hwj的博客
12-17 765
以下是通过链表进行排序查询： 涉及 循序查找、二分查找、快速排序 #include<stdio.h> #include<stdlib.h> #define MAXSIZE 1000 struct LNode{ int Data[MAXSIZE]; //Data为待排序序列数组 int Last; //Last为最后一个元素的数组下标 }; typedef struct LNode *List; List Create() { List L; L = (List
数据结构——排序查找算法实现
langtaol的成长记
08-18 1659
前面转载了一篇讲排序算法的文章，这几天将排序和查找算法进行了实现，在这里贴出代码来。
实验五——查找和排序的应用
DEAR_CXN的博客
01-21 3219
实验内容 [问题描述] 学生信息管理系统 [基本要求] 设计一个学生信息管理系统，学生对象至少要包含：学号、姓名、性别、成绩1、成绩2、总成绩等信息。要求实现以下功能： 1.试选择一种方式存储：基于数组、链表或文件方式 2．总成绩要求自动计算； 3．查询：分别给定学生学号、姓名，能够查找到学生的基本信息（要求至少用两种查找算法实现）； 排序：分别按学生的学号、总成绩进行排序（要求至...
数据结构实验——查找实验
qq_65814357的博客
07-05 1726
一实验内容编写算法实现下列问题的求解。(1) 对下列数据表，分别采用二分查找算法实现查找，给出查找过程依次所比较的元素（的下标），并以二分查找的判定树来解释。 第一组测试数据：数据表为 (1,2,3,4,6,7,8,9,10,11,12,13,17,18,19,20,24,25,26,30,35,40,45,50,,100)查找的元素分别为： 2，8，20, 30，50，5，15，33，110 第二组数据：数据表为 (2,3,5,7,8,10,12,15,18,20,22,25,30,35,40,
数据结构实验——排序算法C语言
student_hwj的博客
12-14 1029
利用顺序表进行排序，以下有三种比较简单的排序算法：简单选择排序、直接插入排序、冒泡排序，希望对你有所帮助哦~ #include<stdio.h> #include<stdlib.h> #define MAXSIZE 1000 struct LNode{ int Data[MAXSIZE]; //Data为待排序序列数组 int Last; //Last为最后一个元素的数组下标 }; typedef struct LNode *List; List Create(
数据结构与算法——排序算法
caoxuan666的博客
02-23 1750
排序算法的重要性不言而喻在算法竞赛中经常考到因此我们要好好学习！使用恒定的额外空间，只需要使用他给你的数据一个就地排序算法使用恒定的的额外空间来产生输出（仅修改给定的数组）。它仅通过修改线性表中元素的顺序来对线性表进行排序。例如，插入排序和选择排序是就地排序算法，因为它们不使用任何额外的空间来对线性表进行排序。而归并排序和计数排序的经典实现就不是就地排序算法待排序数据，是否可以一次性的载入到内存中当所有待排序记录不能被一次载入内存进行处理时，这样的排序就被称为外部排序。
数据结构实验——查找子系统
07-31
编写顺序查找、二分查找程序（二选一）；编写建立二叉排序树的程序；编写在二叉排序树上的查找、插入、删除结点的程序；编写二叉排序树中序输出的程序
数据结构实验——二叉排序树查找
06-26
实验内容：建立有n个元素的二叉排序树，并在其上进行查找。 实验说明：(1)建立n个元素的二叉树，以链式结构存储，数据元素为整型。(2)在该二叉树上查找某数据，若查找成功则输出成功信息，若查找失败，则插入该数据...
数据结构——排序查找等实验
11-19
符合学校的实验要求，完整的代码。对大家很有帮助，欢迎下载
数据结构实验——查找
02-12
一、实验目的 1、掌握查找的不同方法，并能用高级语言实现查找算法。 2、熟练掌握顺序表的查找方法和有序顺序表的...3、掌握二叉排序树的生成、插入、删除、输出运算。 二、实验内容 1、有序顺序表的二分查找的递归算法
数据结构实验报告(C++) 实验4:查找与排序实验指导（含源码）
05-03
一、查找与排序实验（1）——查找 题目1. 输出二叉排序树中所有的关键字值不小于key的元素值 题目2. (选做题)判断二叉排序树是否为平衡二叉树 题目3. 链地址法处理冲突的哈希表 二、查找与排序实验（2）——排序 ...
高级数据结构-树状数组
weixin_72982195的博客
05-29 422
基本知识：1.lowbit运算2.树状数组及其应用a[N]是原始数组；c[N]是树状数组，存放数组a中i号位之前的lowbit(i)个元素之和，c[i]覆盖长度是lowbit(i)特别强调 树状数组的下标必须从1开始！！！（1）.函数getSum(x)，返回前x个数之和a[1]+a[2]+......a[x].（2）.函数update(x,c).实现将第x个数加上一个数v的功能，即a[x] += c；例题1：在完成了分配任务之后，西部 314来到了楼兰古城的西部。
数据结构--链表
pzn2506的博客
05-30 1269
想象⼀下这样的场景，假设每节⻋厢的⻋⻔都是锁上的状 态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从⻋头⾛到⻋尾？链表的结构跟⽕⻋⻋厢相似，淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。链表中每个节点都是独⽴申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个节点的。最简单的做法：每节⻋厢⾥都放⼀把下⼀节⻋厢的钥匙。
数据结构--拓扑排序
最新发布
Zhang_Qin123的博客
05-31 555
对于一个进行拓扑排序，是将G中所有节点排成一个线性序列，该序列满足以下两个条件：① 每个节点有且仅出现一次 ② 若存在一条从节点A到节点B的路径，则在序列中A一定出现在B前面。对于求一个有向无环图的拓扑排序步骤：1.在图中找到一个没有前驱(入度为0)的节点，然后输出2. 从图中删除该节点和所有以它为起点的有向边3.重复操作1和操作2，直到图为空 或 当前图不存在无前驱的顶点为止第一步操作，删除节点 1第二步操作，删除节点 2第三步操作，删除节点4最后拓扑排序依次为 3 5，不再画图讲述。
//顺序查找,找不到返回0 int Search_Seq(SSTable &ST, int key) { //--------补充代码--Start------ //--------补充代码--End------- }
11-19
以下是顺序查找的代码实现，如果找到了目标元素，返回其在表中的位置，否则返回0： ```c++ int Search_Seq(SSTable &ST, int key) { ST.elem[0].key = key; // 将哨兵设为待查找的元素，简化查找过程 int i; for (i = ST.length; ST.elem[i].key != key; --i); // 从后往前查找 return i; // 返回目标元素在表中的位置，如果找不到则返回0 } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值