C语言实现九种排序

最新推荐文章于 2019-08-14 21:03:02 发布
最新推荐文章于 2019-08-14 21:03:02 发布
阅读量186 收藏 3
点赞数
分类专栏： 数据结构与算法基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40144572/article/details/85080530
版权

文章目录

C语言实现九种排序

头文件

#ifndef _MYSORT_H_
#define _MYSORT_H_
/*网站 ： sorting.at*/

typedef enum {UP,DOWN} SORTWAY;


void myswap(int *a,int *b);
void arrayswap(int a[],int i,int j);



void myprint(int a[],int len);

/************************[r_bubble_sort]************************************
函数功能：
				冒泡排序 ===>非递归实现
函数参数：
函数返回值：
*************************[r_bubble_sort]************************************/
void bubble_sort(int array[], int len_array,SORTWAY way);

/************************[r_bubble_sort]************************************
函数功能：
				冒泡排序 ===>递归实现
函数参数：
函数返回值：
*************************[r_bubble_sort]************************************/
void r_bubble_sort(int array[], int len_array,SORTWAY way);




/************************[cocktail_sort]************************************
函数功能：
				鸡尾酒排序(双向冒泡排序) ===>非递归实现
函数参数：
函数返回值：
*************************[cocktail_sort]************************************/
void cocktail_sort(int array[], int len_array,SORTWAY way);
/************************[r_cocktail_sort]************************************
函数功能：
				鸡尾酒排序(双向冒泡排序) ===>递归实现
函数参数：
函数返回值：
*************************[r_cocktail_sort]************************************/
void r_cocktail_sort(int array[], int left,int right,SORTWAY way);



/************************[selection_sort]************************************
函数功能：
				选择排序 ===>非递归实现
				算法思想：在数组中找最小或最大数的下标，其值与数组第一个元素交换
函数参数：
函数返回值：
*************************[selection_sort]************************************/
void selection_sort(int array[], int len_array,SORTWAY way);
void r_selection_sort(int array[], int len_array,int limit_index,SORTWAY way);


/************************[Insertion_sort]************************************
函数功能：
				插入排序 ===>非递归实现
				算法思想：将一个数插入到有序数组中
							1、复制性移动
							2、插入数据
			
函数参数：
				[in]array     :  需要排序的数组
				[in]len_array :
				[in]way       :
函数返回值：
*************************[Insertion_sort]************************************/
void Insertion_sort(int array[], int len_array,SORTWAY way);


/************************[Insertion_DIV_sort]************************************
函数功能：
				插入排序 ===>非递归实现 (二分法)
				算法思想：将一个数插入到有序数组中
							1、复制性移动
							2、插入数据
			
函数参数：
				[in]array     :  需要排序的数组
				[in]len_array :	 
				[in]way       :
函数返回值：
*************************[Insertion_DIV_sort]************************************/
void Insertion_DIV_sort(int array[], int len_array,SORTWAY way);

/************************[Shell_sort]************************************
函数功能：
				希尔排序 ===>分组插入排序
				算法思想：	多次将待排序数组分组，每组进行直接插入排序
							将一个数插入到有序数组中
							1、复制性移动
							2、插入数据
			
函数参数：
				[in]array     :  需要排序的数组
				[in]len_array :	 
				[in]way       :
函数返回值：
*************************[Shell_sort]************************************/
void Shell_sort(int array[], int len_array,SORTWAY way);

/************************[Heap_sort]************************************
函数功能：
				堆排序 
				算法思想：
						1、将数组调整成二叉堆的形式  （从第一个非叶结点的结点开始，从右到左，从下到上进行跳调整）
						2、进行排序：将第一个节点的值与最后一个节点交换，然后“去掉”（长度减一）这个节点，在进行堆调整。重复操作至长度为1
函数参数：
				[in]array     :  需要排序的数组
				[in]len_array :	 
				[in]way       :
函数返回值：
*************************[Heap_sort]************************************/
void Heap_sort(int array[], int len_array,SORTWAY way);

