7.26数据结构day5

1. 优化后的冒泡排序程序：

#include <stdio.h>
#include <string.h>

void pop_sort(int *arr,int len){
	int i,j;
	int flag=0;
	for(j=0;j<len;j++){
		flag=0;
		for(i=0;i<len-j-1;i++){
			if(arr[i]>arr[i+1]){
				int temp=0;
				temp=arr[i+1];
				arr[i+1]=arr[i];
				arr[i]=temp;
				flag=1;
			}
		}
		if(flag==0){
		break;
		}
	}
}

int main(int argc, const char *argv[])
{
	int arr[8]={198,289,98,357,85,170,232,110};
	int len=sizeof(arr)/sizeof(int);
	pop_sort(arr,len);
	for(int i=0;i<len;i++){
		printf("%d\t",arr[i]);
	}
	return 0;
}

运行的代码结果：

2.使用优化后的选择排序编程：

 

#include <stdio.h>

void select_sort(int* arr,int len){
	int i,j;
	for(i=0;i<len;i++){
		int index=i;
		for(j=i+1;j<len;j++){
			if(arr[index]>arr[j]){
				index=j;
			}
		}
		if(index!=i){
			int temp=0;
			temp=arr[index];
			arr[index]=arr[i];
			arr[i]=temp;
		}
	}
}

int main(int argc, const char *argv[])
{
	
	int arr[8]={198,289,98,357,85,170,232,110};
	int len=sizeof(arr)/sizeof(int);
	select_sort(arr,len);

	for(int i=0;i<len;i++){
		printf("%d\t",arr[i]);
	}

	return 0;
}

代码结果：

3.使用直接插入进行编程：

#include <stdio.h>


void insert_sort(int *arr,int len){
	int i,j,temp;
	for(i=1;i<len;i++){
		temp=arr[i];                   //temp=7
		for(j=i;j>0&&arr[j-1]>temp;j--){ 
			arr[j]=arr[j-1];             //arr[1]=8
		}
		arr[j]=temp;                    //arr[0]=7
	}
}


int main(int argc, const char *argv[])
{
	int arr[8]={198,289,98,357,85,170,232,110};
	int len=sizeof(arr)/sizeof(int);
	insert_sort(arr,len);

	for(int i=0;i<len;i++){
		printf("%d\t",arr[i]);
	}
	return 0;
}

 代码结果：

4.快速排列进行排列：

#include <stdio.h>


int part(int* arr,int low,int high){
	int x=arr[low];
	while(low<high){
		while(arr[high]>=x&&low<high){
			high--;
		}
		arr[low]=arr[high];
		while(arr[low]<=x &&low<high){
			low++;
		}
		arr[high]=arr[low];
	}
	arr[low]=x;
	return low;
}


void quick_sort(int* arr,int low,int high){
	if(low<high){
		int mid=part(arr,low,high);
		quick_sort(arr,low,mid-1);
		quick_sort(arr,mid+1,high);
	}
}


int main(int argc, const char *argv[])
{
	int arr[8]={198,289,98,357,85,170,232,110};
	int len=sizeof(arr)/sizeof(int);

	quick_sort(arr,0,len-1);
	for(int i=0;i<len;i++){
		printf("%d\t",arr[i]);
	}
	return 0;
}

 代码的实现：

2.使用哈希存储将数据存入哈希表中，并进行查找

 

哈希存储：

.h头文件：

#ifndef _HASH_H_
#define _HASH_H_

#define N 10
#define P 13

typedef int datatype;
typedef struct Node{
	datatype data; 				//数据域
	struct Node* next;  		//指针域
}Node;

//初始化哈希表
void init_hash(Node* hash[]);

//将元素存入哈希表
int insert_hash(Node* hash[],int x);

//查看哈希表的函数
void show_hash(Node* hash[]);

//哈希查找
void search_hash(Node* hash[],int key);

#endif

 需要调用到的自定义函数：

#include <stdio.h>
#include <stdlib.h>
#include "hash.h"


//初始化哈希表
void init_hash(Node* hash[]){
	for(int i=0;i<P;i++){
		hash[i]=NULL;
	}
	printf("初始化成功\n");
}


//将元素存入哈希表
int insert_hash(Node* hash[],int x){
	int index=x%P;     //定位要存储的链表
	//将数据封装成结点
	Node* q=(Node*)malloc(sizeof(Node));
	if(q==NULL){
		printf("封装失败\n");
	}

	q->data=x;
	q->next=NULL;

	//使用头插法将结点放入链表hash[index]
	q->next=hash[index];
	hash[index]=q;

}


//查看哈希表的函数
void show_hash(Node* hash[]){
	for(int i=0;i<P;i++){
		printf("%d: ",i);
		Node *q=hash[i]; //定义遍历指针
		while(q!=NULL){
			printf("%d-->",q->data);
			q=q->next;
		}
		printf("NULL\n");
	}
}

//哈希查找
void search_hash(Node* hash[],int key){
	int index=key%P;  //定位要查找的值的所在链表
	//定义遍历指针遍历链表
	Node* q=hash[index];
	while(q!=NULL&&q->data!=key){
		q=q->next;
	}
	//对找到的结点判断
	if(NULL==q){
		printf("查找失败\n");
	}else {
		printf("查找数据在表中\n");
	}
}

main函数：

#include <stdio.h>
#include <stdlib.h>
#include "hash.h"

int main(int argc, const char *argv[])
{
	int arr[N]={25,51,8,22,26,62,11,16,54,41};
	
	Node *hash[P];     //哈希表
	
	init_hash(hash); 	//初始化哈希

	//将序列元素存入哈希表3
	for(int i=0;i<P;i++){
		insert_hash(hash,arr[i]);
	}
	
	//遍历
	show_hash(hash);
	search_hash(hash,26);
	return 0;
}