链表、常见排序和查找算法代码

最新推荐文章于 2022-10-31 15:40:53 发布
最新推荐文章于 2022-10-31 15:40:53 发布
阅读量286 收藏 1
点赞数
分类专栏： C语言 文章标签： 算法 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bboyaxu/article/details/127235593
版权

文章目录

1. 链表

创建链表和输出链表：

#include<stdio.h>
#include<stdlib.h>
struct Linklist{
	int data;
	struct Linklist *next;
};
int n;
struct Linklist *creat()
{
	int i;
	struct Linklist *head=(struct Linklist *)malloc(sizeof(struct Linklist));
	head->next=NULL;
	struct Linklist *p;
	p=head;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		struct Linklist *s=(struct Linklist *)malloc(sizeof(struct Linklist));
		scanf("%d",&s->data);
		p->next=s;
		s->next=NULL;
		p=s;
	}
	return head;
}
void print(struct Linklist *p)
{
	
	while(p->next!=NULL)
	{
		printf("%-3d",p->next->data);
		p=p->next;
	}
}
int main()
{
	struct Linklist *head;
	head=creat();
	print(head);
	putchar('\n');
	printf("%d",n);
	return 0;
}

2. 排序

2.1 冒泡排序

#include <stdio.h>
int main()
{
	//冒泡排序，也是一种简单直观的排序算法。
	//它重复地走访过要排序的数列，一次比较两个元素，
	//如果他们的顺序错误就把他们交换过来。 
	int a[10]={1,2,3,4,5,6,7,8,9,0},i,j,t;
	for(i=0;i<9;i++)
		for(j=0;j<9;j++)
		{
			if(a[j]>a[j+1])
				t=a[j],a[j]=a[j+1],a[j+1]=t;
		}
	for(i=0;i<10;i++)
		printf("%2d",a[i]);
	return 0; 
}

2.2 选择排序

#include <stdio.h>
int main()
{
	//选择排序
	//首先在未排序序列中找到最小（大）元素，
	//存放到排序序列的起始位置。
	//再从剩余未排序元素中继续寻找最小（大）元素，
	//然后放到已排序序列的末尾。
	//重复第二步，直到所有元素均排序完毕
	int a[10]={1,2,3,4,5,6,7,8,9,0},i,j,t,max;
	for(i=0;i<10;i++)
	{
		max=i;
		for(j=i+1;j<10;j++)
			if(a[j]>a[max])
				max=j;
		t=a[i],a[i]=a[max],a[max]=t;
	}
	for(i=0;i<10;i++)
		printf("%2d",a[i]);
	return 0; 
}

2.3 快速排序

#include <stdio.h>
void print(int *a,int len)
{
	int i;
	for(i=0;i<len;i++)
		printf("%3d",a[i]);
	putchar('\n');
}
void swap(int *a,int *b)
{
	int t;
	t=*a;
	*a=*b;
	*b=t;
}
void merge_sort_recursive(int *arr,int start,int end)
{
	if(start>=end)
		return;
	int mid=arr[end];
	int left=start,right=end-1;
	while(left<right)
	{
		while(arr[left]<mid && left<right)
			left++;
		while(arr[right]>=mid && left<right)
			right--;
		swap(&arr[left],&arr[right]);
	}
	if(arr[left]>=arr[end])
		swap(&arr[left],&arr[end]);
	else
		left++;
	print(arr,10);
	if(left)
		merge_sort_recursive(arr,start,left-1);
	merge_sort_recursive(arr,left+1,end);
	
}
void merge_sort(int *arr,int len)
{
	merge_sort_recursive(arr,0,len-1);	
} 

int main()
{
	int a[10]={3,6,2,7,1,3,7,1,2,7},i,j,len,max,key,gap;
	len=10;
	print(a,10);
	merge_sort(a,10);
	print(a,10);
	
}

2.4 希尔排序

#include <stdio.h>
void print(int a[],int len)
{
	int i;
	for(i=0;i<len;i++)
		printf("%2d",a[i]);
	printf("\n");
}
void shell(int a[],int len)
{
	int i,j,gap,temp;
	for(gap=len/2;gap>0;gap/=2)
	{
		for(i=gap;i<len;i++)
		{
			temp = a[i];
			for(j=i-gap;j>=0 && a[j]>temp;j-=gap)
				a[j+gap] = a[j];
			a[j+gap] = temp;
		}
		print(a,len); 
	}
}  
int main()
{
	int a[10]={1,8,3,6,5,4,7,2,9,0};
	print(a,10); 
	shell(a,10); 
	return 0; 
}