/************************[merge_sort]************************************
函数功能：
				按顺序合并两个数组

函数参数：
				[in]array     :  需要排序的数组
				[in]len_array :	 
				[in]way       :
函数返回值：
*************************[merge_sort]************************************/
void merge(int array[],int left,int mid,int right,int*tmp,SORTWAY way);
/************************[merge_sort]************************************
函数功能：
				归并排序  ===>递归实现
				算法思想：
						 
函数参数：		
				[in]array     :  需要排序的数组
				[in]left      :	 数组的左边界
				[in]right     :	 数组的右边界
				[in]tmp       :  临时数组 ，用来暂存合并后的数据
				[in]way       :  way等于UP   为升序
								 way等于DOWN 为降序
函数返回值：
*************************[merge_sort]************************************/
void r_merge_sort(int array[], int left,int right,int tmp[],SORTWAY way);


/************************[partition]************************************
函数功能：
				分区确定基准值的下标
				
函数参数：
				[in]array     :  需要分区的数组
				[in]left      :	 数组的左边界
				[in]right     :	 数组的右边界
				[in]way       :  way等于UP   为升序
								 way等于DOWN 为降序
函数返回值：
				返回分区后的基准值的下标
*************************[partition]************************************/
int partition(int array[],int left,int right,SORTWAY way);
/************************[r_quick_sort]************************************
函数功能：
				快速排序  ‘=====>递归实现
				算法思想：选取一个基准值，将数组按基准值分成两部分，一部分比他小，一部分比他大
						  核心操作就是分区，确定基准值的位置 ，然后左右两边在进行快排

函数参数：
				[in]array     :  需要排序的数组
				[in]left      :	 数组的左边界
				[in]right     :	 数组的右边界
				[in]way       :  way等于UP   为升序
								 way等于DOWN 为降序
函数返回值：
				
*************************[r_quick_sort]************************************/
void r_quick_sort(int array[], int left,int right,SORTWAY way);

#endif//_MYSORT_H_

C文件

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

void myswap(int *a,int *b)
{
	int tmp = *a;
	*a 		= *b;
	*b 		= tmp ;
}

void arrayswap(int a[],int i,int j)
{
	int tmp = a[i];
	a[i]    = a[j];
	a[j]    = tmp;
}

void myprint(int a[],int len)
{	
	int i;
	for(i=0;i<len;i++)
		printf("%4d",a[i]);
	printf("\n");
}


void bubble_sort(int array[], int len_array,SORTWAY way)
{
	
	int i,j;
	for(i=0;i<len_array-1;i++)
	{
		for(j=0;j<len_array-1-i;j++)
		{
		
			if(UP == way) //升序
			{
				if(array[j]<array[j+1])
				{
				    int tmp        = array[j];
					array[j]   = array[j+1];
					array[j+1] = tmp; 
				}
			}
			else
			{
				if(array[j]>array[j+1])
				{
				    int tmp        = array[j];
					array[j]   = array[j+1];
					array[j+1] = tmp; 
				}
			}
		}
	}
}


void r_bubble_sort(int array[], int len_array,SORTWAY way)
{
	
	int i;
	for(i=0;i<len_array-1-i;i++)
	{
		if(UP == way)
		{
			if(array[i]<array[i+1])
			{
				int tmp    = array[i];
				array[i]   = array[i+1];
				array[i+1] = tmp; 
			}
		}
		else
		{
			if(array[i]>array[i+1])
			{
				int tmp    = array[i];
				array[i]   = array[i+1];
				array[i+1] = tmp; 
			}
		}
	}
	
	r_bubble_sort(array,len_array-1,way);

}



