C语言编写数据结构查找算法

Posted 2023-04-05

查找时程序设计中经常使用的一种操作，给定一组待查找关键字，使用所学的各种查找方法，查找指定的关键字，若查找成功输出该关键字的位置，否则输出查找失败的提示。　　最好有解释　　还有运行图片，结果

实验五 查找的实现
一、 实验目的
1．通过实验掌握查找的基本概念；
2．掌握顺序查找算法与实现；
3．掌握折半查找算法与实现。
二、 实验要求
1． 认真阅读和掌握本实验的参考程序。
2． 保存程序的运行结果，并结合程序进行分析。
三、 实验内容
1、建立一个线性表，对表中数据元素存放的先后次序没有任何要求。输入待查数据元素的关键字进行查找。为了简化算法，数据元素只含一个整型关键字字段，数据元素的其余数据部分忽略不考虑。建议采用前哨的作用，以提高查找效率。
2、查找表的存储结构为有序表，输入待查数据元素的关键字利用折半查找方法进行查找。此程序中要求对整型量关键字数据的输入按从小到大排序输入。
一、顺序查找
顺序查找代码：
#include"stdio.h"
#include"stdlib.h"
typedef struct node
intkey;
keynode;
typedef struct Node
keynoder[50];
intlength;
list,*sqlist;
int Createsqlist(sqlist s)

inti;
printf("请输入您要输入的数据的个数:\n");
scanf("%d",&(s->length));
printf("请输入您想输入的%d个数据;\n\n",s->length);
for(i=0;i<s->length;i++)
scanf("%d",&(s->r[i].key));
printf("\n");
printf("您所输入的数据为:\n\n");
for(i=0;i<s->length;i++)
printf("%-5d",s->r[i].key);
printf("\n\n");
return1;

int searchsqlist(sqlist s,int k)

inti=0;
s->r[s->length].key=k;
while(s->r[i].key!=k)


i++;

if(i==s->length)

printf("该表中没有您要查找的数据！\n");
return-1;

else
returni+1;

sqlist Initlist(void)

sqlistp;
p=(sqlist)malloc(sizeof(list));
if(p)
returnp;
else
returnNULL;

main()

intkeyplace,keynum;//
sqlistT;//
T=Initlist();
Createsqlist(T);
printf("请输入您想要查找的数据的关键字:\n\n");
scanf("%d",&keynum);
printf("\n");
keyplace=searchsqlist(T,keynum);
printf("您要查找的数据的位置为:\n\n%d\n\n",keyplace);
return2;

顺序查找的运行结果：
二、折半查找
折半查找代码：
#include"stdio.h"
#include"stdlib.h"
typedef struct node
intkey;
keynode;
typedef struct Node
keynoder[50];
intlength;
list,*sqlist;
int Createsqlist(sqlist s)

inti;
printf("请输入您要输入的数据的个数:\n");
scanf("%d",&(s->length));
printf("请由大到小输入%d个您想输入的个数据;\n\n",s->length);
for(i=0;i<s->length;i++)
scanf("%d",&(s->r[i].key));
printf("\n");
printf("您所输入的数据为:\n\n");
for(i=0;i<s->length;i++)
printf("%-5d",s->r[i].key);
printf("\n\n");
return1;

int searchsqlist(sqlist s,int k)

intlow,mid,high;
low=0;
high=s->length-1;
while(low<=high)

mid=(low+high)/2;
if(s->r[mid].key==k)
returnmid+1;
elseif(s->r[mid].key>k)
high=mid-1;
else
low=mid+1;

printf("该表中没有您要查找的数据!\n");
return-1;

sqlist Initlist(void)

sqlistp;
p=(sqlist)malloc(sizeof(list));
if(p)
returnp;
else
returnNULL;

main()

intkeyplace,keynum;//
sqlistT;//
T=Initlist();
Createsqlist(T);
printf("请输入您想要查找的数据的关键字:\n\n");
scanf("%d",&keynum);
printf("\n");
keyplace=searchsqlist(T,keynum);
printf("您要查找的数据的位置为:\n\n%d\n\n",keyplace);
return2;

