数据结构算法题整理2

最新推荐文章于 2023-11-20 08:00:00 发布
最新推荐文章于 2023-11-20 08:00:00 发布
阅读量674 收藏 11
点赞数 3
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AnalogElectronic/article/details/102887963
版权

1.将一个线性表中所有奇数移到偶数之前的算法

#include<stdio.h>

void move_odd(int r[],int s,int t)
{
	int i=s,j=t,x=r[s];
	while(i<j)
	{
		while(i<j && r[j]%2==0)j--;if(i<j){r[i]=r[j];i++;}
		while(i<j && r[i]%2==1)i++;if(i<j){r[j]=r[i];j--;}
	}
	r[i]=x;
}

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

void main()
{
	int a[9]={1,2,3,4,5,6,7,8,9};
	traverse_array(a,9);
	move_odd(a,0,8);
	traverse_array(a,9);
}

在这里插入图片描述

2.链式存储二叉树，在二叉树中查找某元素，如果二叉排序树中存在该元素则函数结束，否则插入该元素
#include<stdio.h>
#include<stdlib.h>

typedef struct BiTNode
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void initBiTree(BiTree *BT)
{
	(*BT)=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->lchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->data=5;
	(*BT)->lchild->data=4;
	(*BT)->rchild->data=6;
	(*BT)->lchild->lchild=NULL;
	(*BT)->lchild->rchild=NULL;
	(*BT)->rchild->lchild=NULL;
	(*BT)->rchild->rchild=NULL;
}


void MidOrder(BiTree T)
{
	if(T)
	{
		MidOrder(T->lchild);
		printf("%3d",T->data);
		MidOrder(T->rchild);
	}
}

//二叉搜索树的非递查找归算法
int Find(BiTree T,int item)
{
	while(T)
	{
		if(item==T->data)
			return 1;
		else if(item<T->data)
			T=T->lchild;
		else T=T->rchild;
	}
	return -1;
}


//在二叉树中查找某元素，如果二叉排序树中存在该元素则函数结束，否则插入该元素

int BSTInsert(BiTree *T,int key)
{
	if((*T)==NULL)
	{
		(*T)=(BiTree)malloc(sizeof(BiTNode));
		(*T)->data=key;
		(*T)->lchild=(*T)->rchild=NULL;
		return 1;		
	}
	else if(key==(*T)->data)
	{
		return 0;
	}
	else if(key<(*T)->data)
	{
		return BSTInsert(&(*T)->lchild,key);  //在左子树查找
	}
	else
	{
		return BSTInsert(&(*T)->rchild,key);  //在右子树中查找
	}
}

int main()
{
	BiTree T;
	initBiTree(&T);
	MidOrder(T);
	if(Find(T,6))printf("查找成功\n");
	BSTInsert(&T,3);
	MidOrder(T);
	return 0;
}

在这里插入图片描述
3.辗转相除法求最大公约数

#include<stdio.h>


int greatestCommonDivisor(int a,int b)
{
	int w,t,p;
	w=a*b;
	while(b!=0)   //辗转相除法
	{
		if(a<b)
		{
			p=a;
			a=b;
			b=p;
		}
		t=a%b;
		a=b;
		b=t;
	}
	return a;
}

int main()
{
	printf("greatestCommonDivisor(12,36) is %d\n",greatestCommonDivisor(12,36));
	printf("leastCommonMultiple(12,36) is %d\n",12*36/greatestCommonDivisor(12,36));
	return 0;
}

在这里插入图片描述
4.按升序合并两个有序链表

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

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;


//头插法初始化链表
void build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%6d",p->data);
		p=p->next;
	}
	printf("\n");
}

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