void cocktail_sort(int array[], int len_array,SORTWAY way)
{
	
	int left  = 0;
	int right = len_array-1;
	
	
	while(left < right)
	{
		if(UP == way)
		{
			//从左到右遍历，找到最大的数，放到最后面
			int i;
			for(i = left ;i<right;i++)
			{
				if(array[i]>array[i+1])
				{
					myswap(&array[i],&array[i+1]);
				}
			}
			right--;
			
			//从右到左遍历，找到最小的数，放到最前面	
			for(i = right ;i>left;i--)
			{
				if(array[i]<array[i-1])
				{
					myswap(&array[i],&array[i-1]);
				}
			}
			left++;
		}
		else
		{
			//从左到右遍历，找到最小的数，放到最后面
			int i;
			for(i = left ;i<right;i++)
			{
				if(array[i]<array[i+1])
				{
					myswap(&array[i],&array[i+1]);
				}
			}
			right--;
			
			//从右到左遍历，找到最大的数，放到最前面
			for(i = right ;i>left;i--)
			{
				if(array[i]>array[i-1])
				{
					myswap(&array[i],&array[i-1]);
				}
			}
			left++;
		}

	}	
}

void r_cocktail_sort(int array[], int left,int right,SORTWAY way)
{
	//退出条件
	if(left >= right)
		return;
	
	
	if(UP == way)
	{
		//从左到右遍历，找到最大的数，放到最后面
		int i;
		for(i = left ;i<right;i++)
		{
			if(array[i]>array[i+1])
			{
				myswap(&array[i],&array[i+1]);
			}
		}
		right--;
		
		//从右到左遍历，找到最小的数，放到最前面	
		for(i = right ;i>left;i--)
		{
			if(array[i]<array[i-1])
			{
				myswap(&array[i],&array[i-1]);
			}
		}
		left++;
	}
	else
	{
		//从左到右遍历，找到最小的数，放到最后面
		int i;
		for(i = left ;i<right;i++)
		{
			if(array[i]<array[i+1])
			{
				myswap(&array[i],&array[i+1]);
			}
		}
		right--;
		
		//从右到左遍历，找到最大的数，放到最前面
		for(i = right ;i>left;i--)
		{
			if(array[i]>array[i-1])
			{
				myswap(&array[i],&array[i-1]);
			}
		}
		left++;
	}
	
	r_cocktail_sort(array,left,right,way);
}


void selection_sort(int array[], int len_array,SORTWAY way)
{	
	//找最小元素下标
	int i,j ;
	for(i=0;i<len_array-1;i++)
	{
		if(UP == way)
		{
			int min = i;
			for(j = i+1;j<len_array;j++)
			{
				if(array[min]>array[j])
					min = j;
			}
			//与数组第一个元素交换
			if(min != i)
				arrayswap(array,min,i);
		}
		else
		{
			int max = i;
			for(j = i+1;j<len_array;j++)
			{
				if(array[max]<array[j])
					max = j;
			}
			//与数组第一个元素交换
			if(max != i)
				arrayswap(array,max,i);
		}
		
	}	
}

void r_selection_sort(int array[], int len_array,int limit_index,SORTWAY way)
{	

	if(limit_index == len_array-1)
		return;

	int i;
	//找最小元素下标
	if(UP == way)
	{
		int min = limit_index ;
		for(i = min+1;i<len_array;i++)
		{
			if(array[min]>array[i])
				min = i;
		}
		//与数组第一个元素交换
		if(min != limit_index)
			arrayswap(array,min,limit_index);
	}
	else
	{
		int max = limit_index;
		for(i = max+1;i<len_array;i++)
		{
			if(array[max]<array[i])
				max = i;
		}
		//与数组第一个元素交换
		if(max != limit_index)
			arrayswap(array,max,limit_index);
	}
	limit_index++;
	r_selection_sort(array,len_array,limit_index,way);
}



void Insertion_sort(int array[], int len_array,SORTWAY way)
{
	int i,j;
	for(i=1;i<len_array;i++)
	{
		j = i-1;
		int tmp = array[j+1];		
		while(j>=0)
		{
			if(UP == way)
			{
				//找到第一个比他小的数
				if(tmp >= array[j])
				{
					break;	
				}
				else
				{
					array[j+1] = array[j];	
					j--;
				}
			}
			else
			{
				//找到第一个比他大的数
				if(tmp <= array[j])
				{
					break;	
				}
				else
				{
					array[j+1] = array[j];	
					j--;
				}
			}
			
		}
		//插入数据
		array[j+1] = tmp;
	}
	
}

