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

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量260 收藏 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
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JS常用的数据结构和算法,链表、栈、队列、排序和查找:octocat
04-03
在这个主题下，我们将深入探讨四种基本的数据结构——链表、栈、队列以及基础的排序和查找算法。这些概念不仅在日常开发中广泛应用，也是面试中常被考察的知识点。 **链表** 链表是一种线性数据结构，与数组不同，...
链表、图、排序算法C语言实现.zip
06-13
本资源"链表、图、排序算法C语言实现.zip"包含的是用C语言编写的链表、图以及排序算法的实现代码，这对于学习和理解这些概念提供了实际操作的例子。 首先，我们来详细探讨一下链表。链表是一种线性数据结构，与数组...
c语言排序算法（使用链表）
Ethereal_tl的博客
12-22 3098
直接插入排序、折半插入排序、希尔排序、气泡排序(又称冒泡排序,直接交换排序)、快速排序、选择排序
c语言 链表 插入排序,表插入排序算法
weixin_33603405的博客
05-21 960
前面章节中所介绍到的三种插入排序算法，其基本结构都采用数组的形式进行存储，因而无法避免排序过程中产生的数据移动的问题。如果想要从根本上解决只能改变数据的存储结构，改用链表存储。表插入排序，即使用链表的存储结构对数据进行插入排序。在对记录按照其关键字进行排序的过程中，不需要移动记录的存储位置，只需要更改结点间指针的指向。链表的存储结构用代码表示为：#define SIZE 100typedef st...
常用排序算法总结（数组+链表）Java
weixin_42970016的博客
01-25 1261
常用排序算法的总结和分析一、简介二、具体分析及代码1.冒泡排序2.选择排序3.插入排序4.归并排序5.快速排序6.希尔排序7.计数排序8.堆排序9.桶排序10.基数排序 一、简介 最近在复习算法和数据结构，复习到排序和查找，在这里对常用的几种排序算法做一个总结 先放一张图，这张图包括了十种经典排序算法的一些特点和复杂度，接下来就按照图中的顺序来进行具体的分析 二、具体分析及代码 说明：本文中的排序目标均为升序 *定义swap方法: private void swap(int[]nums, int
链表排序总结（全）（C++）
热门推荐
zj
07-18 2万+
文章目录链表排序与数组排序的区别借助外部空间冒泡排序插入排序归并排序快速排序 链表排序与数组排序的区别 数组的排序几乎所有人都很熟悉了，常用的算法插入、冒泡、归并以及快排等都会或多或少依赖于数组可以在O(1)时间随机访问的特点。 链表排序一般指单链表排序，链表是不支持随机访问的，需要访问后面的节点只能从表头顺序遍历，所以链表的排序是一个相对比较复杂的问题。 那么怎样进行链表排序呢？ 借助外部空间 既然数组排序简单，那可以借助数组进行排序： 把链表中的值一次遍历导入数组（时间复杂度O(n)） 对数组进行排序
链表的快速排序和归并排序
To the beyond and infinity!
07-26 2435
不同于数组快排和归并排序(见排序归纳总结（插入排序、归并排序、堆排序、快速排序、桶排序）)，链表不能够随机访问，只能从链表头遍历至链表尾，针对这一特性，需要对数组的排序算法做相应的调整。 文章目录1. 快速排序2. 归并排序 1. 快速排序 对于链表的快速排序，使用两个指针p和q，使得p和q都只向其next方向进行遍历，同时保证p之前的链表节点的val都小于head的val值，p和q之间的链表节点的val都大于head的val值，则当q遍历到链表末尾时，再将head的val和p的val值进行互换，则就进行
链表直接插入排序
qq_41027398的博客
01-02 4931
文章目录带头结点不带头结点 带头结点 基本思想： 将带头结点head的链表拆分为：head带一个结点的链表和q带剩余结点的链表，将q中的每个结点逐次插入到head链表中，构成一个带头结点且结点值递增的链表 关键代码： LinkList sort(LinkList &head){ LinkList p, q, r, l; p = head->next;//将原链表拆分为两个链表,一个head带一个结点,一个q带剩余结点 q = p->next; p->next = NUL
常用链表排序算法
Micheal
06-08 4120
转载自:http://blog.csdn.net/northplayboy/article/details/552388    ==========================  功能：选择排序(由小到大)  返回：指向链表表头的指针 ========================== */ /*  选择排序的基本思想就是反复从还未排好序的那些节点中，  选出键值（就是
数据结构——顺序表和链表的代码实现及算法思路
qq_45768060的博客
03-25 2333
线性结构顺序表和链表的实现及各种操作合集一级目录线性表顺序储存的实现结构体的定义顺序表的初始化插入操作删除操作按值查找应用举例删除自第i个元素开始的k个元素链表的实现不含头结点的链表的实现结构体定义线性表的创建线性表的长度计算按序号查找按值查找插入操作删除操作应用举例俩有序链表的合并 一级目录 线性表顺序储存的实现 结构体的定义 const int MAX_SIZE=10; struct Sepl...
数据结构与算法—二叉排序(查找)树
bigsai
08-19 1万+
再数据结构中`树`、`图`才是数据结构标志性产物，(线性表大多都现成api可以使用),因为树的`难度相比线性表大一些`并且树的`拓展性很强`，你所知道的树、二叉树、**二叉排序树**，**AVL树**，线索二叉树、**红黑树**、B数、线段树等等高级数据结构。然而二叉排序树是所有的基础，所以彻底搞懂二叉排序树也是非常重要的。
【查找算法】6种常见的查找算法简述及Python代码实现
一个甜甜的大橙子的博客
05-10 5450
6种查找算法简述及Python实现
链表树图排序查找
06-27
在"ExamCpp"这个文件中，我们可以推测这可能是一个学习资源或练习项目，它包含了关于链表、树、图的实现和排序查找算法的编程示例。通过研究和实践这些代码，可以加深对这些基础数据结构和算法的理解，提升编程技能...
数据结构-链表相关功能和算法
06-11
在这个"数据结构-链表相关功能和算法"的主题中，我们将深入探讨链表的原理、操作以及它们在实际问题中的应用。 链表的基本概念： 1. 链表是由一系列节点构成的，每个节点包含数据部分和指针部分，指针指向下一个...
数据结构链表树图查找排序
09-20
在树和图结构中，查找算法通常更快，如二叉搜索树的查找时间复杂度为O(log n)。哈希表提供常数时间的查找，但需要额外的空间来存储索引。 5. **排序**：排序是将一组数据按照特定顺序排列的过程。常见的排序算法有...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 934
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 231
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 241
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 306
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
二元查找树转排序双向链表算法解析
其中，将二元查找树（BST）转换成排序的双向链表是一个典型的算法问题，它涉及到数据结构的深入理解和巧妙操作。 二元查找树是一种特殊的二叉树，它的每个节点都满足左子树上所有节点的值小于当前节点的值，而右子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Limux8

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

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

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

打赏作者

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

抵扣说明：

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

余额充值