考研408 王道数据结构算法题整理（一）数组

nabobess

已于 2023-03-09 15:16:36 修改

阅读量649

点赞数 3

分类专栏：考研408 文章标签：考研算法数据结构

于 2023-03-09 15:15:36 首次发布

本文链接：https://blog.csdn.net/nabobess/article/details/129423578

版权

考研408 专栏收录该内容

8 篇文章 18 订阅

订阅专栏

文章详细介绍了快速排序、折半查找和归并排序的代码实现，包括基于数组和链表的数据结构。同时，提到了暴力解法的优化方向，如最大最小值计算、交换和比较函数的使用，并分析了时间复杂度。此外，还展示了顺序表的操作，如数组翻转、删除特定元素以及合并有序数组的方法。

摘要由CSDN通过智能技术生成

1.1.1 整理并理解快速排序代码

void Qsort(int A[], L, R){       //a数组保存数据，L和R是边界
   if (L>=R) return;             //当前区间元素个数<=1则退出
   int key, i=L, j=R;            //i和j是左右两个数组下标移动
   把a数组中随机一个元素和A[L]交换  //快排优化，使得基准值的选取随机
   key=A[L];                     //key作为枢值参与比较
   while (i<j){
      while (i<j && A[j]>key)
          j--;
      while (i<j && A[i]<=key)
          i++;
      if (i<j)
          swap(A[i], A[j]);      //交换A[i]和A[j]
   }
   swap(A[L], A[i]);
   Qsort(A, L, i-1);            //递归处理左区间
   Qsort(A, i+1, R);            //递归处理右区间
}

1.1.2 整理并理解折半查找代码

1）基于数组的

int Binary_Search(int A[], int L, int R, int x){   //A[]和x不一定是int型
   int mid;
   while (L<R){                                   //如果L>R则范围错误
      mid=(L+R)/2;                                //mid取中间数，向下取整
      if (x<=A[mid]) R=mid;
          else L=mid+1;                          //更新查找范围
   }
   if (A[L]==x) return L;                        //查找成功，返回数组下标L
      else return -1;                            //查找失败
}

2）基于顺序有序表的

int Binary_Search(SeqList L, Elemtype key){
	int low=0, high=L.Len-1, mid;
	while(low<=high){
		mid=(low+high)/2;
		if(L.data[mid]==key) return mid;
		else if(L.data[mid]<key) low=mid+1;
		else high=mid-1;
	}
	return -1;
}

1.1.3 整理并理解归并排序代码

1）顺序表存储

void Merge(ElemType R[],ElemType T[],int low,int mid,int high)
{ 
   //将有序表R[low..mid]和R[mid+1..high]归并为有序表T[low..high] 
	int i,j,k;
	i=low; j=mid+1;k=low; 
    while(i<=mid&&j<=high)
	{
		//将R中记录由小到大地并入T中 
		if(R[i].key<=R[j].key) T[k++]=R[i++]; 
        else T[k++]=R[j++]; 
	} 
	while(i<=mid)               //将剩余的R[low..mid]复制到T中 
		T[k++]=R[i++];
	while(j<=high)              //将剩余的R[j.high]复制到T中 
		T[k++]=R[j++];
}

2）链表存储

LinkList MergeLinkList(LinkList A,LinkList B){ 
    LinkList C=(LinkList)malloc(sizeof(LNode));
    C->next=NULL;
    LNode *pc=C, *r=C;
    LNode *pa=A->next;
    LNode *pb=B->next;
    while(pa!=NULL&&pb!=NULL){
    	if(pa->data<=pb->data){
    		r->next=pa;
    		r=pa;
			pa=pa->next;
		}
		else{
			r->next=pb;
			r=pb;
    		pb=pb->next;
		}
	}
	while(pa!=NULL){
		r->next=pa;
		r=pa;
		pa=pa->next;
	}
	while(pb!=NULL){
		r->next=pb;
		r=pb;
		pb=pb->next;
	}
	return C;
}

1.1.4 总结数组做题流程——暴力——优化方向

1.1.4.1 可以直接用的代码

最大最小值Max_int、Min_int
比大小函数max(a, b)、min(a, b)
输入输出函数cin、cout
交换函数swap(a, b)
取绝对值abs(a)

1.1.4.2 复杂度问题

1.对于循环：搞清楚主语句实现的次数
如：

   for (i=1;i<n;i*=2)                  //22考研真题
      for (j=0;j<i;j++)
          sum++;

语句“sum++”共实现了T=1+2+4+8+16+…2^k=2(k+1)-1次，n<T<2n, 即时间复杂度是O(n)
2.对于递归：展开公式写几项总结规律
如P8 二、01题以及P11 归纳总结第2点

1.2.1 顺序表的数据结构定义

静态分配

#define MAXSIZE 100
typedef struct{
	ElemType data[MAXSIZE];
	int length;
}Sqlist;

动态分配

#define InitSize 100
typedef struct{
	ElemType *data;
	int MaxSize,length;
}Sqlist;

1.3.1 P18.1 将一个数组前后翻转

void Reverse(Sqlist &S){
	for(int i=0;i<S.length/2;i++){
		swap(S.data[i],S.data[S.length-1-i]);
	}
}

1.3.2 P18.3 删除数组中值为x的元素

算法思想：用k记录顺序表L中不等于x的元素个数（即需要保存的元素个数），扫描时将不等于x的元素移动到下标k的位置，并更新k值。扫描结束后修改表长。

void DelectX(Sqlist &S, ElemType x){
	int k=0;
	for(int i=0;i<S.length;i++){
		if(S.data[i]!=x){
			S.data[k]=S.data[i];
			k++;
		}
	}
	S.length=k;
}

1.3.3 P18.7 将两个有序数组合并成一个有序数组

void Merge(Sqlist A, Sqlist B, Sqlist &C){
	int i=0,j=0,k=0;
	while(i<A.length && j<B.length){
		if(A.data[i]<=B.data[j]){
			C.data[k++]=A.data[i++];
		}
		else{
			C.data[k++]=B.data[j++];
		}
	}
	while(i<A.length){
		C.data[k++]=A.data[i++];
	}
	while(j<B.length){
		C.data[k++]=B.data[j++];
	}
	C.length=k;
}