void Insertion_DIV_sort(int array[], int len_array,SORTWAY way)
{
	
	//二分法找到要插入的位置
	int i;
	for(i=1;i<len_array;i++)
	{
		int left  = 0;
		int right = i-1;
	
		
		int tmp = array[i]; //保存待插入的数据
		while(left <= right )
		{
			int mid   = (left+right)/2;
			if(UP == way)
			{
				if(tmp < array[mid] )
					right  = mid-1;
				else
					left   = mid+1;			
			}
			else
			{
				if(tmp >array[mid])
					right  = mid-1;
				else
					left   = mid+1;					
			}
		}
		
		//复制性移位
		int j;
		for(j=i-1;j>=left;j--)
			array[j+1] = array[j];
		
		
		//插入数据
		array[left] = tmp;
		
	}		
}



void Shell_sort(int array[], int len_array,SORTWAY way)
{
	
	int gap = 0 ;
	while(gap < len_array)
	{
		gap = gap*3+1;
	}
	
	
	while(gap>0)
	{
		int  i;
		for(i = gap;i<len_array;i++)
		{
			int j = i-gap;	//找到该数据（i）所在组的前一个数据(j)
			
			int tmp = array[i];//保存待插入的数据
			
			//找到要插入位置的前一个位置
			while(j>=0 )
			{
				if(UP == way)
				{
					if(tmp < array[j])
					{
						array[j+gap] = array[j];
						j-=gap;
					}
					else
					{
						break;
					}
				}
				else
				{
					if(tmp > array[j])
					{
						array[j+gap] = array[j];
						j-=gap;
					}
					else
					{
						break;
					}
				}
					
			}
			
			//插入数据
			array[j+gap] = tmp;
			
			
		}
		gap /= 3;
	}
	
	
}


//调整堆
void r_herify(int array[],int index,int len_array,SORTWAY way)
{
	int lchild_index = 2*index+1;
	int rchild_index = 2*index+2;
	
	if(UP == way) //升序，大顶堆
	{
		int max = index;
		if(lchild_index<len_array && array[max] < array[lchild_index])
			max = lchild_index;
		
		if(rchild_index<len_array && array[max] < array[rchild_index])
			max = rchild_index;
		
		if(max != index)	
		{
			arrayswap(array,max,index);
			r_herify(array,max,len_array,way);
		}
	}
	else	//降序，小顶堆
	{
		int min = index;
		if(lchild_index<len_array && array[min] > array[lchild_index])
			min = lchild_index;
		
		if(rchild_index<len_array && array[min]> array[rchild_index])
			min = rchild_index;
		
		if(min != index)	
		{
			arrayswap(array,min,index);
			r_herify(array,min,len_array,way);
		}
	}
}
void Heap_sort(int array[], int len_array,SORTWAY way)
{
	//建堆:从非叶节点开始，把每一个结点搞成大顶堆
	int i;
	for(i=len_array/2-1;i>=0;i--)
	{
		r_herify(array,i,len_array,way);
	}	
	
	//排序 ==> 交换 调整
	int last = len_array;
	for(i = len_array-1;i >0;i--)
	{		
		arrayswap(array,0,i);
		last--;
		r_herify(array,0,last,way);
	}
	
}



