数据结构中一些常用的算法

1.0 快速排序

1. //快速排序  

2. 1．先从数列中取出一个数作为基准数。

   2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

   3．再对左右区间重复第二步，直到各区间只有一个数。

   
   
3. void quick_sort(int s[], int l, int r)  
4. {  
5.     if (l < r)  
6.     {  
7.         //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1  
8.         int i = l, j = r, x = s[l];  
9.         while (i < j)  
10.         {  
11.             while(i < j && s[j] >= x) // 从右向左找第一个小于x的数  
12.                 j--;    
13.             if(i < j)   
14.                 s[i++] = s[j];  
15.               
16.             while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数  
17.                 i++;    
18.             if(i < j)   
19.                 s[j--] = s[i];  
20.         }  
21.         s[i] = x;  
22.         quick_sort(s, l, i - 1); // 递归调用   
23.         quick_sort(s, i + 1, r);  
24.     }  
25. }

2.0 折半查找（二分查找）

int binary_search(const int arr[],int low,int high,int key)

{

int mid=low+(high-low)/2;

if (low>high)

return -1;

else {

if (arr[mid]==key)

return mid;

else if(arr[mid]>key)

return binary_search(arr,low,mid-1,key);

else

return binary_search(arr,mid+1,high,key);

}

}

3.0 遍历二叉树

递归遍历

1. void preorder(bintree t){  
2.     if(t){  
3.         printf("%c ",t->data);  
4.         preorder(t->lchild);  
5.         preorder(t->rchild);  
6.     }  
7. }

非递归遍历

1. #define SIZE 100  
2. typedef struct seqstack{  
3.     bintree data[SIZE];  
4.     int tag[SIZE];   //为后续遍历准备的  
5.     int top;     //top为数组的下标  
6. }seqstack;  
7.   
8. void push(seqstack *s,bintree t){  
9.   
10.     if(s->top == SIZE){  
11.         printf("the stack is full\n");  
12.     }else{  
13.         s->top++;  
14.         s->data[s->top]=t;  
15.     }  
16. }  
17.   
18. bintree pop(seqstack *s){  
19.     if(s->top == -1){  
20.         return NULL;  
21.     }else{  
22.         s->top--;  
23.         return s->data[s->top+1];  
24.     }  
25. }

层次遍历

一）生成队列：

1. #define MAX 1000  
2.   
3. typedef struct seqqueue{  
4.     bintree data[MAX];  
5.     int front;  
6.     int rear;  
7. }seqqueue;  
8.   
9.   
10. void enter(seqqueue *q,bintree t){  
11.     if(q->rear == MAX){  
12.         printf("the queue is full!\n");  
13.     }else{  
14.         q->data[q->rear] = t;  
15.         q->rear++;  
16.     }  
17. }  
18.   
19. bintree del(seqqueue *q){  
20.     if(q->front == q->rear){  
21.         return NULL;  
22.     }else{  
23.         q->front++;  
24.         return q->data[q->front-1];  
25.     }  
26. } 

二）便利实现：

1. void level_tree(bintree t){  
2.     seqqueue q;  
3.     bintree temp;  
4.     q.front = q.rear = 0;  
5.     if(!t){  
6.         printf("the tree is empty\n");  
7.         return ;  
8.     }  
9.     enter(&q,t);  
10.     while(q.front != q.rear){  
11.         t=del(&q);  
12.         printf("%c ",t->data);  
13.         if(t->lchild){  
14.             enter(&q,t->lchild);  
15.         }  
16.         if(t->rchild){  
17.             enter(&q,t->rchild);  
18.         }  
19.     }  
20. }

4.0 二叉树查找

1. bintree search_tree(bintree t,datatype x){  
2.     if(!t){  
3.         return NULL;  
4.     }  
5.     if(t->data == x){  
6.         return t;  
7.     }else{  
8.         if(!search_tree(t->lchild,x)){  
9.             return search_tree(t->rchild,x);  
10.         }  
11.         return t;  
12.     }  
13. }

5.0 冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

void bubble_sort(inta[],int n);

 

void bubble_sort(int a[],int n) //n为数组a的元素个数

{

     int i,j,temp;

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

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

         {

             if (a[i]>a[i+1]) //数组元素大小按升序排列

             {

                 temp=a[i];

                 a[i]=a[i+1];

                 a[i+1]=temp;

             }

         }

}

int main()

{

     int number[SIZE]={95,45,15,78,84,51,24,12};

     int i;

     bubble_sort(number,SIZE);

     for (i=0;i<SIZE;i++)

     {

         printf ( "%d" ,number[i]);

     }

     printf ( "\n" );

}

6.0 堆排序

1.0） 初始化操作：将R[1..n]构造为初始堆；

2.0）每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆（亦称重建堆）

//本函数功能是：根据数组array构建大根堆

 

void 　HeapAdjust( int 　array[], int 　i, int 　nLength)

{

　 int 　nChild;

　 int 　nTemp;

　 for (;2*i+1<nLength;i=nChild)

　{

　 //子结点的位置=2*（父结点位置）+1

　nChild=2*i+1;

　 //得到子结点中较大的结点

　 if (nChild<nLength-1&&array[nChild+1]>array[nChild])

　++nChild;

　 //如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点

　 if (array[i]<array[nChild])

　{

　nTemp=array[i];

　array[i]=array[nChild];

　array[nChild]=nTemp;

　}

　 else

　 //否则退出循环

　 break ;

　}

}

 

//堆排序算法

void HeapSort(int array[],int length)

{

int tmp;

//调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素

//length/2-1是最后一个非叶节点，此处"/"为整除

for (int i=length/2-1;i>=0;--i)

HeapAdjust(array,i,length);

//从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素

for (int i=length-1;i>0;--i)

{

//把第一个元素和当前的最后一个元素交换，

//保证当前的最后一个位置的元素都是在现在的这个序列之中最大的

///Swap(&array[0],&array[i]);

tmp=array[i];

array[i]=array[0];

array[0]=tmp;

//不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值

HeapAdjust(array,0,i);

}

}