排序算法累计ing

不同的排序算法

保持学习ing

#include<iostream>
using namespace std;
#define N 11
#define true 1
#define false 0
typedef struct Sqlist{
	int r[N];
	int length=0;
}Sqlist;

void DispM(Sqlist *L);

void CreatSqlist(Sqlist *L);

void BubbleSort(Sqlist *L);/*冒泡排序*/

void EazySort(Sqlist *L);/*简单排序*/

void StraightSort(Sqlist *L);/*直接插入排序法*/

void XiErSort(Sqlist *L);/*希尔排序*/

void HeatSort(Sqlist *L);/*堆排序*/
void HeadJust(Sqlist *L, int s, int m);
void swap(Sqlist *L, int n, int m);

void MergeSort(Sqlist *L);/*归并排序*/
void MSort(int SR[], int TR[], int s, int t);
void Merge(int SR[], int TR[], int s,int m,int n);

void FastSort(Sqlist *L);/*快速排序*/
void FSort(Sqlist *L, int low, int high);
int Partition(Sqlist *L, int low, int high);

#include"Sort.h"
#include<time.h>
#include <stdlib.h>
using namespace std;

void DispM(Sqlist *L){
	if (L != NULL){
		for (int i = 1; i < N; i++){
			cout <<i<<" :"<<L->r[i] <<" "<< endl;
		}
	}
}
void CreatSqlist(Sqlist *L){
	srand((unsigned int)time(NULL));
	int a = 100, b = 1;
	L->length = 0;
	for (int i = 1; i < N; i++){
		L->r[i]=(rand() % 99 + 1);
		L->length++;
	}
	//DispM(L);
}

void BubbleSort(Sqlist *L){
	int i, j;
	int t = 0;
	for (i = 1; i < L->length + 1; i++){//顺序
		for (j = i + 1; j < L->length + 1; j++){
			if (L->r[i] >L->r[j]){
				t = L->r[j];
				L->r[j] = L->r[i];
				L->r[i] = t;
			}
		}
	}
	/*for (i = 1; i < L->length + 1; i++){//倒序
		for (j = L->length; j >= i; j--){
			if (L->r[i] >L->r[j]){
				t = L->r[j];
				L->r[j] = L->r[i];
				L->r[i] = t;
			}
		}
	}*/
	/*排除已经是顺序的数组段*/
	int flag = true;
	for (i = 1; i < L->length + 1&&flag; i++){
		flag = false;
		for (j = i + 1; j < L->length + 1; j++){
			if (L->r[i] >L->r[j]){
				t = L->r[j];
				L->r[j] = L->r[i];
				L->r[i] = t;
				flag = true;
			}
		}
	}
	//DispM(L);
}

void EazySort(Sqlist *L){
	int i, j, min;
	int t = 0;
	CreatSqlist(L);
	DispM(L);
	for (i = 1; i < L->length + 1; i++){
		min=i;
		for (j = i + 1; j < L->length + 1; j++){
			if (L->r[min]>L->r[j]){
				min = j;//找到后面的最小值，然后更换
			}
		}
		if (i!=min){
			t = L->r[min];
			L->r[min] = L->r[i];
			L->r[i] = t;
		}
	}
	DispM(L);
}

void StraightSort(Sqlist *L){/*对于已经排好的序列来说，再次插入一个值*/
	int i, j;
	CreatSqlist(L);
	DispM(L);//从小到大排列
	for (i = 2; i <= L->length; i++){//寻找需要排序的点
		if (L->r[i] < L->r[i - 1]){
			L->r[0] = L->r[i];
			for (j = i - 1; L->r[j] > L->r[0]; j--){
				L->r[j + 1] = L->r[j];//后移
			}
			L->r[j + 1] = L->r[0];
		}
	}
	for (i = 2; i <= L->length; i++){
		if (L->r[i - 1] > L->r[i]){
			L->r[0] = L->r[i - 1];
			for (j = i; L->r[j] < L->r[0]; j--){

			}
		}
	}
	DispM(L);
}