//两个有序单链表的合并排序算法
void MergeLinkList(LinkList ha,LinkList hb,LinkList *hc)
{
	LinkList s=(*hc)=0;
	while(ha!=0 && hb!=0)
		if(ha->data<hb->data)
		{
			if(s==0)
				(*hc)=s=ha;
			else{s->next=ha;s=ha;}   
			ha=ha->next;
		}
		else
		{
			if(s==0)
				(*hc)=s=hb;
			else{s->next=hb;s=hb;}
			hb=hb->next;
		}		
	if(ha==0) s->next=hb; else s->next=ha;	
}

void main()
{
	LinkList La,Lb,Lc,*p;
	int a[9]={1,3,21,52,81,411,1311,11000,63000};
	int b[9]={8,31,72,511,820,900,1300,1311,1500};
	build_node(&La,a,9);
	build_node(&Lb,b,9);
	traverse_node(La);
	traverse_node(Lb);
	MergeLinkList(La,Lb,&Lc);
	traverse_node(Lc);
}

在这里插入图片描述
5.按升序合并两个有序顺序表

#include<stdio.h>

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


//两个有序顺序表合并按升序合并为一个顺序表
void mergeSq(int a[],int len_a,int b[],int len_b,int c[])
{
	
	int i=0,j=0,k=0;
	while(i<len_a && j<len_b)
	{
		if(a[i]<=b[j])
		{
			c[k]=a[i];++i;
		}
		else
		{
			c[k]=b[j];++j;
		}
		k++;
	}

	while(i<len_a)
		c[k++]=a[i++];
	while(j<len_b)
		c[k++]=b[j++];
}

void main()
{
	int a[9]={1,3,2,4,43,51,63};
	int b[9]={8,9,17,25,38,39,43,44,75};
	int c[16];
	traverse_array(a,7);
	traverse_array(b,9);
	mergeSq(a,7,b,9,c);
	traverse_array(c,16);
}

在这里插入图片描述
6.判断二叉树A中是否有自树的结构和树B一样

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