折半查找运行结果：
三、实验总结：
该实验使用了两种查找数据的方法（顺序查找和折半查找），这两种方法的不同之处在于查找方式和过程不同，线性表的创建完全相同，程序较短，结果也一目了然。追问

您可以把一些解释写上去吗　　　这样很多我不懂　　　弄些注释吧　　谢谢啦　　

参考资料：http://wenku.baidu.com/view/1da6314af7ec4afe04a1df6c.html

参考技术A 1、顺序查找
2、二分查找
3、分块查找 参考技术B #include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct tree_node

int data;
struct tree_node *lchild;
struct tree_node *rchild;
tree,*tlink;
int tree_init(struct tree_node **root);
void tree_construct(struct tree_node *root,int value);
tlink delet_tree_root(tree *root);
tlink delet_tree_value(struct tree_node *root,int value);
int tree_search(int value,tree *root);
int tree_height(struct tree_node *root);
void print_tree_node(struct tree_node *root);

int tree_init(struct tree_node **root)

if(((*root)=(struct tree_node *)malloc(sizeof(struct tree_node))) == NULL)
return -1;

(*root)->lchild = (*root)->rchild = NULL;
(*root)->data = 0;
return 0;


void tree_construct(struct tree_node *root,int value);
tlink delet_tree_root(tree *root);


p->data = value;
break;



if(value <= (p->data))

if(!(p->lchild))

tree_init(&(p->lchild));
p->lchild->data = value;
break;

else

p = p->lchild;
continue;


if(value >= (p->data))

if(!(p->rchild))

tree_init(&(p->rchild));
p->rchild->data = value;
break;

else

p = p->rchild;
continue;




return ;

tlink delet_tree_root(tree *root)

tlink tmp = root;
tlink p = root->rchild;
if(root->rchild == NULL)

root = root->lchild;
return root;

if(root->lchild == NULL)

root = root->rchild;
return root;

while(p->lchild != NULL)
p = p->lchild;
p->lchild = root->lchild;
root = root->rchild;
free(tmp);
return root;

tlink delet_tree_value(struct tree_node *root,int value)


struct tree_node *p = root;
struct tree_node *tmp;

if(root->data == value)

tmp = delet_tree_root(root);
return tmp;


while(p)


if((p->lchild!=NULL && (p->lchild->data)==value) || (p->rchild != NULL&&(p->rchild->data)==value))
break;
if(p->data > value)

p = p->lchild;
continue;

if(p->data < value)

p = p->rchild;
continue;



if(p == NULL)

printf("NO data record!\n");
return NULL;


if((p->lchild != NULL) && (p->lchild->data == value))

tmp = delet_tree_root(p->lchild);
p->lchild = tmp;
return root;

if((p->rchild != NULL) && (p->rchild->data == value))


tmp = delet_tree_root(p->rchild);
p->rchild = tmp;

return root;




int tree_search(int value,tree *root)

tlink p = root;
while(p != NULL)

if(p->data == value)
return 1;
if(value > (p->data))
p = p->rchild;
else
p = p->lchild;

if(p == NULL)
return 0;


int tree_height(struct tree_node *root)

struct tree_node *p1 = root;
struct tree_node *p2 = root;
int i=0,j=0;
if(p1->data == 0) return 1;

while(p1)

i++;
p1 = p1->lchild;


while(p2)

j ++;
p2 = p2->rchild;

return (i>j?(i):(j));


void print_tree_node(struct tree_node *root)

struct tree_node *p = root;

if(p == NULL)
return ;
print_tree_node(p->lchild);
printf("%d\t",p->data);
print_tree_node(p->rchild);

return;


int main(void)

int k,i,value;
struct tree_node *root;
struct tree_node *tmp;
if(tree_init(&root)<0)

printf("Iinit error!\n");

printf("Please input the number of the data:\n");
scanf("%d",&k);
int a[k];
printf("PLease put the data:\n");
for(i=0;i<k;i++)