void XiErSort(Sqlist *L){
	int i, j;
	CreatSqlist(L);
	int increment = L->length;
	while (increment > 1){
		increment = increment / 3 + 1;
		for (i = increment + 1; i < L->length; i++){
			if (L->r[i] < L->r[i - increment]){
				L->r[0] = L->r[i];
				for (j = i - increment; j > 0 && L->r[0] < L->r[j]; j -= increment){
					L->r[j + increment] = L->r[j];
				}
				L->r[j + increment] = L->r[0];
			}
		}
	}
	DispM(L);
}

void HeatSort(Sqlist *L){
	CreatSqlist(L);
	int i;
	for (i = L->length / 2; i > 0; i--){//i会往后走一半  所以i的范围就变换一半
		HeadJust(L,i,L->length);
	}

	for (i = L->length; i > 1; i--){
		swap(L,1,i);
		HeadJust(L,1,i-1);
	}
	DispM(L);
}

void swap(Sqlist *L, int n, int m){
	int temp;
	temp = L->r[n];
	L->r[n]=L->r[m];
	L->r[m] = temp;
}

void HeadJust(Sqlist *L, int s, int m){//完成进行一个最大堆排序，s是排序数值的一半，
	int temp, j;
	temp = L->r[s];
	for (j = 2 * s; j <= m; j *= 2){//对于完全二叉树来说，s是中间结点；2*s是左孩子，2*s+1是右孩子。
		if (j < m&&L->r[j] < L->r[j + 1]){//选择一个较大的
			++j;
		}
		if (temp >= L->r[j]){//此时说明中间结点是二叉树中较大的
			break;
		}
		L->r[s] = L->r[j];//顶点赋予最大值。
		s = j;
	}
	L->r[s] = temp;
}

//归并 排序  未按完成
void MergeSort(Sqlist *L){
	CreatSqlist(L);
	//DispM(L);
	MSort(L->r, L->r, 1, L->length);/*无法给SR TR 赋值*/
	DispM(L);
}

void MSort(int SR[], int TR1[], int s, int t){
	int m;
	int TR2[N+1];
	if (s == t){
		TR1[s] = SR[s];
	}
	else
	{
		m = (s + t) / 2;//应用递归 将数组分半 ，一直到数组数为1，
		MSort(SR,TR2,s,m);//分别处理左半部分
		MSort(SR,TR2,m+1,t);//处理右半部分
		Merge(TR2,TR1,s,m,t);//将其合并
	}
}

void Merge(int SR[], int TR[], int i, int m, int n){
	int j, k,l;
	for (j = m + 1, k = i; i <= m&&j <= n; k++){
		if (SR[i] < SR[j]){
			TR[k] = SR[i + 1];
		}
		else{
			TR[k] = SR[j + 1];
		}
	}
	if (i <= m){
		for (l = 0; l <= m - i; l++){
			TR[k + 1] = SR[i + 1];
		}
	}
	if (j <= n){
		for (l = 0; l <= n - j; l++){
			TR[k + 1] = SR[j + 1];
		}
	}
}

/*快速排序算法*/
void FastSort(Sqlist *L){
	CreatSqlist(L);
	DispM(L);
	FSort(L, 1, L->length);/*当前排序的最小值到当前排序的最大值*/
	DispM(L);
}

void FSort(Sqlist *L, int low, int high){
	int point;//point是位于low和high的中间位置
	if (low < high){
		point=Partition(L, low, high);
		FSort(L, low, point - 1);
		FSort(L,point+1,high);
	}
}

