查找

静态查找：查找时，只查找读取

顺序表上查找

无序表上查找，设置位置0为岗哨，从后往前查找，查找长度为(n+1)/2

有序表上查找，使用二分查找，平均查找长度为 log2(n+1)-1

索引顺序表上查找，索引表将顺序表分别分割为若干块，顺序表按块有序，查找长度为 (n/s+s)/2+1

动态查找

二叉排序树：或为空树或具有下列性质：

1.若左子树不为空，则左子树上的所有结点的键值均小于它的根结点的键值，

2.若右子树不为空，则右子树上的所有结点的键值均小于它的根结点的键值，

3.根的左子树，右子树均为二叉排序树

中序遍历即可得到升序序列

查找长度与树的形态有关,介于O(n)和log2(n)之间

散列表：使数据的存储位置与键值之间建立某件联系，减少比较次数

散列函数：数据元素的键值和存储位置之间建立的对应关系H

散列表，散列地址，

冲突 k1!=k2 H(k1)=H(k2),则称k1,k2是相对H的同义词

堆积：非同义词之间对同一散列地址的争夺现象

常用散列法：数字分析法，保留余数法,平方取中发，基数转换法

解决冲突的方法：线性探测法 (地址+1) ，二次探测法(+-k2),链地址法，多重散列法，公共溢出区法

排序：内部排序，外部排序

内部排序：插入排序，交换排序，选择排序，归并排序

插入排序：直接插入排序 O(n2)，折半插入排序，表插入排序，希尔排序 nlog2n n^s

直接插入排序：依次将每个记录插入到一个已排好序的有序表中去，得到一个新的，记录数增加1的有序表

void straightInertSort(List R,int n)

{

int i,j;

for(i=2;i<n;i++)

{

R[0]=R[i];

j=i-1;

while(R[0]<R[j])

{

R[j+1]=R[j];

j--;

}

R[j+1]=R[0];

}

}

希尔排序：以n/2为步长分割List,排序分割的List,再以原步长/2，重复执行，知道步长为0 结束排序。

交换排序:冒泡排序O(n2) ，快速排序 (不稳定，nlog2n  n2)

冒泡排序：是一种交换排序方法，首先将第一个记录和第二个记录比较，若为逆序，则将两个记录交换，然后比较第二个和第三个，依次类推，直到完成第n-1和第n个比较交换位置。此为第一趟起泡。结果使键值最大的记录移动到第n个位置上。然后对前n-1个记录进行同样的操作。

void BubbleSort(List R,int n)

{

int i,j,temp,endSort;

for(i=1;i<=n-1;i++)

{

endSort=0;

for(j=1;j<=n-1-i;j++)

{

if(R[j].key>R[j+1].key)

{

temp=R[j];

R[j]=R[j+1];

R[j+1]=temp;

endSort=1;

}

}

if(endSort==0)break;

}

}

快速排序：

void QuickSort(List R,int low,int high)

{

if(low<high)

{

temp=QuickPartition(R,low,high);

QuickSort(R,low,temp-1);

QuickSort(R,temp+1,high);

}

}

int QuickPartition(List R,int low,int high)

{

x=R[low];

while(low<high)

{

while(low<high&&R[high].key>x.key)

{

high--;

}

R[low]=R[high];

while(low<high&&R[low].key<x.key)

{

low++;

}

R[high]=R[low];

}

R[low]=x;

return low;

}

选择排序：直接选择排序（不稳定 O(n^2)），堆排序(不稳定 nlog2n)

直接选择排序：在第i次选择操作中，通过第n-i次键值比较，从n-i+1个记录中，选出最小的键值记录，并和第i个记录交换。

void SelectSort(List R,int n)

{

int min,i,j

for(i=1;i<=n-1;i++)

{

min=i;

for(j=i+1;j<=n;j++)

{

if(R[j].key<R[min].key) min=j;

if(min!=i) swap(R[min],R[i]);

}

}

}

堆排序：最小堆是一颗以k1为根的完全二叉树，任一结点都不大于它的两个孩子的值。

void HeapStort(List R,int n)

{

int i;

for(i=n/2;i>=1;i++)

Shit(R,i,n);

for(i=n;i>=2;i--)

{

Swap(R[1],R[i]);

Shit(R,1,i-1);

}

}

　　　　　　　　List为完全二叉树 顺序结构存储

　　　　　　　　K为 根结点序号

　　　　　　　　m为 顺序存储结构最后一个结点位置

void Shit(List R,int k,int m)

{

int i,j,x;

List t;

i=k;j=i*2;

x=R[k].key;

t=R[k];

while(j<=m)

{

if(j<m)&&R[j].key>R[j+1].key)

{

j++;

}

if(x<R[j].key) break;

else

{

R[i]=R[j];

i=j;

j=2*i;

}

}

}

归并排序：有序序列的归并(不稳定的 nlog2n)，二路归并排序(稳定的 nlog2n)

要求待排序序列是有若干有序子序列组成

有序序列的归并: a h m n

二路归并排序:有n个有序的子序列，每个序列的长度为1，首先将相邻的两个记录合并，得到较大的n/2个较大的有序子序列，再将相邻的子序列两两合并，得到[[n/2]/2]个有序的子序列，如此反复，直到得到一个长度为n的有序序列位置。

排序算法中，没有那种是最优的，就时间复杂度而言，比较简单的排序算法，直接插入，直接选择，冒泡排序等，所需时间复杂度为O(n^2).但是在某些情况下，如初始序列已基本有序，直接插入算法和冒泡算法时间复杂度为O(n)。就待排序列的记录数量而言，当记录数较小时，尽量选择简单的排序算法，当n比较大时并且记录无规律可言时，采用快速排序，堆排序，归并排序等时间复杂度较低的算法。快速排序，直接选择排序，堆排序是不稳定的算法。