打印从1到最大的n位数


主要的考点：n可能很大，大到int甚至long int都会溢出，怎么解决？

网上看了几个题解，没看懂，看懂了一个思路最简单的：

从1到n按顺序打印出从1到最大的n十进制数，其实就是n个从0到9的全排列(把数字在0之前的去掉)
//打印1到最大的n位数的主方法
public void printToMaxOfDigits(int n){
	if(n <= 0){
		System.out.println("输入的n没有意义");
		return;
	}
	char number[] = new char[n];
	for (int i = 0; i < number.length; i++) {
		number[i] = '0';
	}
	for (int i = 0; i < 10; ++i) {
		number[0] = (char) (i + '0');
		printToMaxOfNDigitsRecursively(number, n, 0);
	}	
}
//利用递归实现1到最大的n位数的全排列
public void printToMaxOfNDigitsRecursively(char[] number, int n, int index) {
	if(index == n - 1){
		printNumber(number);
		return;
	}
	for (int i = 0; i < 10; ++i) {
		number[index + 1] = (char) (i + '0');
		printToMaxOfNDigitsRecursively(number, n, index + 1);
	}
}
	
//输出
private void printNumber(char[] number) {
	boolean isBeginning0 = true;
	int nLength = number.length;
	for (int i = 0; i < nLength; ++i) {
		if(isBeginning0 && number[i]!='0'){
			isBeginning0 = false;
		}
		if(!isBeginning0){
			System.out.print(number[i]);
		}
	}
	System.out.println();
}

删除链表的节点
public class sortArrayByOddEven {  //需要额外定义一个类ListNode题目有给出
	public static void main(String[] args) {
 
		ListNode pHead = new ListNode(1);   
		ListNode pAhead = new ListNode(3);
		ListNode pBhead = new ListNode(5);
		ListNode pChead = new ListNode(7);
		pHead.next = pAhead;
		pAhead.next = pBhead;
		pBhead.next = pChead;
		deleteNode(pHead,pBhead);
		while (pHead != null) {
			System.out.print(pHead.value + ",");
			pHead = pHead.next;
		}
 
	}
 
	private static void deleteNode(ListNode pHead, ListNode pBhead) {
		if(pHead==null||pBhead==null)  //当头指针为空，或者删除节点为空时
			return ;
		ListNode pNode = pHead;        
		if(pNode.next==null) {            
			while(pNode.next!=pBhead) {
				pNode = pNode.next;
			}
			pNode.next = null;
		}else {               //我们直接让删除节点的值等于删除节点的下一个节点值
             //再将删除节点的next赋值为 deleNode（删除节点）.next.next 起到间接删除的效果
                    
			pBhead.value = pBhead.next.value;
			pBhead.next = pBhead.next.next;
		}
	}	
}

题目：在命令行执行程序。要求：输入一组数字，进行排序，最后打印输出。

#include "stdafx.h"
//1.实现将数字字符串转换为数字
int strToInt(char *arr);
//2.将数字字符串数组 转换为整型数组存储
void anasiy(char *arr[],int n,int *rest);
//3.将整型数组排序（升）
void sort(int *arr,int n);
//4.输出排序结果
void output(int *arr,int n);
int main(int argc, char* argv[])
{
	int n=argc-1;
	int *rest=new int [n];//动态获取存储空间
	anasiy(argv+1,n,rest);
	output(rest,n);
	sort(rest,n);
	output(rest,n);
	delete(rest);

	return 0;
}
int strToInt(char *arr)
{
	int num=0;
	while(*arr!='\0')
	{
		if(*arr>='0'&&*arr<='9')
		{
			num=num*10+*arr-'0';
			arr++;
		}
	}
	return num;
}
void anasiy(char *arr[],int n,int *rest)
{
	for(int i=0;i<n;i++)
	{
		rest[i]=strToInt(arr[i]);
	}
}
void output(int *rest,int n)
{
	for(int i=0;i<n;i++)
	{
		printf("%d ",rest[i]);
	}
	printf("\n\n");
}
void sort(int *rest,int n)
{
	int tmp=0;
	for(int i=0;i<n;i++)
	{
		for(int j=n-1;j>i;j--)
		{
			if(rest[j]<rest[j-1])
			{
				tmp=rest[j];
				rest[j]=rest[j-1];
				rest[j-1]=tmp;
			}
		}
	}
}

1.在vc++6.0的环境下，新建一个项目，选建一个A"Holle world" application。

2.输入以上全部代码。编译运行。控制台不会有显示。因为此题时要在命令行执行的。

3.找到装有次项目  .exe 文件的 Debug文件夹。复制路径。

4.cmd打开命令行，在命令行内通过操作找到3中找到的路径，然后输入.exe 的名字  在输入数字即可。按下enter建后会在命令行显示输出，刚才输进去的数字排好序后的结果。



其中，函数分装的思想是值得初学者好好学习的！

主要的功能函数是1. 将输入的数字字符串转换为一组数字 2.将转换后的一组

