数据结构与算法代码（C语言编写数据结构查找算法）

本文目录

• C语言编写数据结构查找算法
• 数据结构,算法与应用 ---C++语言描述(代码与习题答案)
• 刚学数据结构，题目不会，给个代码（算法）参考
• 数据结构算法代码
• GitHub Python项目推荐｜数据结构和算法必知必会的50个代码实现
• 数据结构与算法实验代码
• 数据结构算法设计问题，还不太会，哪位能给出具体代码（算法）参考
• 求大神 帮忙补一段c语言数据结构与算法考试的代码 有标注帮帮忙 急急急考试中
• 数据结构，题目不会，希望能给代码（算法）参考，谢谢

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

实验五 查找的实现
一、 实验目的
1．通过实验掌握查找的基本概念；
2．掌握顺序查找算法与实现；
3．掌握折半查找算法与实现。
二、 实验要求
1． 认真阅读和掌握本实验的参考程序。
2． 保存程序的运行结果，并结合程序进行分析。
三、 实验内容
1、建立一个线性表，对表中数据元素存放的先后次序没有任何要求。输入待查数据元素的关键字进行查找。为了简化算法，数据元素只含一个整型关键字字段，数据元素的其余数据部分忽略不考虑。建议采用前哨的作用，以提高查找效率。
2、查找表的存储结构为有序表，输入待查数据元素的关键字利用折半查找方法进行查找。此程序中要求对整型量关键字数据的输入按从小到大排序输入。
一、顺序查找
顺序查找代码：
#include"*****"
#include"*****"
typedef struct node{
intkey;
}keynode;
typedef struct Node{
keynoder;
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-》*****));
printf("\n");
printf("您所输入的数据为:\n\n");
for(i=0;i《s-》length;i++)
printf("%-5d",s-》*****);
printf("\n\n");
return1;
}
int searchsqlist(sqlist s,int k)
{
inti=0;
s-》*****=k;
while(s-》*****!=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"*****"
#include"*****"
typedef struct node{
intkey;
}keynode;
typedef struct Node{
keynoder;
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-》*****));
printf("\n");
printf("您所输入的数据为:\n\n");
for(i=0;i《s-》length;i++)
printf("%-5d",s-》*****);
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-》*****==k)
returnmid+1;
elseif(s-》*****》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;
}
折半查找运行结果：
三、实验总结：
该实验使用了两种查找数据的方法（顺序查找和折半查找），这两种方法的不同之处在于查找方式和过程不同，线性表的创建完全相同，程序较短，结果也一目了然。

数据结构,算法与应用 ---C++语言描述(代码与习题答案)

#include《*****》
#include《*****》
#include《*****》
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int status;
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef struct
{
int *elem;
int length;
int listsize;
}sqlist;
int flag=0;
status initlist(sqlist *l)
{
l-》elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));
if(!l-》elem)exit(OVERFLOW);
l-》length=0;
l-》listsize=LIST_INIT_SIZE;
return OK;
}
status listinsert(sqlist *l,int i,int e)
{
int *newbase,*q,*p;
if(i《1||i》l-》length+1)return ERROR;
if(l-》length》=l-》listsize)
{
newbase=(int*)realloc(l-》elem,(l-》listsize+LISTINCREMENT)*sizeof(int));
if(newbase)exit(OVERFLOW);
l-》elem=newbase;
l-》listsize+=LISTINCREMENT;
}
q=&(l-》elem);
for(p=&(l-》elem);p》=q;--p)
{
*(p+1)=*p;
}
*q=e;
++l-》length;
return OK;
}
void listprint(sqlist *l)
{
int i;
for(i=0;i《l-》length;i++)
{
printf("%-5d",l-》elem);
}
}
status listdelete(sqlist *l,int i,int *e)
{
int *p,*q;
if((i《1)||(i》l-》length))return ERROR;
p=&(l-》elem);
e=*p;
q=l-》elem+l-》length-1;
for(++p;p《=q;++p)*(p-1)=*p;
--l-》length;
return OK;
}
status getelem(sqlist *l,int i,int *e)
{
if((i《1)||(i》l-》length))return ERROR;
*e=l-》elem;
return OK;
}
int meun()
{
int a;
printf("*************************\n");
printf("* 1 InitList *\n");
printf("* 2 ListInsert *\n");
printf("* 3 ListPrint *\n");
printf("* 4 Delete *\n");
printf("* 5 Getelem *\n");
printf("* 6 Exit *\n");
printf("*************************\n");
fflush(stdin);
do
{
printf("qing xuan ze:\n");
scanf("%d",&a);
}while(!(a》=1&&a《=6));
return a;
}
void main()
{
sqlist l,*p;
int x,i,e,result;
p=&l
do
{ clrscr();
x=meun();
switch(x)
{
case 1: initlist(p);
flag=1;
printf("initlist succes!press enter contiue");
getch();
break;
case 2: if(flag==0)
{
printf("you must initlist first!please select!");
getch();
break;
}
fflush(stdin);
printf("\n please input i and e:");
scanf("%d%d",&i,&e);
result=listinsert(p,i,e);
if(result==ERROR)
printf("error:i out of rang!press enter continue");
else
printf("insert completed!please enter continue");
getch();
break;
case 3: printf("sqlist:\n");
listprint(p);
getch();
break;
case 4: printf("\n please input i:");
scanf("%d",&i);
result=listdelete(p,i,&e);
if(result==ERROR)
printf("error:i out of rang!press enter continue");
else
printf("delete completed!please enter continue");
getch();
break;
case 5: printf("\n please input i:\n");
scanf("%d,&i");
result=getelem(p,i,&e);
if(result==ERROR)
printf("error:i out of rang!press enter continue");
else
printf("completed:%d",e);
getch();
break;
case 6: printf("bye\n");
getch();
exit(0);
}
}while(1);
}

