7月25日数据结构作业 哈希表以及一系列排序算法

哈希表头文件 

 #ifndef __HAXI__
 #define __HAXI__
 
 typedef struct Node
 {
     int data;           //数据域
     struct Node *next;  //指针域
 
 }Node;
 
 //初始化哈希表
 void csh(Node *haxi[], int n);
 
 //将数据存入哈希表
 void shuru(Node *haxi[],int key);
 
 //输出哈希表内容
 void shuchu(Node *haxi[], int n);
 
 //哈希查找
 void chazhao(Node *haxi[], int key);
 
                                             
 
 
 
 #endif
                                             
                                             
                                             

哈希表功能函数

#include <stdio.h>                                                    
#include <stdlib.h>                                                   
#include "./day2501.h"                                                
                                                                      
                                                                      
//初始化哈希表                                                        
void csh(Node *haxi[],int n)                                          
{                                                                     
    int i = 0;                                                        
    for(i=0; i<n; i++)                                                
    {                                                                 
        haxi[i] = NULL;                                               
    }                                                                 
}                                                                     
                                                                      
//将数据存入哈希表                                                    
void shuru(Node *haxi[],int key)                                      
{                                                                     
    int pos = key%13; //通过哈希函数找到要存储的链表位置              
    Node *p = (Node *)malloc(sizeof(Node));//申请节点存放数据         
    if(NULL == p)                                                     
    {                                                                 
        printf("节点申请失败\n");                                     
        return ;                                                      
    }                                                                 
    p->data = key;                                                    
    p->next = NULL;                                                   
                                                                      
    //头插法将数据放入表中                                            
    p->next = haxi[pos];                                              
    haxi[pos] = p;                                                    
}                                                                     
                                                                      
//输出哈希表内容                                                      
void shuchu(Node *haxi[], int n)                                      
{                                                                     
    int i = 0;                                                        
    Node *q = haxi[0];                                                
    for(i=0; i<n; i++)                                                
    {                                                                 
        q = haxi[i];                                                  
        printf("%d: ",i);                                             
        while(q != NULL)                                              
        {                                                             
        //  printf("%d: ",i);                                         
            printf("%d->>",q->data);                                  
            q = q->next;                                              
        }                                                             
        printf("NULL\n");                                             
                                                                      
    }                                                                 
                                                                      
}                                                                     
                                                                      
//哈希查找                                                            
void chazhao(Node *haxi[], int key)                                   
{                                                                     
    int pos = key%13; //通过哈希函数 查找关键字所在的链条             
    Node *q = haxi[pos];                                              
    while(q != NULL && q->data != key)                                
    {                                                                 
        q = q->next;                                                  
                                                                      
    }                                                                 
    if(NULL == q)                                                     
    {                                                                 
        printf("你要查的数据不在表中\n");                             
                                                                      
    }else                                                             
    {                                                                 
        printf("你要查的数据在表中\n");                               
    }                                                                 
}                                                                     
                                                                      
                                                                      
                                                                      
                                                                      
                                                                      
                                                                      
                                                                      
                                                                      
                                                                      
                                                                      
                                                                      

哈希表主函数

#include <stdio.h>                                         
#include <stdlib.h>                                        
#include "./day2501.h"                                     
int main(int argc, const char *argv[])                     
{                                                          
    int arr[10] = {25,51,8,22,26,67,11,16,54,41};          
    Node *haxi[13]; //定义哈希表                           
    csh(haxi,13);                                          
    int i = 0;                                             
    for(i=0; i<10; i++)        //循环调用哈希表插入函数，把数据通过哈希函数插入哈希表中                         
    {                                                      
        shuru(haxi,arr[i]);                                
    }                                                      
    shuchu(haxi, 13);      //测试查找                                
    chazhao(haxi, 100);    //测试查找                       
                                                           
                                                           
                                                           
    return 0;                                              
}                                                          
                                                           

算法头文件

#ifndef __PAIXU__                    
#define __PAIXU__

//冒泡排序
void maopao(int *s, int n);

//选择排序
void xuanze(int *s, int n);

//插入排序
void charu(int *s, int n);

//快速排序
void kp(int *s, int low, int high);

