小罗哥的算法学习笔记

初级排序算法

选择排序的实现

实现思想是：选择数组的第一个数，然后和第二数进行对比，如果大于或者小于就交互，以此类推

 void swap(int p[], int i, int minindex)
 {
	 int temp = p[i];
	 p[i] = p[minindex];
	 p[minindex] = temp;
 }
int main()
{
	int abc[] = { 7,8,91,5,4,8,3,1,564,321,6 };
	int end = sizeof(abc) / sizeof(abc[0]);
	for (int i = 0; i <end-1; i++)
	{
		int minindx = i;
		for (int j = i+1; j < end; j++)
		{
			minindx = abc[minindx] <abc[j] ? j : minindx;
			
			
		}
		swap(abc, i, minindx);

	}

插入排序

实现思想：将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动

void swap(int p[], int i, int minindex)
 {
	 int temp = p[i];
	 p[i] = p[minindex];
	 p[minindex] = temp;
 }
int main()
{
	int abc[] = { 7,8,55,31,4,8,3,1,54,31,61,1,10 };
	int end = sizeof(abc) / sizeof(abc[0]);
	for (int i = 1; i <end; i++)
	{
		for (int j = i-1; j >=0 &&abc[j]>abc[j+1]; j--)
		{		
			swap(abc, j,j+1 );	
		}
	}
	for (int  k = 0; k < end; k++)
	{
		cout << abc[k] << endl;

	}
	return 0;
}

递归思想：

函数调用子过程分为左子过程右子过程，左子过程调用孙左右子过程返回最大值，右子过程如此；实际上在实现的过程中getmax(arr,0,arr.size()-1)会首先压入栈中等待下一步返回

	int getmax(vector<int>&a,int l,int r)
	{
		if (l == r) return a[l] ;
		int mid = (l + r) / 2;
		int maxleft = getmax(a, l, mid);
		int maxRight = getmax(a, mid+1, r);
		return fmax(maxleft, maxRight);
	}
int main()
{
	
	vector <int>arr = { 8,10,21,1,8,87,100 };
	cout << getmax(arr,0,arr.size()-1) << endl;

	return 0;
}

归并排序

数组一分为二，左右子数组分别排序，随后通过插入的方式进行合并

  public static void main(String[] args) {
        int a[]={10,88,15,7,3279,8654,98,4};
        mergetsort(a);
        for (int i=0;i<a.length;i++)
        {
            System.out.println(a[i]);
        }
    }
    public static void  mergetsort(int[]arr)
    {
        if(arr==null||arr.length<2) return;
        sortProcess(arr,0,arr.length-1);
    }
    public static void sortProcess(int[]arr,int L,int R)
    {
        if (L==R) return;
        int mid=L+((R-L)>>1);
        sortProcess(arr,L,mid);
        sortProcess(arr,mid+1,R);
        merge(arr,L,mid,R);
    }
    public static void merge(int []arr,int L,int mid,int R)
    {
        int help[]=new int[R-L+1];
        int i=0;
        int p1=L;
        int p2=mid+1;
        while (p1<=mid&&p2<=R)
        {
            help[i++]=arr[p1]<arr[p2]?arr[p1++]:arr[p2++];
        }
        while (p1<=mid)
        {
            help[i++]=arr[p1++];
        }
        while (p2<=R)
        {
            help[i++]=arr[p2++];
        }
        for(i=0;i<help.length;i++)
        {
        arr[L+i]=help[i];
        }
    }