数据结构(C)

数据结构©

一、排序算法

1.插入排序

直接插入排序

//从第二个数开始，先判断当前的数是否小于前一个数，如果小于，就从当前数的前一个数开始判断（是否大于当前数，如果满足的话就将前一个数往后移动一位，循环结束把当前数插入适当的位置）
void InsertSort(int *p,int n){
    int i,j,temp;
	for(i=1;i<n;i++){
		if(p[i]<p[i-1]){
			temp = p[i];
			for(j=i-1;j>=0&&p[j]>temp;j--){
				p[j+1]=p[j];
			}
			p[j+1]=temp;
		}
    }
}

折半插入排序

void InsertSort(int *p,int n){
int i,j,low,high,mid,temp;
	for(i=1;i<n;i++){
		temp =p[i];  //从1为下标的位置开始，把p[1]~~p[n-1]插入到前面已排序的队列
		low=0;
		high=i-1;
        //找出插入位置
		while(low<=high){
		mid=(low+high)/2;
		if(p[mid]>temp) 
			high=mid-1;
		else             //当p[mid] = temp时，为了稳定性也向右边走一位
			low=mid+1;
		}
        //将[low,i-1]个数往后面移动一位
		for(j=i-1;j>=low;j--)
			p[j+1]=p[j];
		p[low] = temp;
	}
}

希尔排序

void ShellSort(int *p , int n){
    int d,i,j,temp;
	  for(d=n/2;d>=1;d=d/2){                   //d的迭代，每次相邻的距离不一样
		  for(i=d;i<n;i++){                    //从每次小的排序序列的第二个开始排序
			//下面的算法就跟直接插入排序的算法是一样的，只是每次不再是加一
              if(p[i]<p[i-d]){
				temp =p[i];
				for(j=i-d;j>=0&&p[j]>temp;j-=d)
					p[j+d]=p[j];		
				p[j+d]=temp;
			  }
		  }
	  }
}

2.交换排序

冒泡排序

//从后往前冒泡
void BubbleSort(int *p,int n){
    	int i,j,temp,flag;
	for(i=0;i<n-1;i++){
		flag =0;
		for(j =n-1;j>i;j--){
			if(p[j]<p[j-1]){
				temp =p[j];
				p[j]=p[j-1];
				p[j-1]=temp;
				flag = 1;
			}
		}
		if(flag == 0)
			return;
	}
}
//从前往后冒泡
void BubbleSort(int *p,int n){
    int i,j,temp,flag;
	  for( i=0;i<n-1;i++){
		  flag = 0;
		  for(j=0;j<n-1-i;j++){
			  if(p[j]>p[j+1]){
				temp=p[j];
				p[j]=p[j+1];
				p[j+1]=temp;
				flag=1;
			  }
		  }
		  if(flag == 0)
			  return;
      }
}

快速排序（内部排序中，最优秀的）

void QuickSort(int *p,int low,int high){          //low和high是数组的下标[0,n-1]
	int Partition(int *p,int low,int high);
	if(low<high){
		int pivotpos = Partition(p,low,high);
		QuickSort(p,low,pivotpos-1);
		QuickSort(p,pivotpos+1,high);
	}
	
}
int Partition(int *p,int low,int high){
	int pivot =p[low];
	while(low<high){
		while(low<high && p[high]>=pivot)
			high--;
		p[low] = p[high];
		while(low<high && p[low]<=pivot)
			low++;
		p[high]=p[low];
	}
	p[low]=pivot;     //最后low==high，所以用low和high在这里是一样的
	return low;
}

3.选择排序

简单选择排序

void SelectSort(int *p,int n){
    	int min,temp,i,j;
	for(i=0;i<n-1;i++){
		min=i;
		for(j=i+1;j<n;j++){
			if(p[j]<p[min])
				min=j;
		}
		if(min != i){
			temp =p[min];
			p[min]=p[i];
			p[i]=temp;
		}	
	}
}

堆排序

//ppt讲解的是把p[0]留空，记录p[k],代码中的注解就是这种情况时的代码
//没有注解的就是数组从0开始的情况
//可以按照从1开始理解，只是取值的时候索引减去1就行了
//len是数组的长度
void HeapSort(int *p,int len){
	int temp,i;
	void HeadAdjust(int *p,int k,int len);
	void BuildMaxHeap(int *p,int len);
	BuildMaxHeap(p,len);
	for(i=len;i>1;i--){
		/*temp =p[i];
		p[i]=p[1];
		p[1]=temp;*/
		temp =p[i-1];
		p[i-1]=p[0];
		p[0]=temp;
		HeadAdjust(p,1,i-1);
	}

}

void HeadAdjust(int *p,int k,int len){
	//int temp=p[k];
	int i,temp;
	temp=p[k-1];
	for(i=2*k;i<=len;i*=2){
			//if(i<len && p[i+1]>p[i])
			if(i<len && p[i]>p[i-1])
				i++;
			//if(p[i]<temp)
			if(p[i-1]<temp)
				break;
			else{
				//p[k]=p[i];
				p[k-1]=p[i-1];
				k=i;
			}
	}
	p[k-1]=temp;
}
void BuildMaxHeap(int *p,int len){
	int i;
	for(i=len/2;i>0;i--)
		HeadAdjust(p,i,len);
}

4.归并排序

//两个有序数组合并，是利用一个新的数组，将两个下标相邻的数组，复制到这个新的数组中，再用i,j把新数组中
//数再放回原数组
void Merge(int *p,int low,int mid,int high){    //high为数组下标，所以数组长度为high+1
	int i,j,k,*b;
	b=(int *)malloc((high+1)*sizeof(int));
	
	for(k=low;k<=high;k++)
		b[k]=p[k];
	for(i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){
		if(b[i]<=b[j])
			p[k]=b[i++];
		else
			p[k]=b[j++];
	}
	while(i<=mid)
		p[k++]=b[i++];
	while(j<=high)
		p[k++]=b[j++];

}
void MergeSort(int *p,int low,int high){
	if(low<high){
		int mid;
		mid = (low+high)/2;         //从中间分开
		MergeSort(p,low,mid);           //对两边分别归并
		MergeSort(p,mid+1,high);
		Merge(p,low,mid,high);
	}                                                  
}

5.基数排序

6.多路归并排序