//这核心就是围绕着选择的基准点p进行处理（p，Low往右大于p的元素，high小于p的元素，三者进行一个交换）
int Partition(Sqlist *L, int low, int high){
	int pointkey = L->r[low];
	while (low < high){/*括号里的两个循环，先设置一个基准点p，找到high小于p的进行交换，然后找到low大于p的进行交换，*/
		/*找到右边小于基准点的位置*/
		while (low < high&&L->r[high] >= pointkey)
			high--;
		swap(L, low,high);//进行交换
		/*找到左边大于基准点的点*/
		while (low < high&&L->r[low] <= pointkey)
			low++;
		swap(L,low,high);//进行交换
	}
	return low;
}

void main(){
	Sqlist *L;
	L = new Sqlist;
	//CreatSqlist(L);
	//BubbleSort(L);
	//EazySort(L);
	//StraightSort(L);
	//StraightSort(L);
	//XiErSort(L);
	//HeatSort(L);
	//MergeSort(L);
	FastSort(L);
	system("pause");
}

有n个数，要求输入一个数，把它插到数列中，使得数列仍然有序，并输出新数列

先输入乱序的数，将其存在数组中，再用排序法排好

再找到输入一个数所在数组中介于哪些数之间

记下该值所归属的位置

再用for从后往前替换

//有n个数，要求输入一个数，把它插到数列中，使得数列仍然有序，并输出新数列
#include<stdio.h>
#define N 10
#define M 11
int main()
{

	int a[N];
	int i = 0, j = 0, k, t, q;

	printf("please input %d numbers : \n", N);
	for (i = 0; i < N; i++)
	{
		scanf_s("%d", &a[i]);
	}
	printf("输出数组 \n");

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

	//冒泡排序法
	for (i = 0; i < N - 1; i++)
		for (j = 0; j < N - i - 1; j++)
			if (a[j] > a[j + 1])
			{
				k = a[j];
				a[j] = a[j + 1];
				a[j + 1] = k;
			}
	printf("从小到大排序后输出\n");
	for (i = 0; i < N; i++) {
		printf("%d", a[i]);
	}


	//插到一个序列中
	printf("请输入一个数t：\n");
	scanf_s("%d", &t);
	printf("%d\n",t);
	//找出t所在的位置
	for (i = 0; i < N; i++)
	{
		if (t >= a[i] && t <= a[i + 1])
		{
			q = i+1;
			
		}
	}

	//再将i之后的值往前移一位
	for (j = N - 1; j >= q; j--)
	{
		a[j + 1] = a[j];
	}
	a[q] = t;
	
	for (i = 0; i < M; i++)
	{
		printf("%d", a[i]);
	}
	return 0;

}

冒泡排序java实现

public class Sort
{
	public static void main(String[] args)
	{
		int t;
		int[] a={25,24,3,9,8,55,101,999,65,33,996,5};
		for(int i=0;i<a.length;i++)
			for(int j=i+1;j<a.length;j++)
		{
			if(a[i]>a[j])
			{
				t=a[j];
				a[j]=a[i];
				a[i]=t;
			}
		}

		for(int i=0;i<a.length;i++)
		{
			System.out.println(a[i]);
		}
	}
}

这种题刚刚开始学编程的时候，表示难以理解，现在哈哈哈可以

生成随机数排序

这里是一个生成随机数的过程，包括数组空间随机生成 数组元素随机生成 +冒泡排序。

import java.util.Random;
public class Sort
{
	public static void main(String[] args)
	{

		//生成一个乱序的数组
		Random rand=new Random();
		int[] a=null;
		a=new int[rand.nextInt(10)];//开辟数组空间  每次也是随机的

		for(int i=0;i<a.length;i++)
		{
			a[i]=rand.nextInt(999);
			System.out.println(a[i]);
		}

		System.out.println(a.length);
		int t;
		//int[] a={25,24,3,9,8,55,101,999,65,33,996,5};
		for(int i=0;i<a.length;i++)
			for(int j=i+1;j<a.length;j++)
		{
			if(a[i]>a[j])
			{
				t=a[j];
				a[j]=a[i];
				a[i]=t;
			}
		}

		for(int i=0;i<a.length;i++)
		{
			System.out.println(a[i]);
		}
	}
}