scanf("%d",&value);
a[i] = value;

for(i=0;i<k;i++)
tree_construct(root,a[i]);
while(getchar() != '\n');
print_tree_node(root);
printf("\n");
printf("The tree height is:%d\n",tree_height(root));

while(root != NULL)

printf("input the data you want to delet:\n");
scanf("%d",&value);
if(tree_search(value,root) == 0)

printf("The data is not exist!\n");
continue;

else

root = delet_tree_value(root,value);
print_tree_node(root);
printf("\n");
while(getchar()!='\n');


printf("There is no data exist!\nByebye!\n");

return 0;



这是我自己辛辛苦苦写的，想了一天再把树的删除搞定。已经验证过。本回答被提问者和网友采纳

数据结构算法C语言实现---2.3线性表的顺序表示和实现

　　注意：

　　虽然是用C语言实现，但是考虑到使用了一个C++的特性----引用以简化代码，所以所有的代码均以cpp作为后缀，用g++编译（以后不做说明）。

　　g++版本：

　　

　　一.简述

　　本节主要讲述线性表的顺序实现，主要操作包括建表，插入元素，删除元素，查找元素，合并表等操作，根据书中伪代码编写了C语言，使用int类型进行了测试，需要注意的是查找元素时使用了函数指针，C语言初学者不易理解，可查阅相关书籍学习。

　　二.头文件

 1 //head.h
 2 /**
 3 My Code
 4 */
 5 #include <cstdio>
 6 #include <cstdlib>
 7 /**
 8 page 10
 9 */
10 #define TRUE 1
11 #define FALSE 0
12 #define OK 1
13 #define ERROR 0
14 #define INFEASIBLE -1//不可行的
15 #define OVERFLOW -2
16 //Status是函数的类型，其值是函数结果状态代码
17 typedef int Status;//注意分号不能少

View Code

　　三.CPP文件

//2_2.cpp
/**
author:zhaoyu
email:[e-mail]
date:2016-6-4
note:realize my textbook <<数据结构（C语言版）>>
*/

#include "head.h"
//----线性表的动态分配顺序存储结构----
#define LIST_INIT_SIZE 100//线性表存储空间的初始分配量
#define LISTINCREMENT 10//线性表存储空间的分配增量
/**
My Code
to make the paragram run correctlly
*/
#define ElemType int

typedef struct {
    ElemType *elem;//存储空间基址
    int length;//当前长度
    int listsize;//当前分配的存容量（以sizeof(ElemType)位单位）
}SqList;
int compare(ElemType a, ElemType b)
{
    return a==b?1:0;
}
/**
algorithm 2.3
page 23
*/
Status InitList_Sq(SqList &L)
{
    //构造一个空的线性表
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if (!L.elem)
    {
        exit(OVERFLOW);
    }
    L.length = 0;
    L.listsize = LIST_INIT_SIZE;
    return OK;
}//InitList_Sq

