㈠ 数据结构：查找算法和排序算法有哪些知道的请详细说明下！谢谢
查找就包括顺序查找，二分查找线段树的查找
排序就多了
冒泡，选择，插入，分治，堆排序，基数排序，桶排序，快速排序。。。。
㈡ 对比顺序查找,二分查找和哈希查找算法,它们各自的特点是什么
顺序查找,二分查找和哈希查找算法,它们各自的特点是：
1.对比顺序查找的特点就是从表的第一个元素开始一个一个向下查找，如果有和目标一致的元素，查找成功;如果到最后一个元素仍没有目标元素，则查找失败。
2.二分查找的特点就是从表中间开始查找目标元素。如果找到一致元素，则查找成功。如果中间元素比目标元素小，则仍用二分查找方法查找表的后半部分(表是递增排列的)，反之中间元素比目标元素大，则查找表的前半部分。
3.哈希算法的特点是是使用给定数据构造哈希表，然后在哈希表上进行查找的一种算法。先给定一个值，然后根据哈希函数求得哈希地址，再根据哈希地址查找到要找的元素。是通过数据元素的存储地址进行查找的一种算法。
㈢ 急求！！！！关于数据结构在【C语言】环境中实现：是关于查找和排序的算法 实现如下功能
下面的代码能实现你的功能咯。。。都很基础的，这是我以前学C的时候写的，希望对你有帮助
#include <stdio.h>
#include <malloc.h>
#include<stdlib.h>
struct stu
{ struct stu *last;
int a;
struct stu* next;
}*q,*h,*p,*l;
/*void jllb()
{
int i,j;
h=(struct stu*)malloc(sizeof(struct stu));
q=h;
q->last=NULL;
h->a=0;
for(i=1;i<=9;i++)
{
p=(struct stu*)malloc(sizeof(struct stu));
p->a=2*i+3;
p->next=NULL;
q->next=p;
p->last=q;
q=p;
}
}
void cylb()
{
int b;
printf("请输入要插入的数");
scanf("%d",&b);
p=(struct stu*)malloc(sizeof(struct stu));
p->a=b;
for(q=h;(q->next)->a<b;q=q->next);
p->next=q->next;
p->last=q;
q->next=p;
p->next->last=p;
}
void dylb()
{
for(q=h;;q=q->next)
{
printf("%d\n",q->a);
if(q->next==NULL)break;
}
}
void sclb()
{
int m;
printf("请输入需删除的数：");
scanf("%d",&m);
for(p=h;p->a!=m;p=p->next) ;
q=p->last;
p->next->last=q;
q->next=p->next;
free(p);
}
void xglb()
{
int n,m;
printf("选择错误的数：");
scanf("%d",&n);
printf("\n需要改成的数：");
scanf("%d",&m);
for(p=h;p->a!=n;p=p->next);
p->a=m;
}
void _save()
{
FILE *fp;
if((fp=fopen("D:\\data.txt","w"))==NULL)
{
printf("error");
exit(0);
}
p=h;
while(1)
{
fread(p,sizeof(struct stu),1,fp);
p=p->next;
if(p->next==NULL)
break;
}
fclose(fp);
}*/
void chu()
{
FILE *fp;
int i=0;
if((fp=fopen("D:\\data.txt","r"))==NULL)
{
printf("esaa");
exit(0);
}
q=(struct stu *)malloc(sizeof(struct stu ));
while(1)
{
fread(q,sizeof(struct stu),1,fp);
if(i==0)
q=h;
q=(struct stu *)malloc(sizeof(struct stu ));
q=q->next;
i++;
if(q->next==NULL)
break;
}
fclose(fp);
q=h;
printf("%d %d\n\n\n",q->a,q->next->a);
}
main()
{
int m;
// jllb();
// dylb();
while(1)
{
printf("需要选择的功能1sc 2cy 0 tc 3；");
scanf("%d",&m);
switch(m)
{
// case 1:sclb();break;
// case 2:cylb();break;
// case 0:exit(0);break;
// case 3:xglb();break;
// case 4:_save(); break;
case 5:chu();break;
}
// dylb();
}
}
㈣ vb解析算法的功能
排序算法 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
解析算法 所谓解析法（analysis algorithm）是指用解析的方法找出表示问题的前提条件与结果之间关系的数学表达式，并通过表达式的计算来实现问题求解。
事先考虑到某一变量可能取的值，尽量用自然语言中含义清楚的单词来表示它的每一个值，这种方法称为枚举方法。
索引查找是在索引表和主表(即线性表的索引存储结构)上进行的查找。
索引查找的过程是：首先根据给定的索引值K1，在索引表上查找出索引值等于KI的索引项，以确定对应予表在主表中的开始位置和长度，然后再根据给定的关键字K2，茬对应的子表中查找出关键字等于K2的元素(结点)。对索引表或子表进行查找时，若表是顺序存储的有序表，则既可进行顺序查找，也可进行二分查找，否则只能进行顺序查找！
㈤ 查找算法的作用
查找就是在一个数据集合里查找到你需要的数据，查找算法就是在查找过程中使用的算法。查找算法有好多，最基础的就是线性表查找。
因为提到了算法，所以需要注意的是时间复杂度跟空间复杂度，进而涉及到数据的存储方式，比如数组，链表，矩阵，树，图等等数据结构，这些数据结构可以帮助你降低算法的复杂度。
如果有兴趣，随便找本数据结构书翻翻，里面或多或少都会有讲解。用关键字标识一个数据元素，查找时根据给定的某个值，在表中确定一个关键字的值等于给定值的记录或数据元素。在计算机中进行查找的方法是根据表中的记录的组织结构确定的。顺序查找也称为线形查找，从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。二分查找要求线形表中的结点按关键字值升序或降序排列，用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，这样递归进行，直到查找到或查找结束发现表中没有这样的结点。分块查找也称为索引查找，把线形分成若干块，在每一块中的数据元素的存储顺序是任意的，但要求块与块之间须按关键字值的大小有序排列，还要建立一个按关键字值递增顺序排列的索引表，索引表中的一项对应线形表中的一块，
㈥ 哪个算法可以即可以用于查找又可以用于排序
二叉排序树的构造算法既可以用于查找，也可以用于排序
㈦ 软考 软件设计师 过来人指路
2-软件设计师视频—ciu培训免费在线观看
链接:https://pan..com/s/1HBgPCST07X0QMHC3znSK_Q
软件设计师是指能根据软件开发项目管理和软件工程的要求，按照系统总体设计规格说明书进行软件设计，编写程序设计规格说明书等相应的文档的实用性人才。还能够组织和指导程序员编写、调试程序，并对软件进行优化和集成测试，开发出符合系统总体设计要求的高质量软件；具有工程师的实际工作能力和业务水平，可聘任工程师职务。2004年人社部将高级程序员更名为软件设计师
㈧ 索引顺序查找算法
参考代码，不一定正确。
#include <malloc.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>
#include <memory.h>
struct element
{
long key;
long data;
};
struct index
{
long address;
long maxkey;
};
struct index *creatidxtable(struct element *elems, long elen, long *tlen, long *plen)
{
struct index *itable;
long i, step, len;
len = (long)sqrt(elen);
*plen = len;
step = len;
len = (len * len == elen ? len : len + 1);
*tlen = len;
itable = (struct index *)malloc(sizeof(struct index) * len);
for (i = 0; i < len; ++i)
{
itable[i].address = i;
if (i < len - 1)
itable[i].maxkey = elems[ i * step + *plen - 1].key;
else
itable[i].maxkey = elems[elen - 1].key;
}
return itable;
}
long searchposition(struct index *itable, long length, long *times, long key)
{
long i;
++(*times);
if (key <= itable[0].maxkey)
return itable[0].address;
++(*times);
if (key >= itable[length - 1].maxkey)
return itable[length - 1].address;
for (i = 0; i < length - 1; ++i)
{
(*times) += 2;
if (key > itable[i].maxkey && key <= itable[i + 1].maxkey)
return itable[i + 1].address;
}
return -1;
}
long seqencesearch(struct element *elems, long start, long length, long *times, long key)
{
long i;
for (i = start; i < start + length; ++i)
{
++(*times);
if (elems[i].key == key)
return i;
}
return -1;
}
void selectionsort(struct element *elems, long length)
{
long i, j, k, s = sizeof(struct element);
struct element t;
for (i = 0; i < length - 1; ++i)
{
k = i;
for (j = i + 1; j < length; ++j)
{
if (elems[k].key > elems[j].key)
{
k = j;
}
}
if (k != i)
{
memcpy(&t, elems + i, s);
memcpy(elems + i, elems + k, s);
memcpy(elems + k, &t, s);
}
}
}
void initdata(struct element *elems, int length)
{
long i;
srand(time(NULL));
for (i = 0; i < length; ++i)
{
elems[i].data = elems[i].key = rand();
}
}
void output(struct element *elems, int length)
{
long i;
for (i = 0; i < length; ++i)
{
printf("%-10d ", elems[i].key);
if ((i + 1) % 5 == 0)
printf("\n");
}
}
void main()
{
struct element * elems;
struct index *itable;
long num, tlen, plen, times, key, start, pos;
while (1)
{
printf("请输入想要测试的数据量：");
scanf("%ld", &num);
if (num <= 0)
break;
elems = (struct element *)malloc(sizeof(struct element) * num);
initdata(elems, num);
selectionsort(elems, num);
output(elems, num);
itable = creatidxtable(elems, num, &tlen, &plen);
times = 0;
printf("\n");
printf("请输入一个查找关键字：");
scanf("%ld", &key);
if ((start = searchposition(itable, tlen, ×, key)) == -1)
{
printf("查找失败1！\n");
}
else
{
pos = seqencesearch(elems, start * plen,
(start == tlen - 1 ? num - (tlen - 1) * plen : plen), ×, key);
if (pos != -1)
{
printf("查找成功！\n");
printf("关键字对应的值：%ld\n", elems[pos].data);
printf("关键字比较次数：%ld\n", times);
}
else printf("查找失败！\n");
}
free(elems);
free(itable);
}
system("PAUSE");
}
㈨ 查找算法性能研究（顺序存储、有序顺序存储、链表存储、二叉排序树存储）
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
static const int ARRAY_MAX = 10000;
typedef int DataType;
class SequentialStorage
{
public:
DataType data[ARRAY_MAX];
int top;
SequentialStorage()
{
top = -1;
}
void insertData(DataType data)
{
if(top == ARRAY_MAX-1)
return;
this->data[++top] = data;
}
int find(DataType data)
{
for(int i = 0;i <= top;i++)
{
if(this->data[i] == data)
return i;
}
return -1;
}
};
class OrderlySequenceStorage
{
public:
DataType data[ARRAY_MAX];
int top;
OrderlySequenceStorage()
{
top = -1;
}
void insertData(DataType data)//插入排序
{
if(top == ARRAY_MAX-1)
return;
int i = top;
while(this->data[i] > data&&i != -1)
{
this->data[i+1] = this->data[i];
i--;
}
this->data[i+1] = data;
top++;
}
int find(DataType data)//普通查找
{
for(int i = 0;i <= top;i++)
{
if(this->data[i] == data)
return i;
}
return -1;
}
int find2(DataType data)//二分法
{
if(this->data[0] > data||this->data[top] < data)
return -1;
if(this->data[0] == data)
return 0;
if(this->data[top] == data)
return top;
int a = 0;
int b = top;
while(true)
{
if(a == b-1)
return -1;
if(this->data[(a+b)/2] == data)
return (a+b)/2;
else if(this->data[(a+b)/2] < data)
a = (a+b)/2;
else
b = (a+b)/2;
}
}
};
typedef struct node
{
DataType data;
struct node *pNext;
}LLSNode;
class LinkedListStorage
{
public:
LLSNode *pHead;
LinkedListStorage()
{
pHead = NULL;
}
void insertData(DataType data)
{
LLSNode *p = (LLSNode *)malloc(sizeof(LLSNode));
p->data = data;
p->pNext = pHead;
pHead = p;
}
LLSNode *find(DataType data)
{
LLSNode *p = pHead;
while(p)
{
if(p->data == data)
return p;
p = p->pNext;
}
return NULL;
}
};
typedef struct node2
{
DataType data;
struct node2 *lchild,*rchild;
}BSTNode;
class BinarySortTree
{
public:
BSTNode *pRoot;
BinarySortTree()
{
pRoot = NULL;
}
void insertData(DataType data)
{
BSTNode *f,*p = pRoot;
while(p)
{
f = p;
if(data < p->data)
p = p->lchild;
else
p = p->rchild;
}
p = (BSTNode *)malloc(sizeof(BSTNode));
p->data = data;
p->lchild = NULL;
p->rchild = NULL;
if(pRoot == NULL)
pRoot = p;
else
if(data < f->data)
f->lchild = p;
else
f->rchild = p;
}
BSTNode *find(DataType data)
{
if(pRoot == NULL)
return NULL;
else
return recursion(data,pRoot);
}
BSTNode *recursion(DataType data,BSTNode *p)
{
if(data == p->data||p == NULL)
return p;
else if(data < p->data)
return recursion(data,p->lchild);
else
return recursion(data,p->rchild);
}
void print()
{
if(pRoot != NULL)
printR(pRoot);
}
void printR(BSTNode *p)
{
if(p->lchild != NULL)
printR(p->lchild);
printf("%d\t",p->data);
if(p->rchild != NULL)
printR(p->rchild);
}
};
class CPUTime
{
public:
_int64 getCPUCycleCount(void)
{
_asm _emit 0x0F
_asm _emit 0x31
}
long long arr[1000];
int count;
long long lastCPUCycleCount;
int randCount;
CPUTime()
{
for(int i = 0;i < 1000;i++)
arr[i] = 0;
count = -1;
lastCPUCycleCount = getCPUCycleCount();
randCount = 0;
}
void setTimePoint()
{
arr[++count] = getCPUCycleCount()-lastCPUCycleCount;
lastCPUCycleCount = getCPUCycleCount();
}
int rand()
{
randCount++;
int temp = getCPUCycleCount()%20000;
return (temp*(randCount+temp))%10007;
}
};
int main()
{
SequentialStorage ss;
OrderlySequenceStorage oss;
LinkedListStorage lls;
BinarySortTree bst;
DataType temp1;
CPUTime cpuTime;
for(int i = 0;i < 2000;i++)
{
temp1 = cpuTime.rand();
ss.insertData(temp1);
oss.insertData(temp1);
lls.insertData(temp1);
bst.insertData(temp1);
}
DataType temp[7];
for(int i = 0;i < 7;i++)
temp[i] = ss.data[cpuTime.rand()%2000];
cpuTime.setTimePoint();
for(int i = 0;i < 7;i++)
{
ss.find(temp[i]);
cpuTime.setTimePoint();
}
for(int i = 0;i < 7;i++)
{
oss.find(temp[i]);
cpuTime.setTimePoint();
}
for(int i = 0;i < 7;i++)
{
oss.find2(temp[i]);
cpuTime.setTimePoint();
}
for(int i = 0;i < 7;i++)
{
lls.find(temp[i]);
cpuTime.setTimePoint();
}
for(int i = 0;i < 7;i++)
{
bst.find(temp[i]);
cpuTime.setTimePoint();
}
int count = 1;
printf("各项存储结构查找已存在数据的时间（cpu周期）：\n");
printf("储存方式\t\t数据1\t数据2\t数据3\t数据4\t数据5\t数据6\t平均\n");
int a[9];
for(int i = 1;i < 8;i++)
a[i] = (int)cpuTime.arr[count++];
a[8] = (a[1]+a[2]+a[3]+a[4]+a[5]+a[6]+a[7])/7;
printf("顺序存储\t\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",a[1],a[2],a[3],a[4],a[5],a[6],a[8]);
for(int i = 1;i < 8;i++)
a[i] = (int)cpuTime.arr[count++];
a[8] = (a[1]+a[2]+a[3]+a[4]+a[5]+a[6]+a[7])/7;
printf("有序顺序存储(普通)\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",a[1],a[2],a[3],a[4],a[5],a[6],a[8]);
for(int i = 1;i < 8;i++)
a[i] = (int)cpuTime.arr[count++];
a[8] = (a[1]+a[2]+a[3]+a[4]+a[5]+a[6]+a[7])/7;
printf("有序顺序存储(二分法)\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",a[1],a[2],a[3],a[4],a[5],a[6],a[8]);
for(int i = 1;i < 8;i++)
a[i] = (int)cpuTime.arr[count++];
a[8] = (a[1]+a[2]+a[3]+a[4]+a[5]+a[6]+a[7])/7;
printf("链表存储\t\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",a[1],a[2],a[3],a[4],a[5],a[6],a[8]);
for(int i = 1;i < 8;i++)
a[i] = (int)cpuTime.arr[count++];
a[8] = (a[1]+a[2]+a[3]+a[4]+a[5]+a[6]+a[7])/7;
printf("二叉排序树存储\t\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",a[1],a[2],a[3],a[4],a[5],a[6],a[8]);
system("pause");
}
//我按照课题的要求写的c++具体实现的代码，楼主可以编译运行着试试，你可以参考一下
//我这搜索的是储存结构里已存在的数据，你也可以按题目的要求用随机生成的数据
//楼主留下qq吧，我等会把流程图发给你
//至于其他的，楼主还是自己试着写写看吧
另外,站长团上有产品团购,便宜有保证