刚学数据结构，题目不会，给个代码（算法）参考

1
#include "*****"

#define MAXSIZE 32

typedef char datatype;

typedef struct _Node{
datatype data;
_Node *lchild, *rchild;
}Node, *PNode, *PBitTree;

void visit(PNode node){
printf("%c\t", node-》data);
}

(1)
void PreOrder(PBitTree root){
if(!root) return;
visit(root);
PreOrder(root-》lchild);
PreOrder(root-》rchild);
}

void InOrder(PBitTree root){
if(!root) return;
InOrder(root-》lchild);
visit(root);
InOrder(root-》rchild);
}

void PostOrder(PBitTree root){
if(!root) return;
PostOrder(root-》lchild);
PostOrder(root-》rchild);
visit(root);
}

(2)
void Display(PBitTree root){
PNode nodeQueue; /*结点队列*/
int levelQueue; /*用于保存结点层次信息的队列*/
int front=0, rear=0, curlevel = 0, bline = 0; /*bline用于判断是否需要换行*/
PNode p = root;
if(p) { /*根结点入队*/
nodeQueue = p;
levelQueue = 0;
rear = (rear + 1) % MAXSIZE;
}
while(front != rear) { /*如果队列不空*/
p = nodeQueue; /*获取队首元素*/
bline = levelQueue != curlevel ? 1 : 0; /*判断是否需要换行*/
curlevel = levelQueue;
front = (front + 1) % MAXSIZE; /*出队*/
if(bline) printf("\n"); /*如果需要换行，则输出换行符*/
visit(p);
if(p-》lchild) { /*如果左孩子不空，将左孩子入队*/
nodeQueue = p-》lchild;
levelQueue = curlevel + 1;
rear = (rear + 1) % MAXSIZE;
if(p-》rchild) { /*如果右孩子不空，将右孩子入队*/
nodeQueue = p-》rchild;
levelQueue = curlevel + 1;
rear = (rear + 1) % MAXSIZE;
}
}
}

(3)
void Exchange(PBitTree root) {
if(!root) return;
PNode tmp;
Exchange(root-》lchild);
Exchange(root-》rchild);
tmp = root-》lchild;
root-》lchild = root-》rchild;
root-》rchild = tmp;
}

2
typedef char datatype;

typedef struct _listNode{
datatype data;
_listNode *next;
}RQueueNode, *PRQueueNode, *PRQueue;

PRQueue rear;

void InitRQueue( ) { /*初始化队列*/
rear = (PRQueue) malloc(sizeof(RQueueNode)); /*生成附加头结点*/
rear-》next = rear; /*设置为循环的空队*/
}

void EnRQueue(datatype x) { /*入队*/
PRQueueNode *newNode;
newNode = (PRQueue) malloc(sizeof(RQueueNode)); //生成新结点
newNode-》data = x;
newNode-》next = rear-》next; /*将新结点链接到队尾*/
rear-》next = newNode;
rear = newNode; /*将新结点作为新的队尾*/
}

datatype DeRQueue( ) { /*出队*/
PRQueueNode *front; /*队首指针*/
datatype tmp; /*用于返回队首元素数据*/
assert(rear-》next != rear); /*断言队列不空*/
front = rear-》next-》next;
rear-》next-》next = front-》next;
if(rear == front) rear = rear-》next; /*如果出队的是队列中的最后一个结点*/
tmp = front-》data;
****(front);
return tmp;
}

数据结构算法代码

我感觉你很有必要把这段代码好好的整理、规范下。。。
typedef
char
ListItem;
typedef
struct
node
*link;
typedef
struct
node
{

ListItem
element;

link
next;
}Node;
typedef
struct
llist
*List;
typedef
struct
llist
{

link
first;
}Llist;
估计到后面，你都弄不清楚，这里面的哪个是哪个了吧。
把这段整理清楚之后，出了问题也就很容易找了。。

GitHub Python项目推荐｜数据结构和算法必知必会的50个代码实现

标星(star) ：8860

拷贝(fork) ：2644

贡献人数 ：98 （贡献人数很多哈）

仓库大小 ：1 MB

最后更新 ：2019-08-17

代码提交活跃 ：

主要语言：Python

语言比例：Python:*****%、C:*****%、C++:*****%、Scala:****%、Go:****%、Java:****%、JavaScript:****%、PHP:****%、Rust:****%、C#:****%、TypeScript:****%、Objective-C:****%、Swift:****%、Kotlin:****%、HTML:****%、Shell:****%

数据结构和算法必知必会的50个代码实现 ，内容包括

数组

链表

栈

队列

递归

排序

二分查找

散列表

字符串

二叉树

堆

图

回溯

分治

动态规划

***隐藏网址***

数据结构与算法实验代码

#include 《cstdio》
int gold;
int list;
int fir = 0;//用来判断是否是第一个元素用的
void printresult(int check_number,int n);
int main()
{
int n,m;
scanf("%d%d",&n,&m);
for(int i = 0;i 《 n;i++)
scanf("%d%d%d",&gold);
for(int i = 0;i 《 m;i++)
{
int check_number;
scanf("%d",✓_number);
printresult(check_number,n);
}
printf("\n");
return 0;
}
void printresult(int check_number,int n)
{
for(int i = 0;i 《 n;i++)
{
if(gold)
list++;
}
int result = ++list;//这里还要多加一个1，因为数组原来是0
int num = 1;
for(int i = 0;i 《 n;i++)
{
if(medal)
list++;
}
list++;
double gold_per = gold;
for(int i = 0;i 《 n;i++)
{
if((gold)》gold_per)
list++;
}
list++;
double medal_per = medal;
for(int i = 0;i 《 n;i++)
{
if(medal》medal_per)
list++;
}
list++;
for(int i = 1;i 《 5;i++)
{
if(list《result)
{
result = list;
num = i;
}
}
for(int i = 1;i 《 5;i++)
list = 0;//对排名数组清零，因为之后要多次调用
if(!fir)
{
printf("%d:%d",result,num);//首个输入前面不用空格
fir = 1;
}
else
printf(" %d:%d",result,num);
}
//如果超时的话还可以再优化，不过国家的数量比较少，应该不会
//优化就是把排名是1的话直接输出，不进行之后运算

数据结构算法设计问题，还不太会，哪位能给出具体代码（算法）参考

1、采用遍历二叉树的思想，具体算法思路为（设在树根为root的二叉树中检索值为key的结点）：
（1）如果树root为NULL，返回NULL；
（2）如果树root的根结点的值为key，返回root；
（3）在左子树中检索，得到检索结果pnode；如果pnode不空则返回pnode；否则继续在右子树中检索，得到检索结果pnode，并返回pnode；
设BitNode为二叉树结点结构，BitTree为二叉树类型，dataType为结点中item域的数据类型，则检索算法Search如下：
BitNode* Search(BitTree *root, dataType key) {
BitNode *pnode;
if(root == NULL) return NULL;
if(root-》item == key) return root;
pnode = Search(root-》lchild, key);
if(pnode) return pnode;
pnode = Search(root-》rchild, key);
return pnode;
}

2、把表看成两部分list和list1，其中list是有序表，初始化为只有首元素结点的链表，list1是无序部分，初始化为去掉首元素后剩下的部分。每次从list1中取出第一个元素插入到list的适当位置，使list有序，直到list1为空表时为止。
void InsertSort(LinkList* list) {//list是个带表头结点的单链表
LinkList *list1; //list1为无序部分（不带头结点）
Node *p, *q, *r; //插入时，插入到p和q之间，r为从list1中取到的首结点。
if(list-》next == NULL) return; //空表无需排序
list1 = list-》next-》next;
list-》next-》next = NULL; //将list初始化为只有单首元结点的表
while(list1 != NULL) {
r = list1;
list1 = list1-》next;
p = list;
q = p-》next;
while(q != NULL && q-》data 《 r-》data) {
p = q;
q = p-》next;
}
r-》next = q;
p-》next = r;
}
}

3、把表看成两部分list和list1，其中list是有序表，初始化为空表，list1是无序部分，初始化为原表。每次从list1中取出值为最小的元素插入到list的末尾，使list有序，直到list1为空表时为止。
void SelectSort(LinkList *list) {
LinkList list1; //list1为无序表部分，带表头结点，list1为表头结点；
Node *p, *q, *pre, *min, *last; //q是对list1进行扫描用的指针，p为q的前驱，last指向有序表的表尾。
if(list-》next == NULL) return; //空表无需排序
***** = list-》next; //list为指针类型，list1为普通变量类型，所以访问成员的方式不一样。
last = list;
while(***** != NULL) {//当无序表不空时
pre = &list1
min = pre-》next;
p = min;
q = p-》next;
while(q != NULL) {
if(q-》data 《 min-》data) {
pre = p;
min = q;
}
p = q;
q = p-》next;
}
pre-》next = min-》next; //在list1中删去min
last-》next = min; //将min插入到有序表的末尾
last = min; //将刚插入的元素作为新的表尾
}
last-》next = NULL;
}

求大神 帮忙补一段c语言数据结构与算法考试的代码 有标注帮帮忙 急急急考试中

#include#include#defineNEW(LB*)malloc(sizeof(LB))typedefstructLianb{intdata;structLianb*next;}LB;//创建链表结构体LB*chuangjian(intn){LB*Head,*p;Head=p=NEW;for(inti=0;idata);p-》next=NEW;p=p-》next;}p=0;returnHead;}//创建链表voidxianshi(LB*Head,intn){printf("head-》");LB*p=Head;for(inti=0;i",p-》data);p=p-》next;}printf("end\n");}//显示链表LB*chazhao(LB*Head,intn){LB*p=Head;if(p!=0){for(inti=0;inext;}}else{printf("链表长度不足\n");}returnp;}//查找LB*shanchu(LB*Head,intn){LB*p=chazhao(Head,n-1);p-》next=p-》next-》next;returnHead;}//删除intmain(){LB*head;head=chuangjian(5);//创建链表xianshi(head,5);//显示链表shanchu(head,3);xianshi(head,4);//显示插入后新链表****(head);return0;}

数据结构，题目不会，希望能给代码（算法）参考，谢谢

1
typedef char datatype;
typedef struct _listnode{
datatype data;
_listnode *next;
}ListNode, *PListNode, *PList, ,

PList list; /*单链表头指针*/

void InitList( ) {
list = (PList) malloc ( sizeof ( ListNode ) );
assert(list);
list-》next = NULL;
}

void ReversedDisplay( ) {
PListNode stack; /* 栈的容量要保证大于链表的长度 */
int top = -1;
PListNode p = list-》next;
while(p != NULL) { /* 当还没有到达表尾时 */
stack = p; /* 进栈 */
p = p-》next;
}
while(top 》 -1) { /* 当栈不空时 */
p = stack; /* 出栈 */
printf("%c\t", p-》data);
}
}

2
/*设datatype为顺序双栈元素数据类型，DStack为顺序双栈，m为其容量, top初始化为m。*/

#define m 64

typedef char datatype;
datatype DStack;
int top;
int bottom;

void InitStack( ) {
top = -1;
top = m;
bottom =-1;
bottom = m;
}

void Push(int i, datatype x) {
assert(top); /* 断言栈不满 */
assert(i 》 0 && i 《 3); /* 断言i的合法性 */
i == 1 ? top--; /* i等于1为栈1，等于2（或者说不等于1）时为栈2 */
DStack = x;
}

datatype Pop(int i) {
datatype tmp;
assert(top); /*断言i栈不空*/
assert(i 》 0 && i 《 3);
tmp = DStack;
i == i ? top++;
return tmp;
}