/**
algorithm 2.4
*/
Status ListInsert_Sq(SqList &L, int i, ElemType e)
{
    //在顺序线性表L中第i个位置之前插入新的元素e
    //i的合法为[1, ListLength_Sq(L)+1]
    if (i < 1 || i > L.length + 1)
    {
        return ERROR;//i值不合法
    }
    if (L.length >= L.listsize)
    {//当前存储空间已满，增加分配
        ElemType *newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT)*sizeof(ElemType));
        if (!newbase)
        {
            exit(OVERFLOW);//存储分配失败
        }
        L.elem = newbase;//新基址
        L.listsize += LISTINCREMENT;//增加存储容量
    }
    ElemType *q = &(L.elem[i-1]);//q为插入位置
    for (ElemType *p = &L.elem[L.length-1]; p >= q; p--)
    {
        *(p+1) = *p;//插入位置及之后的元素右移
    }
    *q = e;
    ++L.length;
    return OK;
}//ListInsert_Sq
/**
algorithm 2.5
*/
Status ListDelete_Sq(SqList &L, int i, ElemType &e)
{
    //在顺序线性表中删除第i个元素，并用e返回其值
    //i的合法值为[1, ListLength_Sq(L)]
    if ((i < 1) || (i > L.length))
    {
        return ERROR;//i为不合法值
    }
    ElemType *p = &(L.elem[i-1]);//p为被删除元素的位置
    e = *p;//被删除的元素赋值给e
    ElemType *q = L.elem + L.length - 1;//表位元素的位置
    for (++p; p <= q; ++p)
    {
        *(p-1) = *p;//被删除元素之后的元素左移
    }
    --L.length;//表长减 1
    return OK;
}//ListDelete_Sq
/**
algorithm 2.6
*/
int LocateElem_Sq(SqList L, ElemType e, Status(* compare)(ElemType, ElemType))
{
    //在顺序线性表L中查找第1个值与e满足compare()的元素位序
    //若找到返回其在L中的位序，否则返回0
    int i = 1;//i的初值为第一个元素的位序
    ElemType *p = L.elem;//p为第一个元素的存储位置
    while (i <= L.length && !(*compare)(*p++, e))
    {
        ++i;
    }
    if (i <= L.length)
    {
        return i;
    }
    else
    {
        return 0;
    }
}//LocateElem_Sq
/**
algorithm 2.7
*/
void MergeList_Sq(SqList La, SqList Lb, SqList &Lc)
{
    //已知顺序线性表La和Lb的元素按值非递减排列
    //归并La和Lb得到新的顺序线性表Lc,Lc的元素也按值非递减排列
    ElemType *pa = La.elem;
    ElemType *pb = Lb.elem;
    Lc.listsize = Lc.length = La.length + Lb.length;
    ElemType *pc = Lc.elem = (ElemType *)malloc(Lc.listsize*sizeof(ElemType));
    if (!Lc.elem)
    {
        exit(OVERFLOW);
    }
    ElemType *pa_last = La.elem + La.length - 1;
    ElemType *pb_last = Lb.elem + Lb.length - 1;
    while (pa <= pa_last && pb <= pb_last)
    {
        if (*pa <= *pb)
        {
            *pc++ = *pa++;
        }
        else
        {
            *pc++ = *pb++;
        }
    }
    while (pa <= pa_last)
    {
        *pc++ = *pa++;
    }
    while (pb <= pb_last)
    {
        *pc++ = *pb++;
    }
}//MergeList_Sq
/**
My code
*/
void PrintList(SqList L)
{
    for (int i = 1; i <= L.length; i++)
    {
        printf("%d\\t", L.elem[i-1]);
    }
    printf("\\n");
}
/**
My Test
*/
int main(int argc, char const *argv[])
{
    SqList La, Lb, Lc;
    InitList_Sq(La);
    InitList_Sq(Lb);
    InitList_Sq(Lc);
    //创建一个1 2 3 4的线性表
    ListInsert_Sq(La, 1, 10);
    ListInsert_Sq(La, 2, 20);
    ListInsert_Sq(La, 3, 30);
    ListInsert_Sq(La, 4, 50);
    PrintList(La);
    //在位序4（即值为5的位置）插 4
    ListInsert_Sq(La, 4, 40);
    PrintList(La);
    //创建线性表Lb;10, 20, 5, 30
    ListInsert_Sq(Lb, 1, 15);
    ListInsert_Sq(Lb, 2, 25);
    ListInsert_Sq(Lb, 3, 5);
    ListInsert_Sq(Lb, 4, 35);
    PrintList(Lb);
    int temp;
    //删除位置3的元素，并返回给 temp
    ListDelete_Sq(Lb, 3, temp);
    PrintList(Lb);
    printf("%d\\n", temp);
    //查找 30 在 Lb 的位置 
    printf("%d\\n", LocateElem_Sq(Lb, 30, compare));
    printf("%d\\n", LocateElem_Sq(Lb, 35, compare));
    //合并La， Lb 到 Lc，注意前提是有序的
    MergeList_Sq(La, Lb, Lc);
    PrintList(Lc);
    return 0;
}

View Code

　　四.测试