2.5 归并排序

#include <stdio.h>
#include <math.h>
void print(int *a,int len)
{
	int i;
	for(i=0;i<len;i++)
		printf("%3d",a[i]);
	putchar('\n');
}
void merge_sort_recursive(int *a,int *arr,int start,int end)
{
	if(start>=end)
		return;
	int mid=(end-start)/2+start;
	int start1=start,end1=mid;
	int start2=mid+1,end2=end;
	merge_sort_recursive(a,arr,start1,end1);
	merge_sort_recursive(a,arr,start2,end2);
	int k=start;
	while(start1 <= end1 && start2 <= end2)
	{
		if(a[start1]<a[start2])
			arr[k++]=a[start1++];
		else 
			arr[k++]=a[start2++];	
	}
	while(start1 <= end1)
		arr[k++]=a[start1++];
	while(start2 <= end2)
		arr[k++]=a[start2++];
	while(start<=end) 
	{
		a[start]=arr[start];
		start++;
	}	
	print(a,10);
}
void merge_sort(int *a,int len)
{
	int arr[10];
	merge_sort_recursive(a,arr,0,len-1);
}

int main()
{
	int a[10]={3,6,2,7,1,2,7,1,2,7};
	print(a,10);
	merge_sort(a,10);
	print(a,10);
}

2.6 堆排序

#include <stdio.h>
void swap(int *a,int *b){
	int t;
	t=*a;
	*a=*b;
	*b=t;
}
void print(int *a,int len){
	int i;
	for(i=0;i<len;i++)
	{
		printf("%-3d",a[i]);
	}
	putchar('\n');
}
// a 数组  len 数组长度 i待维护节点的下标 
void heapify(int *a,int len,int i)
{
	int largest=i;
	int ld=i*2+1,rd=i*2+2;
	if(ld<len && a[largest]<a[ld])
		largest=ld;
	if(rd<len && a[largest]<a[rd])
		largest=rd;
	if(largest != i)
	{
		swap(&a[i],&a[largest]);
		heapify(a,len,largest);
	}
}
void heap_sort(int *a,int len)
{
	int i;
	//建堆 
	for(i=len/2-1;i>=0;i--)
		heapify(a,len,i);
	//排序
	for(i=len-1;i>0;i--)
	{
		swap(&a[i],&a[0]);
		heapify(a,i,0);
	} 
 } 
int main(){
	int a[10]={4,5,6,7,9,8,1,2,3,0};
	print(a,10);
	heap_sort(a,10);
	print(a,10);
}

3. 查找

3.1 二分查找

#include<stdio.h>
void swap(int *a,int *b)
{
	int t;
	t=*a;
	*a=*b;
	*b=t;
}
//二分查找的数组必须是有序的 
int bin_serch(int *a,int len,int target)
{
	int left=0,right=len-1,mid;
	while(left<=right)
	{
		mid=(right-left)/2+left;
		if(target<a[mid])
			right=mid-1;
		else if(target>a[mid])
			left=mid+1;
		else
			return mid;
	}
	return left;
	
} 
int main(){
	int a[10]={0,1,2,3,4,5,6,7,8,9},i,n;
	printf("%d",bin_serch(a,10,3));
}

3.2 选择查找算法大综合