其中先写了一个将单个字符串转换为数字的函数strToInt，在用anasiy函数调用strToInt函数完成全部字符串的转换。

题目
编写一个程序，创建三个任务以及三个运行这些任务的线程：

第一个任务打印字母a100次
第二个任务打印字母b100次
第三个任务打印1～100的整数

如果运行这个程序，则三个线程将共享CPU，并且在控制台上轮流打印字母和数字。

(因为现在电脑的CPU都太快了，100个数和字母根本看不出来CPU在交替执行线程，所以我将数字定为10000
效果

代码
package P1;

public class thread1 {


    public static void main(String[] args){
        //创建三个任务
        Runnable printA=new PrintChar('a',100);
        Runnable printB=new PrintChar('b',100);
        Runnable print100=new PrintNum(100000);

        //创建线程
        Thread thread3=new Thread(print100);
        Thread thread1=new Thread(printA);
        Thread thread2=new Thread(printB);
        //开始线程
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
class PrintChar implements Runnable{

    private char charToPrint;//需要打印的字母
    private  int times;//需要打印的次数

    public PrintChar() {

    }

    public PrintChar(char charToPrint, int times) {
        this.charToPrint = charToPrint;
        this.times = times;
    }

    @Override
    public void run() {
        for (int i = 0; i <= times; i++) {
            System.out.println(charToPrint);
        }
    }
}

class PrintNum implements Runnable{
    private int lastNum;

    public PrintNum(int lastNum) {
        this.lastNum = lastNum;
    }

    @Override
    public void run() {
        for (int i = 0; i < lastNum; i++) {
            System.out.println(" " + i);
        }
    }
}

思路
该程序创建了三个任务。为了同时运行它们，创建了三个线程。调用start()方法启动第一个线程，那么其中的run()方法就会被执行。当run()方法执行完毕之后，线程就终止了。

需求描述
这里考察对线程锁的使用，多线程情况下如何控制各自的执行时间段。
解题思路
我想到的有两种接替思路，一种是使用标志位，一种是使用线程锁。
使用标志位的思路如下：

两个线程一个打印偶数，一个打印奇数，两个线程要交叉执行，所以可以用一个长度为101的数组（第一个位置不用，便于打印的数字和位置保持一致）保存每个线程的执行状态，一个线程执行完毕后在对应位置设置成1，之前前判断数组中前一个位置是否为1，不为1则等待，流程如下:

初始化一个全局数组，长度为101，并且每个线程使用num计数，本线程中需要使用的数组的位置，也是需要打印的数组。
先让需要输出奇数的线程打印一次，数组中状态为1，0，0，0…，同时num+2。
后续两个线程在打印前都判断数组中前一个位置（num-1）是否为1，如果是1，则打印num，同时num+2；否则，等待另外一个线程。

使用线程锁的思路如下：

这种方式就很简单了，直接使用Lock就可以。初始化线程时在线程中设置一个标识，0代表打印偶数，1代表打印奇数。

定义一个全局变量num代表要打印的数字，在线程中判断当前要打印的数字是不是和本线程一直，即奇数=奇数线程，偶数对应偶数线程，如果一直则打印，num++，同时唤醒另外的线程；否则进行等待。
代码编写
思路一
import java.util.concurrent.locks.LockSupport;

/**
 * @Function
 * 
 *
 * @Update
 *
 * @Author cc
 * @CreateTime 2020年03月04日
 */
public class Day2020304 {

	public static void main(String[] args) throws Exception {
		Day2020304 main = new Day2020304();
		main.run();
	}

	int[] array = new int[101];

	void run() throws Exception {
		new Thread(new PrintThread(1)).start();
		new Thread(new PrintThread(2)).start();
	}

	class PrintThread implements Runnable {

		int id;

		public PrintThread(int id) {
			this.id = id;
		}
		
		public void run() {
			int num = id;
			if (id == 1) {
				System.out.println("id " + id + " - " + num);
				array[num] = 1;
				num += 2;
			}
			while (num <= 100) {
				while (array[num - 1] == 0) {
					LockSupport.parkNanos(10);
				}
				System.out.println("id " + id + " - " + num);
				array[num] = 1;
				num += 2;
			}
		}
	}
}


思路二
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Function
 * 
 *
 * @Update
 *
 * @Author cc
 * @CreateTime 2020年03月04日
 */
public class Day2020304 {

	public static void main(String[] args) throws Exception {
		Day2020304 main = new Day2020304 ();
		main.run();
	}

	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
	int num = 1;

	void run() throws Exception {
		new Thread(new PrintThread(0)).start();
		new Thread(new PrintThread(1)).start();
	}

	class PrintThread implements Runnable {

		int id;
		public PrintThread(int id) {
			this.id = id;
		}
		public void run() {
			while (num <= 100) {
				lock.lock();
				try {
					if (num % 2 == id) {
						System.out.println("id " + id + " - " + num);
						num ++;
						condition.signalAll();
					} else {
						condition.await();
					}
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					lock.unlock();
				}
			}
		}
	}
}