void merge(int array[],int left,int mid,int right,int*tmp,SORTWAY way)
{
	int i = left; //左边数组下标
	int j = mid+1;//右边数组下标
	int k = 0;	  //临时数组下标
	if(UP == way)
	{
		while(i<=mid && j<= right)
		{
			if(array[i] < array[j])
				tmp[k++] = array[i++];
			else
				tmp[k++] = array[j++];
		}
		
		while(i<=mid)
			tmp[k++] = array[i++];
		
		while(j<=right)
			tmp[k++] = array[j++];
	}
	else
	{
		while(i<=mid && j<= right)
		{
			if(array[i] > array[j])
				tmp[k++] = array[i++];
			else
				tmp[k++] = array[j++];
		}
		
		while(i<=mid)
			tmp[k++] = array[i++];
		
		while(j<=right)
			tmp[k++] = array[j++];
	}
	
	//将数据放到原数组中
	for(i=0;i<k;i++)
	{
		array[left+i] = tmp[i];
	}
		
}
void r_merge_sort(int array[], int left,int right,int tmp[],SORTWAY way)
{

	if(left>=right)
		return;
			
	int mid  = (left+right)/2;
	//左边数组归并排序
	r_merge_sort(array,left,mid,tmp,way);
	
	//右边数组归并排序
	r_merge_sort(array,mid+1,right,tmp,way);
	
	//合并数组归并排序
	merge(array,left,mid,right,tmp,way);
	

}


//分区
int partition(int array[],int left,int right,SORTWAY way)
{
	int pivot = array[right]; //选取最右边的为基准值
	
	while(left<right)
	{
		//int len = right - left;//待操作数组长度
		if(UP == way)
		{
			while(array[left] <= pivot && left<right)
			{
				left++;
			}
			if(left<right)
			{
				array[right] = array[left];
				right--;
			}
			while(array[right] >= pivot && left<right)
			{
				right--;
			}
			if(left<right)
			{
				array[left] = array[right];
				left++;
			}	
		}
		else
		{
			while(array[left] >= pivot && left<right)
			{
				left++;
			}
			if(left<right)
			{
				array[right] = array[left];
				right--;
			}
			while(array[right] <= pivot && left<right)
			{
				right--;
			}
			if(left<right)
			{
				array[left] = array[right];
				left++;
			}	
		}
		
	}	
	array[left] = pivot;
	
	return left;
}

void r_quick_sort(int array[], int left,int right,SORTWAY way)
{
	if(left<right)
	{
		//分区并确定基准值的下标
		int pivotIndex = partition(array,left,right,way);
		//对左半部分进行快速排序
		r_quick_sort(array,left,pivotIndex-1,way);
		//对右半部分进行快速排序	
		r_quick_sort(array,pivotIndex+1,right,way);
	}
}

测试主函数

#include <stdio.h>
#include "mysort.h"