#include <stdio.h>
#include <string.h> 
void swap(int *a,int *b){
	int t;
	t=*a;
	*a=*b;
	*b=t;
}
void print(int *a,int len){
	int i;
	for(i=0;i<len;i++)
		printf("%-3d",a[i]);
	putchar('\n');
}
void bubble(int *a,int len){
	int i,j;
	for(i=0;i<len-1;i++)
		for(j=0;j<len-1-i;i++)
			if(a[j]>a[j+1])
				swap(&a[j],&a[j+1]); 
}
void select(int *a,int len){
	int i,j,min;
	for(i=0;i<len;i++)
	{
		min=i;
		for(j=i+1;j<len;j++)
			if(a[min]>a[j])
				min=j;
		swap(&a[min],&a[i]); 		
	}
}
void insert(int *a,int len){
	int i,j,key;
	for(i=1;i<len;i++)
	{
		key=a[i];
		j=i-1;
		while(j>=0 && a[j]>key)
		{
			a[j+1]=a[j];
			j--;
		}	
		a[j+1]=key;		
	}
}
void shell(int *a,int len){
	int i,j,temp,gap;
	for(gap=len/2;gap>0;gap/=2)
		for(i=gap;i<len;i++)
		{
			temp=a[i];
			for(j=i-gap;j>=0 && a[j]>temp;j-=gap)
				a[j+gap]=a[j];
			a[j+gap]=temp;		
		}
}
void merge_sort_recursive(int *a,int *arr,int start,int end){
	if(start>=end)
		return;
	int mid=(end-start)/2+start;
	int start1=start,end1=mid;
	int start2=mid+1,end2=end;
	merge_sort_recursive(a,arr,start1,end1);
	merge_sort_recursive(a,arr,start2,end2);
	int k=start;
	while(start1<=end1 && start2<=end2)
	{
		if(a[start1]<a[start2])
			arr[k++]=a[start1++];
		else
			arr[k++]=a[start2++];
	}
	while(start1<=end1)
		arr[k++]=a[start1++];
	while(start2<=end2)
		arr[k++]=a[start2++];
	k=start;
	while(k<=end)
	{
		a[k]=arr[k];
		k++;
	}
}
void quick_sort_recursive(int *a,int start,int end){
	if(start>=end)
		return;
	int mid=a[end];
	int left=start,right=end-1;
	while(left<right)
	{
		while(a[left]<mid && left<right)
			left++;
		while(a[right]>=mid && left<right)
			right--;
		swap(&a[left],&a[right]);
	}
	if(a[left]>=a[end])
		swap(&a[left],&a[end]);
	else
		left++;
	if(left)
		quick_sort_recursive(a,start,left-1);
	quick_sort_recursive(a,left+1,end);
}
int bin_search(int *a,int len,int target){
	int left=0,right=len-1;
	while(left<=right)
	{
		int mid=(right-left)/2+left;
		if(target>a[mid])
			left=mid+1;
		else if(target<a[mid])
			right=mid-1;
		else 
			return mid;
	}
	return left;
}
int main(){
	int a[10]={35,34,33,32,31,15,14,13,12,11},arr[10];
	print(a,10);
//	bubble(a,10);
//	select(a,10);
//	insert(a,10);
//	shell(a,10);
//	merge_sort_recursive(a,arr,0,9);
	quick_sort_recursive(a,0,9);
	print(a,10);
	printf("%d的位置%d",34,bin_search(a,10,34));
}
Limux8
关注
专栏目录
C/C++ 链表的选择排序算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-06 7431
链表的选择排序算法是通过比较链表中的节点值，选出当前最小的节点，然后将该节点从链表中删除，并将其插入到已排序部分的末尾。重复这个过程，直到整个链表排序完成。
链表操作代码
04-16
内有很多链表操作，是我做课设的时候写的，c的初学者可以看看我的代码，还是有一点帮助的
查找算法集：顺序查找、二分查找、插值查找、动态查找(数组实现、链表实现)(转)...
sunxboy的专栏
10-13 212
java 代码 // search.cpp : Defines the entry point for the console application.    //       #include "stdafx.h"   #include "LinkTable.h"   #define        MAX_KEY  500      ...
c语言链表查找的代码与题目,链表的C语言实现之单链表的查找运算_c语言
weixin_29710403的博客
05-22 827
建立了一个单链表之后，如果要进行一些如插入、删除等操作该怎么办？所以还须掌握一些单链表的基本算法，来实现这些操作。单链表的基本运算包括：查找、插入和删除。下面我们就一一介绍这三种基本运算的算法，并结合我们建立单链表的例子写出相应的程序。1、查找对单链表进行查找的思路为：对单链表的结点依次扫描，检测其数据域是否是我们所要查好的值，若是返回该结点的指针，否则返回NULL。{post_permalink...
排序查找算法代码大全
weixin_44146603的博客
09-01 223
下面展示一些 内联代码片。 //直接插入排序,从小到大 void direct_insert(int a[],int n){ int i,j,temp; for(i=1;i<n;i++){ temp = a[i];//保存待排序元素值 j=i-1; // while(j>=0&&a[j]>temp){ // a[j+1] =a[j]; // --j; // } for(j=i;j>=0&&a[j-1]>temp;-
链表排序c++代码_【算法打卡】排序链表
weixin_40002692的博客
12-05 752
屏幕又脏了难度：中等题目：给你链表的头结点head，请将其按升序排列并返回排序后的链表。进阶：你可以在O(nlogn)时间复杂度和常数级空间复杂度下，对链表进行排序吗？示例 1：输入：head = [4,2,1,3]输出：[1,2,3,4]示例 2：输入：head = [-1,5,3,4,0]输出：[-1,0,3...
JS常用的数据结构和算法,链表、栈、队列、排序和查找:octocat
04-03
在这个主题下，我们将深入探讨四种基本的数据结构——链表、栈、队列以及基础的排序和查找算法。这些概念不仅在日常开发中广泛应用，也是面试中常被考察的知识点。 **链表** 链表是一种线性数据结构，与数组不同，...
链表、图、排序算法C语言实现.zip
最新发布
06-13
本资源"链表、图、排序算法C语言实现.zip"包含的是用C语言编写的链表、图以及排序算法的实现代码，这对于学习和理解这些概念提供了实际操作的例子。 首先，我们来详细探讨一下链表。链表是一种线性数据结构，与数组...
链表树图排序查找
06-27
在"ExamCpp"这个文件中，我们可以推测这可能是一个学习资源或练习项目，它包含了关于链表、树、图的实现和排序查找算法的编程示例。通过研究和实践这些代码，可以加深对这些基础数据结构和算法的理解，提升编程技能...
数据结构链表树图查找排序
09-20
在树和图结构中，查找算法通常更快，如二叉搜索树的查找时间复杂度为O(log n)。哈希表提供常数时间的查找，但需要额外的空间来存储索引。 5. **排序**：排序是将一组数据按照特定顺序排列的过程。常见的排序算法有...
C++创建链表、及链表数据查询--.cpp源代码
07-18
C++创建链表、及链表数据查询--.cpp源代码
几种排序算法的实现（链表）
07-11
通过链表实现几种排序算法，并比较它们的优劣。
C++算法之链表排序的代码
weixin_44073507的博客
12-20 699
下面的资料是关于C++算法之链表排序的代码。 { return; while(curr){ prev = curr; curr = curr->next; insert_for_sort_operation(ppNode, prev); } return; } b）对于待插入的节点，选择合适的位置插入即可 { return; } while(cur){ if(pNode->data < cur
简单的查找与排序的算法实现（python）
Wu030520的博客
10-31 317
简单的查找及排序的算法实现
链表的排序代码 c语言,C语言的源代码 l链表排序
weixin_42298754的博客
05-21 339
typedef struct node{int data;struct node *next;}*Linklist,Node;void paixu(Linklist head){Linklist p,q,small;int temp;for(p=head->next;p->next!=NULL;p=p->next) /* for(循环变量初值，循环条件，循环变量增量)*/{ sm...
链表排序c++代码_【每日编程107期】链表排序之归并排序
weixin_39524183的博客
12-08 131
每日编程中遇到任何疑问、意见、建议请公众号留言或直接撩Q474356284(备注每日编程)今日问题：示例 1:输入:4->2->1->3输出:1->2->3->4示例 2:输入:-1->5->3->4->0输出:-1->0->3->4->5解决方法：归并排序(MERGE-SORT)是建立在归并操作上的一种...
查找和排序算法
shaoqinghh的博客
03-03 260
常用排序查找算法一、排序算法基础类排序直接插入排序折半插入排序法交换类排序选择排序归并排序基数排序 一、排序算法 基础类排序 直接插入排序 代码实现 def insert_sort(arr): length = len(arr) for i in range(1, length): j = i - 1 if arr[i] < arr[j]: temp = arr[i] arr[i] = arr[j]
各种排序和查找方式的代码实现
weixin_55430573的博客
07-26 682
程序 = 数据结构 + 算法 算法：计算机解决问题的方法或者步骤 结构设计是程序的肉体、算法设计是灵魂
二元查找树转排序双向链表算法解析
其中，将二元查找树（BST）转换成排序的双向链表是一个典型的算法问题，它涉及到数据结构的深入理解和巧妙操作。 二元查找树是一种特殊的二叉树，它的每个节点都满足左子树上所有节点的值小于当前节点的值，而右子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Limux8

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值