//快速排序一趟排序
int yici(int *s, int low, int high);

//遍历
void bianli(int *s, int n);

#endif
                                     

 算法功能函数

 #include <stdio.h>                                       
 #include <stdlib.h>                                      
 #include "./day2502.h"                                   
                                                          
 //冒泡排序                                               
 void maopao(int *s, int n)                               
 {                                                        
     int i = 0, j = 0, temp = 0, flag = 0;                
     for(i=1; i<n; i++)                                   
     {                                                    
         flag = 0;                                        
         for(j=0; j<n-i; j++)                             
         {                                                
             if(s[j] > s[j+1])                            
             {                                            
                 temp = s[j];                             
                 s[j] = s[j+1];                           
                 s[j+1] = temp;                           
                 flag = 1;                                
             }                                            
         }                                                
         if(0 == flag)                                    
         {                                                
             break;  //说明排完了                         
         }                                                
     }                                                    
 }                                                        
                                                          
 //选择排序                                               
 void xuanze(int *s, int n)                               
 {                                                        
     int i = 0, j = 0, min = 0, temp = 0;                 
     for(i=0; i<n; i++)                                   
     {                                                    
         min = i;                                         
         for(j=i+1; j<n; j++)                             
         {                                                
             if(s[min] > s[j])                            
             {                                            
                 min = j;                                 
             }                                            
         }                                                
         if(min != i)                                     
         {                                                
             temp = s[min];                               
             s[min] = s[i];                               
             s[i] = temp;                                 
         }                                                
     }                                                    
                                                          
 }                                                        
                                                          
 //插入排序                                               
 void charu(int *s, int n)                                
 {                                                        
     int i = 0, j = 0, temp = 0;                          
     for(i=1; i<n; i++)                                   
     {                                                    
         temp = s[i];                                     
         for(j=i; j>0 && temp<s[j-1]; j-- )               
         {                                                
             s[j] = s[j-1];                               
         }                                                
         s[j] = temp;                                     
     }                                                    
 }                                                        
                                                          
 //快速排序                                               
 void kp(int *s, int low, int high)                       
 {                                                        
     int mid;                                             
     if(low<high)                                         
     {                                                    
         mid = yici(s, low, high);                        
         kp(s, low, mid-1); //将基准的左边进行快排        
         kp(s, mid+1, high);//将基准的右边进行快排        
     }                                                    
 }                                                        
                                                          
 //快速排序一趟排序                                       
 int yici(int *s, int low, int high)                      
 {                                                        
     int x = s[low]; //记录一下基准                       
     while(low < high)                                    
     {                                                    
         while(s[high]>=x && low<high)                    
         {                                                
             high--;                                      
         }                                                
         s[low] = s[high];                                
                                                          
         while(s[low]<=x && low<high)                     
         {                                                
             low++;                                       
         }                                                
         s[high] = s[low];                                
     }                                                    
     s[low] = x;  //再把基准塞回去                        
     return low;  //将基准的下标返回去                    
                                                          
 }                                                        
                                                          
 //遍历                                                   
 void bianli(int *s, int n)                               
 {                                                        
     int i = 0;                                           
     for(i=0; i<n; i++)                                   
     {                                                    
         printf("%d ",s[i]);                              
     }                                                    
     putchar(10);                                         
 }                                                        
                                                          

 算法主函数

1 #include <stdio.h>                                       
2 #include <stdlib.h>                                      
3 #include "./day2502.h"                                   
4 int main(int argc, const char *argv[])                   
5 {                                                        
6     int s[8] = {198,289,98,357,85,170,232,110};          
7     //冒泡排序                                           
8     maopao(s,8);                                         
9     //遍历                                               
0     bianli(s, 8);                                        
1                                                          
2     //选择排序                                           
3     xuanze(s, 8);                                        
4     //遍历                                               
5     bianli(s, 8);                                        
6                                                          
7     //插入排序                                           
8     charu(s, 8);                                         
9     //遍历                                               
0     bianli(s, 8);                                        
1                                                          
2     //快速排序                                           
3     kp(s, 0, 7);                                         
4     //遍历                                               
5     bianli(s, 8);                                        
6                                                          
7                                                          
8     return 0;                                            
9 }