C++进阶教程(一)

C++进阶教程(一)

C++入门教程

• 补：之前，我们讲了判断语句if,但是我们时常碰到一连串的判断语句.这时，该怎么办呢?我们要用到switch语句.
  格式：

switch(<变量名>)
{
    case <情况一>:<语句>;break;
    case <情况二>:<语句>;break;
    case <情况三>:<语句>;break;
    ......
    case <情况四>:<语句>;break;
    default:<语句>;
}

• 注：default的意思是如果都不符合上面的情况，就执行下面语句.
• 重点：break一定要写.

算法教程

(一) 排序算法.(多次引用calmG的文章，在此致谢)

排序算法是C++的一大重要的算法，noip考试几乎年年都考.

1. 冒泡排序.(解释在注释中)

例：输入一系列数字（无序），输出其从小到大的排序.
代码：

#include<bits/stdc++.h>
using namespace std;
int n,i,j,a[2000];
bool t;              //定义变量
int main()
{
	cin>>n;
	for(i=1;i<=n;i++)
		cin>>a[i];       //输入
	for(i=1;i<=n;i++)
	{
		t=1;
		for(j=n;j>i;j--)
			if(a[j]<a[j-1])        //从后面往前两两判断
			{
				swap(a[j],a[j-1]);     //交换
				t=0;
			}
		if(t)
			break;    //如一次循环中没有交换，说明已经排好序了，退出循环  
	}
	for(i=1;i<=n;i++)
		cout<<a[i]<<" ";
	return 0;
}

2. 选择排序.(解释在注释中)

例：输入一系列数字（无序），输出其从小到大的排序.
核心代码：

// 自定义方法：交换两个变量的值
void swap(int *a,int *b) 
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
/* 选择排序 */
void selection_sort(int arr[], int len)
{
    int i,j;
    for (i = 0 ; i < len - 1 ; i++) {
        int min = i;
        for (j = i + 1; j < len; j++) {    //  遍历未排序的元素
            if (arr[j] < arr[min]) {  //  找到目前最小值
                min = j;   // 记录最小值
            }
        }
        swap(&arr[min], &arr[i]);
    }
}

3.插入排序

核心代码如下：