int main()
{
	int a[]={1,5,3,6,8,4,6,5,4};
	
	int len = sizeof(a)/sizeof(a[0]);

	
	myprint(a,len);
	printf("冒泡排序**********************\n");
	bubble_sort(a,len,UP);
	myprint(a,len);
	bubble_sort(a,len,DOWN);
	myprint(a,len);
	
	printf("鸡尾酒排序**********************\n");
	cocktail_sort(a,len,UP);
	myprint(a,len);	
	cocktail_sort(a,len,DOWN);
	myprint(a,len);
	
	r_cocktail_sort(a,0,len-1,UP);
	myprint(a,len);
	r_cocktail_sort(a,0,len-1,DOWN);
	myprint(a,len);
	
	printf("选择排序**********************\n");
	selection_sort(a,len,UP);
	myprint(a,len);
	r_selection_sort(a,len,0,DOWN);
	myprint(a,len);

	
	printf("插入排序**********************\n");
	Insertion_sort(a,len,UP);
	myprint(a,len);
	Insertion_sort(a,len,DOWN);
	myprint(a,len);
	
	printf("二分法插入排序**********************\n");	
	Insertion_DIV_sort(a,len,UP);
	myprint(a,len);	
	Insertion_DIV_sort(a,len,DOWN);
	myprint(a,len);
	
	printf("希尔分组插入排序**********************\n");	
	Shell_sort(a,len,UP);
	myprint(a,len);	
	Shell_sort(a,len,DOWN);
	myprint(a,len);	
	
	printf("堆排序****************************\n");	
	Heap_sort(a,len,UP);
	myprint(a,len);	
	Heap_sort(a,len,DOWN);
	myprint(a,len);	
	
	printf("归并排序****************************\n");	
	int tmp[10] ={0};
	r_merge_sort(a,0,len-1,tmp,UP);
	myprint(a,len);	
	
	r_merge_sort(a,0,len-1,tmp,DOWN);
	myprint(a,len);

	printf("快速排序****************************\n");	
	r_quick_sort(a,0,len-1,UP);
	myprint(a,len);	
	
	r_quick_sort(a,0,len-1,DOWN);
	myprint(a,len);	
	
	
	
	
	return 0;

}
梦落天涯
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript实现的九种排序算法
12-11
大学曾经用C语言研究过一段时间的排序实现， 这段时间有空用JS再将排序知识点熟悉一遍。 下面话不多说了，来一起看看详细的介绍吧 一、代码汇总(一) 1、冒泡排序 2、改进版冒泡排序 3、选择排序 4、直接插入排序...
C语言实现各种排序
海马有力量的博客
10-25 388
实现了插入排序，折半插入排序，希尔排序，冒泡排序，选择排序，快速排序，归并排序。介绍见注释。 #include<stdio.h> #include<stdlib.h> #define N 100 typedef int ElemType; void Swap(int *a,int *b){ int t; t=*a; *a=*b; *b=t; } //插入排序：设第一个数为排好的序列，后面的数插入到前面的序列 void InsertSort(ElemType a[],int
C语言实现各种排序（1）
各种排序算法的C语言实现
12-16 508
#include&lt;stdio.h&gt; //排序分为插入排序，希尔排序，冒泡排序，快速排序，选择排序，堆排序，归并排序，基数排序（桶排序） //1.1 //直接插入排序，较为简单，思路为从第二个数开始逐个将其插入前面有序的序列中 //平均时间复杂度为O(N2),最快时间复杂度为O(N),最坏时间复杂度为O(N2)，空间复杂度为O(1) void InsertSort(int *a,in...
九大排序总结（c语言）
计算机科学与技术专业学生的成长之路
08-14 295
冒泡排序： 最好情况: T = O( N ); 最坏情况 T = O( N ^ 2 ); void Bubble_sort(int num[],int n) //从小到大 { int i ,j; for(i = 0;i <= n - 1;i++) { for(j = i + 1;j <= n - 1;j++) { if(num[i] > num[j]) ...
九大排序算法-c语言实现及详解
zhang2531的专栏
04-25 922
概述排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。          当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。    快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待
C语言实现六种排序算法
CodeMan
07-02 5173
C语言实现六种排序算法C语言实现六种排序算法冒泡排序 插入排序 归并排序 快速排序 希尔排序 选择排序下载完整源代码冒泡排序从左到右依次比较相邻两个元素，如果大的在左边则交换这两个元素。 如果在依次遍历中执行过交换操作，则再次遍历，直到不发生元素交换。int * sortByMaopao(int * num,int length) { bool flag=true; while(f
排序算法源代码（C语言实现）
04-27
C语言实现的九种经典排序算法（直接选择排序、冒泡排序、快速排序、归并排序、直接插入排序、希尔排序、折半插入排序、堆排序、基数排序），运行稳定高效。
多种排序算法C代码实现
01-06
包含以下九种排序算法的C代码实现源码：可以自已生成随机数以便测试： 选择(SelectSort)、插入(InsertSort)、冒泡(BubbleSort)、Shell排序(ShellSort)、快速排序(QuickSort)、快速排序的改进算法(QStackSort)、合并...
七上八下——冒泡排序.zip_goosex4s_冒泡排序
09-20
实现冒泡排序，后续将陆续上传九种排序方式，C语言实现。
c语言学生成绩管理系统和报告
01-10
学生成绩管理系统需要维护一组学生成绩信息，实现增删查改统计排序以及读取保存，使用结构体数组。 文件的读写需要用到c语言的文件操作函数。 显示学生成绩信息功能分为三个小功能：根据目生成绩信息数量遍历学生...
[转]九大排序算法——C语言实现及详解
静溪小筑
07-26 537
概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。我们这里说说八大排序就是内部排序。         当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时
ROS基于C++动力学约束的路径规划源码+ppt文件.zip
04-30
ROS基于C++动力学约束的路径规划源码+ppt文件.zip
ASP.NET BS结构的城市酒店入住信息管理系统的设计
04-30
ASP.NET B/S结构城市酒店入住信息管理系统的设计与实现简介 一、项目背景与意义 随着城市旅游的蓬勃发展，酒店业作为旅游产业链中的重要一环，面临着日益激烈的市场竞争。为了提升酒店的服务质量和管理效率，信息化管理成为酒店业不可或缺的一部分。因此，我们设计并实现了一个基于ASP.NET的B/S（浏览器/服务器）结构城市酒店入住信息管理系统。该系统旨在帮助酒店实现入住信息的快速录入、查询、修改和统计，提升酒店的运营效率和客户体验。 二、系统主要功能 用户管理：系统支持管理员、前台服务员、客户等不同角色的注册、登录和权限管理。通过角色权限的设置，确保系统数据的安全性和完整性。 房间管理：管理员可以添加、编辑、删除房间信息，包括房间类型、价格、状态等。前台服务员可以实时查看房间状态，为客人办理入住和退房手续。 入住信息管理：前台服务员可以录入客人的入住信息，包括姓名、证件号码、联系方式、入住时间和离店时间等。系统支持客人信息的快速查询和修改，方便前台服务员处理各种客户需求。 费用管理：系统根据客人的入住时间和房间价格自动计算费用，并支持多种支付方式。管理员可以设置折扣、优惠券等促销
基于streamlit的YOLOv8可视化交互界面
04-30
基于streamlit的YOLOv8可视化交互界面
liba52-0-0.7.5+svn613-lp152.3.2.aarch64.rpm
04-30
liba52-0-0.7.5+svn613-lp152.3.2.aarch64
基于matlab实现配电网三相潮流计算方法，对几种常用的配电网潮流计算方法进行了对比分析.rar
最新发布
04-30
基于matlab实现配电网三相潮流计算方法，对几种常用的配电网潮流计算方法进行了对比分析.rar
123321123323211
04-30
121342141414
哈希算法（Hash Algorithm）是一种将任意长度的二进制数据映射为较短的、固定长度的二进制值的函数.txt
04-30
哈希算法的特点
基于ros和stm32f1的小车代码含串口通信+项目说明.zip
04-30
复刻平衡小车，自行添加了转向环和蓝牙控制，蓝牙APP使用的是轮趣科技的。该项目为复刻平衡小车，其中大量代码为b站up主_WNNN的开源代码，加了转向环的代码，添加蓝牙控制功能. 该小车主体由洞洞板焊接，使用的io口焊的时候忘记记了，随缘吧。
c语言实现表插入排序
12-24
以下是C语言实现表插入排序的代码示例： ```c void Insert_sort(int *ar, int len) { int temp = 0; int i = 0, j = 0; for (i = 1; i < len; i++) { temp = ar[i]; for (j = i - 1; j >= 0 && ar[j] > temp; j--) { ar[j + 1] = ar[j]; } ar[j + 1] = temp; } } ``` 这段代码实现了插入排序算法，它将一个记录插入到已排好序的有序表中，从而得到一个新的记录新增1的有序表。具体的步骤如下： 1. 遍历待排序的数组，从第二个元素开始（i = 1）。 2. 将当前元素保存在临时变量temp中。 3. 在已排序的部分中，从当前元素的前一个元素开始（j = i - 1），向前遍历。 4. 如果已排序的元素大于temp，则将该元素向后移动一位（ar[j + 1] = ar[j]）。 5. 继续向前遍历，直到找到一个小于或等于temp的元素，或者已经遍历到数组的起始位置。 6. 将temp插入到找到的位置（ar[j + 1] = temp）。 7. 重复以上步骤，直到遍历完所有的元素。 这样，经过插入排序算法的处理，数组中的元素将按照升序排列。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值