typedef struct BiTNode
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void initBiTree(BiTree *BT)
{
	(*BT)=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->lchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->data=5;
	(*BT)->lchild->data=4;
	(*BT)->rchild->data=6;
	(*BT)->lchild->lchild=NULL;
	(*BT)->lchild->rchild=NULL;
	(*BT)->rchild->lchild=NULL;
	(*BT)->rchild->rchild=NULL;
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

bool isSubTree(BiTree T1,BiTree T2)
{
	if(T2==NULL)return true;
	if(T1==NULL && T2!=NULL)return false;
	if(T1->data=T2->data)
		return isSubTree(T1->lchild,T2->lchild) && isSubTree(T1->rchild,T2->rchild);
	return false;
}

bool HasSubtree(BiTree T1,BiTree T2)
{
	if(T2==NULL)return false;
	if(T1==NULL && T2!=NULL)return false;
	bool flag=false;
	if(T1->data==T2->data)
		flag=isSubTree(T1,T2);
	return flag||HasSubtree(T1->lchild,T2->lchild)||HasSubtree(T1->rchild,T2->rchild);
}

void main()
{
	BiTree T1,T2,T3;
	initBiTree(&T1);
	initBiTree(&T2);
	T3=(BiTree)malloc(sizeof(BiTNode));
	T3->data=4;
	T3->lchild=0;
	T3->rchild=0;
	preOrder(T1);
	if(HasSubtree(T1,T2))
	printf("T1 has subTree T2\n");
	if(HasSubtree(T1,T3))
	printf("T1 has subTree T3\n");
}

在这里插入图片描述
7.统计一个数组中相同元素的个数

#include<stdio.h>

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

void countArrayElement(int *a,int n)
{
	int count=0;
	for(int i=0;i<n;i++)	
	{
		for(int j=0;j<n;j++)
		{
			if(a[i]==a[j])
				count++;
		}
		printf("array element %d has %d\n",a[i],count);
		count=0;
	}
}

void main()
{
	int b[9]={8,9,17,25,8,39,43,8,75};
	traverse_array(b,9);
	countArrayElement(b,9);
}

在这里插入图片描述
8.设计在链式存储结构上交换二叉树中所有左右子树的算法

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

typedef struct BiTNode
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void initBiTree(BiTree *BT)
{
	(*BT)=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->lchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->data=5;
	(*BT)->lchild->data=4;
	(*BT)->rchild->data=6;
	(*BT)->lchild->lchild=NULL;
	(*BT)->lchild->rchild=NULL;
	(*BT)->rchild->lchild=NULL;
	(*BT)->rchild->rchild=NULL;
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

void swapbitree(BiTree BT)
{
	BiTree p;
	if(BT==0)return;
	swapbitree(BT->lchild);swapbitree(BT->rchild);
	p=BT->lchild;BT->lchild=BT->rchild;BT->rchild=p;
}

void main()
{
	BiTree T;
	initBiTree(&T);
	preOrder(T);
	swapbitree(T);
	preOrder(T);
}

在这里插入图片描述

9.交换数组a1a2…amb1b2…bmc1c2…cm为c1c2…bm…b2b1a1a2…am

#include<stdio.h>

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


void reverseA(int array[],int left,int right)
{
	int temp,mid,i;
	mid=(right-left)/2;
	for(i=0;i<=mid;i++)
	{
		temp=array[left+i];
		array[left+i]=array[right-i-1];
		array[right-i-1]=temp;
	}
}

void main()
{
	int array[9]={1,2,3,4,5,6,7,8,9};
	traverse_array(array,9);
	reverseA(array,0,9);
	reverseA(array,0,3);
	reverseA(array,6,9);
	traverse_array(array,9);
}

在这里插入图片描述

9.1采用以下办法时间复杂度可以更小

#include<stdio.h>

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

void reverseA(int array[],int left,int right)
{
	int temp,mid,i;
	mid=(right-left)/2;
	for(i=0;i<=mid;i++)
	{
		temp=array[left+i];
		array[left+i]=array[right-i-1];
		array[right-i-1]=temp;
	}
}

void swapArray(int array[],int n)
{
	int tmp;
	for(int i=0;i<n/3;i++)
	{
		tmp=array[i];
		array[i]=array[i+2*n/3];
		array[i+2*n/3]=tmp;
	}
}

void main()
{
	int array[9]={1,2,3,4,5,6,7,8,9};
	traverse_array(array,9);
	swapArray(array,9);
	reverseA(array,3,6);
	traverse_array(array,9);
}

10.求二叉树根结点左右子树相隔最远的叶子结点之间的距离

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

typedef struct BiTNode
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

int i=0;
void create_binary_tree(BiTree *T)
{
	printf("create binary tree\n");
	int a;
	scanf("%d",&a);
	if(a==0)(*T)=NULL;

	else
	{
		(*T)=(BiTree)malloc(sizeof(BiTNode));
		(*T)->data=a;
		create_binary_tree(&(*T)->lchild);
		create_binary_tree(&(*T)->rchild);
	}	
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

void MidOrder(BiTree T)
{
	if(T)
	{
		
		MidOrder(T->lchild);
		printf("%3d",T->data);
		MidOrder(T->rchild);
	}
}

int Distance(BiTree T)
{
	if(T==NULL)
		return -1;  //空结点高度不计
	int Ltree=Distance(T->lchild)+1;  //左子树高度+1
	int Rtree=Distance(T->rchild)+1;  //右子树高度+1
	int LRdistance=Ltree+Rtree;
	return LRdistance;
}

void main()
{
	BiTree T;
	create_binary_tree(&T);
	preOrder(T);
	MidOrder(T);
	int m=Distance(T);
	printf("%d",m);
}

在这里插入图片描述

AnalogElectronic
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构|设计一个算法，将顺序表的所有奇数移动到偶数的前面
jingling555的博客
01-13 3196
法2：可以从两端开始扫描，如果左边扫描的元素为奇数，则跳过，如果右边扫描的元素为偶数，则跳过，直到左边找到偶数，右边找到奇数，让这两个数交换。法1：可以从头扫描顺序表的元素，当扫描到该元素为奇数，让k++，奇数区间+1（k初始值为-1），然后让该元素与L->data[i]交换。设计一个算法，将顺序表的所有奇数移动到偶数的前面。
将所有奇数移动到所有偶数之前
niulinbiao的博客
09-09 1942
设计将所有奇数移到所有偶数之前的算法。算法思想：利用快速排序的思想。
设计将所有奇数移到所有偶数之前的算法
假技术Po主
02-20 9238
/* 设计将所有奇数移到所有偶数之前的算法 (这里不考虑负数) */ #include&amp;amp;lt;stdio.h&amp;amp;gt; #define N 100 //宏定义 //实现函数 void move(char [],int,int); void main() { char num[N];//这里用char型数组更好 int len; printf(&amp;quot;请输入一串数字：\n&amp;quot;); gets(...
把数组中的所有奇数移动到所有偶数之前
GTC的博客
10-23 2937
**题目：**设计一个将整数数组a[0:n-1]中所有奇数移到所有偶数之前的算法。 要求不另外增加存储空间且时间复杂度为O(n) 思路： 1.创建两个指向数组第一个元素的指针front1，front2。 2.用front2使用for循环对数组进行遍历，并判断数组元素的类型（奇数\偶数） 3.如果front2所指向的元素为偶数，则对下一个元素进行奇偶性判断。 4.如果front2所指向的元素为奇数，则将front2所指向的元素与front1所指向的元素进行调换。 5.front2所指向的元素与front1所指
王道数据结构课后代码题p335 3.设计把所有奇数移动到所有偶数前面的算法（c语言代码实现）
最新发布
m0_46702681的博客
11-20 1404
快速排序是一种常用的排序算法，它利用分治思想将一个序列分成两个子序列，并将小于某个数（称为基准数或枢纽元素）的元素移动到基准数的左侧，大于基准数的元素移动到基准数的右侧，然后对左右两个子序列分别递归进行快速排序，直到子序列中只剩下一个元素或为空时结束递归。我们这一题不用设置基准元素，但是得设置一个临时变量，防止数据被覆盖。然后++i找到一个偶数，--j找到一个奇数。然后++i找到一个偶数，--j找到一个奇数。然后++i找到一个偶数，--j找到一个奇数。首先我们从i=0开始，j=9；
数据结构与算法面试题整理
09-12
数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、...
330道大厂数据结构算法真题
01-10
经典数据结构算法题，它涵盖了很多互联网大厂的数据结构算法的笔试面试真题，包括选择题、简答题、手撕算法题。虽然它整理的年限较早，但不影响它是经典的事实，还是很值得学习的。
2023数据结构与算法面试题手册
12-17
面试必备：数据结构与算法面试题 最新2023整理版
【BAT必备】数据结构算法面试题
05-21
2020年最新Java面试题整理，全网最全一份，包含各个技术栈，Java基础，Java集合，多线程，...MySQL，Nginx，rabbitmq，Redis，Tomcat，zookeeper，设计模式，数据结构，算法，分布式，限流，降级，cap原理等等知识点
面试题中最常用的数据结构和算法【整理】.txt
05-19
面试题中最常用的数据结构和算法【整理】.txt
将数组中所有奇数移动到所有偶数之前的算法
haimianjie2012的专栏
10-22 6476
// 2016_3_Aarry.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include &lt;stdio.h&gt; #define SIZE 10 void Reverse(int* arr,int len) { int i=0,j=len-1,temp; ...
线性表：把所有奇数移动到所有偶数前边
YJH_Algorithm的博客
04-23 6724
已知线性表按顺序存储，且每个元素都是不相同的整数型元素，设计把所有奇数移动到所有偶数前边的算法（要求时间最少，辅助空间少）。 void move(ElemType A[] ,int len) { int i=0,j=len-1; //i表示左端偶数元素的下标，j表示右端奇数元素的下标 while(i<j) { while(i<j&&A[i]%2!=0) i++; //从前向后找到
考研数据结构之数组（5.2）——练习题之将数组所有奇数移到偶数之前（C表示）
二木成林
05-22 3279
题目 设计一个算法，将数组A[0, .... , n-1]中所有奇数移动到偶数之前，要求不另增存储空间，且时间复杂度为O(n)。 分析 设置两个指针i和j,i从数组的左边往右边遍历，j从数组的右边往左边遍历，当i指向偶数，j指向奇数的时候，将A[i]与A[j]交换；当i大于等于j的时候，算法结束。 代码 核心代码： /* 分离偶数与奇数，将奇数放到数组的前端，偶数放到后端 */ /* A[]指的是要分离的数组；n指的是数组元素的长度 */ void divide(int A[],int .
线性表练习之Example011-分解链表中的奇数节点和偶数节点
二木成林
03-28 932
设计一个算法，将一个头结点为 `A` 的单链表（其数据域为整数）分解成两个单链表 `A` 和 `B`，使得 `A` 链表只含有原来链表中 `data` 域为奇数的结点，而 `B` 链表只含有原链表中 `data` 域为偶数的结点，且保持原来的相对顺序。
将顺序表的奇数移至到偶数前
weixin_52571503的博客
11-10 122
已知线性表按顺序存储，且每个元素都是不相同的整数型元素，设计把所有的奇数移到所有偶数前边的算法（要求时间最少，辅助空间少）循环结束：while(++i)执行完后，i=0；while（i++）执行完后，i=1；while(++i)是先执行i+1，在进行判断，在执行循环体；while(i++)是先进行判断，在执行循环体，在+1；
给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。 请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。如下实例。示例 :输入: 1-＞2-＞3-＞4-
thq_kuqi的博客
12-11 1124
【代码】给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。如下实例。示例 :输入: 1-＞2-＞3-＞4-
数组中奇数全部放到偶数前。
bamuyu0353的博客
10-19 653
(1)、将数组A[0.....n]中所有的奇数移到所有偶数前，要求不增加存储空间，且时间复杂度为O(n) //算法分析：**设置两个指针i,j。其中i从左往右，j从右往左。当i指向偶数，j指向奇数时交换两个位置的值。当i>j时结束。** void MoveForward(int a[],int n) { int i=0; int j=n-1; int tem...
调整数组顺序使奇数位于偶数前面。输入一个整数数组,实现一个函数来调整该数组中的数字顺序,使得所有的奇数位于所有的偶数前面。
wzdxsa的博客
09-19 147
定义下标i从前往后遍历数组寻找偶数，定义下标j从后往前遍历数组寻找奇数，每找到一组奇数和偶数就将两个数互换位置，然后接着遍历，直到两个下标相遇错过后结束。这个是在原数组里进行操作，所以空间复杂度为O（1）。与原数组等长的新数组。下面的空间复杂度为O（1）但存在bug。这个算法的时间复杂度为O(n)，因为三个。空间复杂度也为O(n)，因为创建了一个。2.将原数组遍历一遍把奇数复制下来（for循环1）3.将原数组遍历一遍把偶数复制下来（for循环2）4.将新数组的数据复制回到原数组（for循环3）
C语言：调整数组使奇数全部都位于偶数前面
正在努力学C呀！（要学好久呢......）
06-28 1291
使用C语言：调整数组使奇数全部都位于偶数前面。包含题目、分步骤思路、最终实现代码 和 最终实现效果。
考研数据结构代码整理
09-09
考研数据结构的代码整理是一个相对复杂的过程，涉及到多种数据结构和算法的实现。为了更好地应对考研数据结构的编程题目，建议你学习和掌握常见的数据结构，如数组、链表、栈、队列、树、图等，并学会它们的基本操作...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值