/* 插入排序 */
void insertion_sort(int arr[], int len){
    int i,j,key;
    for (i=1;i<len;i++){
        key = arr[i];
        j=i-1;
        while((j>=0) && (arr[j]>key)) {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}

4. 快速排序.

核心代码如下：

// 快速排序
void QuickSort(int arr[], int start, int end)
{
	if (start >= end)
		return;
	int i = start;
	int j = end;
	// 基准数
	int baseval = arr[start];
	while (i < j)
	{
		// 从右向左找比基准数小的数
		while (i < j && arr[j] >= baseval)
		{
			j--;
		}
		if (i < j)
		{
			arr[i] = arr[j];
			i++;
		}
		// 从左向右找比基准数大的数
		while (i < j && arr[i] < baseval)
		{
			i++;
		}
		if (i < j)
		{
			arr[j] = arr[i];
			j--;
		}
	}
	// 把基准数放到i的位置
	arr[i] = baseval;
	// 递归
	QuickSort(arr, start, i - 1);
	QuickSort(arr, i + 1, end);
}

5. 归并排序.

归并排序是快速排序的改良版本，更加稳定.
核心代码如下：

// 归并排序
void MergeSort(int arr[], int start, int end, int * temp) // start和end分别是左边界和右边界
{
	if (start >= end)
		return;
	int mid = (start + end) / 2;
	MergeSort(arr, start, mid, temp);
	MergeSort(arr, mid + 1, end, temp);
 
	// 合并两个有序序列
	int length = 0; // 表示辅助空间有多少个元素
	int i_start = start;
	int i_end = mid;
	int j_start = mid + 1;
	int j_end = end;
	while (i_start <= i_end && j_start <= j_end)
	{
		if (arr[i_start] < arr[j_start])
		{
			temp[length] = arr[i_start]; 
			length++;
			i_start++;
		}
		else
		{
			temp[length] = arr[j_start];
			length++;
			j_start++;
		}
	}
	while (i_start <= i_end)  // 把剩下数的合并
	{
		temp[length] = arr[i_start];
		i_start++;
		length++;
	}
	while (j_start <= j_end)
	{
		temp[length] = arr[j_start];
		length++;
		j_start++;
	}
	// 把辅助空间的数据放到原空间
	for (int i = 0; i < length; i++)
	{
		arr[start + i] = temp[i];
	}
}

6. 桶排序.

代码如下：

#include<stdio.h>
int main() {
     int book[1001],i,j,t;
     //初始化桶数组
     for(i=0;i<=1000;i++) {
       book[i] = 0;
     }
     //输入一个数n，表示接下来有n个数
     scanf("%d",&n);
     for(i = 1;i<=n;i++) {
       //把每一个数读到变量中去
       scanf("%d",&t);
       //计数  
       book[t]++;
     }
     //从大到小输出
     for(i = 1000;i>=0;i--) {
       for(j=1;j<=book[i];j++) {
         printf("%d",i);
       }
     }
    getchar();getchar();
    //getchar()用来暂停程序，以便查看程序输出的内容
    //也可以用system("pause");来代替
    return 0;
}

7. 基数排序.

代码：

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

/* 基数排序
 * 1.求出数组中最大的元素
 * 2.求出最大元素是几位数, 设为i位
 * 3.对所有的数进行i轮排序. 
 *   首先排个位, 然后是十位, 然后百位
 * 4.每一轮的排位都需要分桶, 桶是有顺序的,
 *   然后把桶里的数按顺序放入原来的数组中.
 * 5.直到i轮排序结束后, 数组排序完成.      */

/*获取数字的位数*/
int figure(int num)
{
    int count = 1;
    int temp = num / 10;

    while(temp != 0)
    {
        count++;
        temp /= 10;
    }

    return count;
}

/*查询数组中的最大数*/
int max(int *a, int n)
{
    int max = a[0];
    int i;

    for(i=1; i<n; i++)
    {
        if(a[i] > max)
        {
            max = a[i];
        }
    }

    return max;
}

/*将数字分配到各自的桶中, 然后按照桶的顺序输出排序结果*/
void sort2(int *a, int n, int loop)
{
    int *buckets[10] = {NULL};
    int c[10] = {0};
    int d[10] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
    int i, j, k;
    int row;
    int temp = d[loop-1];

    /*统计每个桶的元素个数*/
    for(i=0; i<n; i++)
    {
        row = (a[i] / temp) % 10;

        c[row]++;
    }

    /*为每个桶分配空间*/
    for(i=0; i<10; i++)
    {
        buckets[i] = (int *)malloc(c[i]*sizeof(int));
    }

    memset(c, 0x00, sizeof(c));

    /*将数组中的数据分配到桶中*/
    for(i=0; i<n; i++)
    {
        row = (a[i] / temp) % 10;

        buckets[row][c[row]] = a[i];

        c[row]++;
    }

    k = 0;

    /*将桶中的数, 倒回到原有数组中*/
    for(i=0; i<10; i++)
    {
        for(j=0; j<c[i]; j++)
        {
            a[k] = buckets[i][j];
            k++;
        }
    }

    /*释放桶内存*/
    for(i=0; i<10; i++)
    {
        free(buckets[i]);
        buckets[i] = NULL;
    }
}

/*基数排序*/
void sort3(int *a, int n)
{
    int m = max(a, n);
    int loop = figure(m);
    int i;

    for(i=1; i<=loop; i++)
    {
        sort2(a, n, i);
    }
}

int main()
{
    int a[] = {2, 343, 342, 1, 123, 43, 4343, 433, 687, 654, 3};
    int *p = a;
    int size;
    int i;

    /*计算数组长度*/
    size = sizeof(a) / sizeof(int);

    /*基数排序*/
    sort3(p, size);

    /*打印排序后结果*/
    for(i=0; i<size; i++)
    {
        printf("%d\n", a[i]);
    }

    return 0;
}