代码基础算法
1. 代码这东西如何入门
代码编写是现代职业技能的重要加分项，刚开始学习代码有几个技巧，可以更快上手。
从基础开始，不断着手练习和思考，是最有效的办法。如果一种自学的学习方法不适合你，那么选择一个专业的机构，在专业老师的指导下开始学习会快得多。与自己自学编程相比，教学培训能提供更快入门，更全面的学习体验。
在有了一定的基础之后，可以试着自己打造一些小程序，这是一个自然而然的过程，不需要过多的担心，对于一个新手来说，是非常宝贵的经验，同时我们也能从中获得便利、快乐和成就感。
当你遇到问题或需要查找时，学习网课会非常方便。一般对于我们选择的编程语言，都会有一些编写较完善的书籍，结合网课看完之后可以得到很多编程中不可缺少的知识
2. 零基础如何写代码如何快速学习
零基础的人想要写代码首先需要进行一定的学习，了解一些基础的编程知识，选择适合自己的程序语言，之后通过不断的学习就可以写代码了。
如果想做一个程序员，在没有基础的情况下，买书自学是一个办法，但是大多数人会因为没有相关的基础知识，导致看书看得一知半解，因为有不同的语言，不同的开发环境，在你不了解的时候，买的书不一定合适。
线下的话相对价格很便宜些，网课也会有专业的老师对你进行教学。但更多的是你要自觉，要跟着学。如果推荐的话，还是选择网课，性价比较高，蚂蚁课堂是一个很不错的选择。总的来说，不管是线上还是线下，都是要自己主动去认真学习的。
3. 计算机程序语言包括哪几个基本算法
冒泡排序、选择排序、、插入排序、希尔排序、归并排序、堆排序
Java版代码：
package com.kevin;
/**
* 七种排序算法Java版
*
* @author Administrator
*
*/
public class Sort {
/**
* 打印数组
*
* @param data
*/
public static void displayData(int[] data) {
for (int d : data) {
System.out.print(d + " ");
}
System.out.println();
}
/**
* 冒泡排序算法，时间复杂度O(n2)，算法具有稳定性，堆排序和快速排序算法不具有稳定性，即排序后相同元素的顺序会发生变化
*
* @param src
*/
public static void bubbleSort(int[] src) {
if (src.length > 0) {
int length = src.length;
for (int i = 1; i < length; i++) {
for (int j = 0; j < length - i; j++) {
if (src[j] > src[j + 1]) {
int temp = src[j];
src[j] = src[j + 1];
src[j + 1] = temp;
}
}
}
}
}
/**
* 快速排序，时间复杂度O(nlogn)，最坏时间复杂度O(n2)，平均时间复杂度O(nlogn)，算法不具稳定性
*
* @param src
* @param begin
* @param end
*/
public static void quickSort(int[] src, int begin, int end) {
if (begin < end) {
int key = src[begin];
int i = begin;
int j = end;
while (i < j) {
while (i < j && src[j] > key) {
j--;
}
if (i < j) {
src[i] = src[j];
i++;
}
while (i < j && src[i] < key) {
i++;
}
if (i < j) {
src[j] = src[i];
j--;
}
}
src[i] = key;
quickSort(src, begin, i - 1);
quickSort(src, i + 1, end);
}
}
/**
* 选择排序，分为简单选择排序、树形选择排序(锦标赛排序)、堆排序 此算法为简单选择排序
*
* @param a
*/
public static void selectSort(int[] a) {
int length = a.length;
for (int i = 0; i < length; i++) {
int minIndex = i;
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
int temp = a[minIndex];
a[minIndex] = a[i];
a[i] = temp;
}
}
}
/**
* 插入排序，适用于少量数据的排序，时间复杂度O(n2)，是稳定的排序算法，原地排序
*
* @param a
*/
public static void insertSort(int[] a) {
int length = a.length;
for (int i = 1; i < length; i++) {
int temp = a[i];
int j = i;
for (; j > 0 && a[j - 1] > temp; j--) {
a[j] = a[j - 1];
}
a[j] = temp;
}
}
/**
* 归并排序算法，稳定排序，非原地排序，空间复杂度O(n)，时间复杂度O(nlogn)
*
* @param a
* @param low
* @param high
*/
public static void mergeSort(int a[], int low, int high) {
if (low < high) {
mergeSort(a, low, (low + high) / 2);
mergeSort(a, (low + high) / 2 + 1, high);
merge(a, low, (high + low) / 2, high);
}
}
/**
* 归并排序辅助方法，合并
*
* @param a
* @param low
* @param mid
* @param high
*/
private static void merge(int[] a, int low, int mid, int high) {
int[] b = new int[high - low + 1];
int s = low;
int t = mid + 1;
int k = 0;
while (s <= mid && t <= high) {
if (a[s] <= a[t])
b[k++] = a[s++];
else
b[k++] = a[t++];
}
while (s <= mid)
b[k++] = a[s++];
while (t <= high)
b[k++] = a[t++];
for (int i = 0; i < b.length; i++) {
a[low + i] = b[i];
}
}
/**
* 希尔排序的一种实现方法
*
* @param a
*/
public static void shellSort(int[] a) {
int temp;
for (int k = a.length / 2; k > 0; k /= 2) {
for (int i = k; i < a.length; i++) {
for (int j = i; j >= k; j -= k) {
if (a[j - k] > a[j]) {
temp = a[j - k];
a[j - k] = a[j];
a[j] = temp;
}
}
}
}
}
/**
* 堆排序，最坏时间复杂度O(nlog2n)，平均性能接近于最坏性能。由于建初始堆所需的比较次数多，故堆不适合记录较少的比较 堆排序为原地不稳定排序
*
* @param array
*/
public static void heapSort(int[] array) {
for (int i = 1; i < array.length; i++) {
makeHeap(array, i);
}
for (int i = array.length - 1; i > 0; i--) {
int temp = array[i];
array[i] = array[0];
array[0] = temp;
rebuildHeap(array, i);
}
}
/**
* 堆排序辅助方法---创建堆
*
* @param array
* @param k
*/
private static void makeHeap(int[] array, int k) {
int current = k;
while (current > 0 && array[current] > array[(current - 1) / 2]) {
int temp = array[current];
array[current] = array[(current - 1) / 2];
array[(current - 1) / 2] = temp;
current = (current - 1) / 2;
}
}
/**
* 堆排序辅助方法---堆的根元素已删除，末尾元素已移到根位置，开始重建
*
* @param array
* @param size
*/
private static void rebuildHeap(int[] array, int size) {
int currentIndex = 0;
int right = currentIndex * 2 + 2;
int left = currentIndex * 2 + 1;
int maxIndex = currentIndex;
boolean isHeap = false;
while (!isHeap) {
if (left < size && array[currentIndex] < array[left]) {
maxIndex = left;
}
if (right < size && array[maxIndex] < array[right]) {
maxIndex = right;
}
if (currentIndex == maxIndex) {
isHeap = true;
} else {
int temp = array[currentIndex];
array[currentIndex] = array[maxIndex];
array[maxIndex] = temp;
currentIndex = maxIndex;
right = currentIndex * 2 + 2;
left = currentIndex * 2 + 1;
}
}
}
public static void main(String[] args) {
int data[] = { 2, -1, 5, 4, 6, 8, 7, -3 };
Sort.displayData(data);
Sort.bubbleSort(data);
Sort.displayData(data);
}
}
4. c#中一些基本算法问题
string[]temp=aa.split(';');
C#的String.Split 方法
String.Split 方法有6个重载函数：
程序代码
1) public string[] Split(params char[] separator)
2) public string[] Split(char[] separator, int count)
3) public string[] Split(char[] separator, StringSplitOptions options)
4) public string[] Split(string[] separator, StringSplitOptions options)
5) public string[] Split(char[] separator, int count, StringSplitOptions options)
6) public string[] Split(string[] separator, int count, StringSplitOptions options)
下边我们通过一些实例来说明下怎么使用(以下string words = "1,2.3,,4";)：
1. public string[] Split(params char[] separator)
程序代码
string[] split = words.Split(new Char[] { ',' });//返回:{"1","2.3","","4"}
string[] split = words.Split(new Char[] { ',', '.' });//返回:{"1","2","3","","4"}
2. public string[] Split(char[] separator, int count)
程序代码
string[] split = words.Split(new Char[] { ',', '.' }, 2);//返回:{"1","2.3,,4"}
string[] split = words.Split(new Char[] { ',', '.' }, 6);//返回:{"1","2","3","","4"}
3. public string[] Split(char[] separator, StringSplitOptions options)
程序代码
string[] split = words.Split(new Char[] { ',', '.' }, StringSplitOptions.RemoveEmptyEntries);//返回:{"1","2","3","4"} 不保留空元素
string[] split = words.Split(new Char[] { ',', '.' }, StringSplitOptions.None);//返回:{"1","2","3","","4"} 保留空元素
4. public string[] Split(string[] separator, StringSplitOptions options)
程序代码
string[] split = words.Split(new string[] { ",", "." }, StringSplitOptions.RemoveEmptyEntries);//返回:{"1","2","3","4"} 不保留空元素
string[] split = words.Split(new string[] { ",", "." }, StringSplitOptions.None);//返回:{"1","2","3","","4"} 保留空元素
5. public string[] Split(char[] separator, int count, StringSplitOptions options)
程序代码
string[] split = words.Split(new Char[] { ',', '.' }, 2, StringSplitOptions.RemoveEmptyEntries);//返回:{"1","2.3,,4"} 不保留空元素
string[] split = words.Split(new Char[] { ',', '.' }, 6, StringSplitOptions.None);//返回:{"1","2","3","","4"} 保留空元素
6. public string[] Split(string[] separator, int count, StringSplitOptions options)
程序代码
string[] split = words.Split(new string[] { ",", "." }, 2, StringSplitOptions.RemoveEmptyEntries);//返回:{"1","2.3,,4"} 不保留空元素
string[] split = words.Split(new string[] { ",", "." }, 6, StringSplitOptions.None);//返回:{"1","2","3","","4"} 保留空元素
5. 用代码实现点在线上的算法 （gis算法基础） 可以用任意程序编写
Dim ctS As Long, x As Single, y As SingleDim ctX(1 To 3) As SingleDim ctY(1 To 3) As Single Private Sub Picture1_MouseDown(Button As Integer, Shift As Integer, x As Single, y As Single) ctS = ctS + 1 If ctS > 3 Then ctS = 1: Picture1.Cls ctX(ctS) = x: ctY(ctS) = y Picture1.Line (x, y)-Step(10, 20), 255, BF If ctS = 3 Then If ctS <> 3 Then MsgBox "选取三个点", vbInformation, "点是否在线上": Exit Sub Picture1.AutoRedraw = True: Picture1.Cls Picture1.Line (ctX(1), ctY(1))-Step(10, 20), 255 Picture1.Line (ctX(2), ctY(2))-Step(10, 20), 255 Picture1.Line (ctX(3), ctY(3))-Step(10, 20), 255 Picture1.Line (ctX(1), ctY(1))-(ctX(2), ctY(2)) End If Dim a, b, c As String a = (ctX(1) - ctX(2)) ^ 2 + (ctY(1) - ctY(2)) ^ 2 b = (ctX(1) - ctX(3)) ^ 2 + (ctY(1) - ctY(3)) ^ 2 c = (ctX(2) - ctX(3)) ^ 2 + (ctY(2) - ctY(3)) ^ 2 If c = a + b Then Print "点在线段上" Else Print "点不在线段上" End If End Sub
6. 二叉树遍历算法基础代码问题
p是一个指针(也就是你说的地址)
p指向了一个BTNode.
c语言的语法规定, 可以用指针去访问结构体成员, 通过使用->或者.
7. 代码的基础应从何学起
先熟悉语言,找一本比较好的入门书把语言给了解了先,C++的话推荐C++ Primer 或者C++ Primer Plus；C的话推荐The C programing language或者C Primer Plus；Java的话看thinking in Java 3rd。
程序 = 算法 + 语言 是没错，但是我认为如果要迅速掌握一们语言的话算法可以先搁一下，而且完成一般的程序也用不到很复杂的算法和数学知识，这样的话可以边学习语言边了解一些算法，也不会在一开始就因为令人头大的算法和数据结构学习中丧失对继续学习的兴趣。
另外就是英语，如果没有初中程度的英语水平的话学起来还是蛮吃力的，因为还要边学边记一些语言的关键字。而只有初中的英语水平的话也是远远不够的，你会在今后的学习当中愈发觉得自己英语水平的欠缺，所以困难还是蛮多的。学编程入门的人很多，但真正掌握一门语言的人就很少，关键就要看你的毅力和韧劲了。
8. C语言基础算法
因为语句的顺序不一样，所以结果也不一样
第一段
i=i+1; //3=2+1 4=3+1 5=4+1 6=5+1
p=p*i; //3=1*3 12=3*4 60= 12*5 360=60*6
输出为3 , 12 , 60 , 360
第二段
p=p*i; //2=1*2 6=2*3 24=6*4 120=24*5
i=i+1; //3=2+1 4=3+1 5=4+1 6=5+1
输出为2 , 6 , 24 , 120
9. 学编程需要什么基础
【需要有一定的数学基础】
编程语言首先就是各个算法的罗列。代码中最重要的往往是对各种数据的处理、存储和应用。这里面普遍都会用到数学思维，如果是从小数学就很难学的懂的同学，建议就不要走编程这条路了。
2
【选择自己的方向】
编程方向有很多种，比如当前流行的移动客户端编程（包括安卓编程和ios编程）、JAVA编程、vs.net编程、和硬件打交道的C语言编程、游戏开发等等。因为小编经常用的是vs.net，这里主要以该编程工具为例。
3
【入门书很重要】
入门往往是从一本由浅入深的教材开始的，现在有很多从入门到精通的教科书，你可以选择其中一本，认真研读。一般初学者会感觉很难理解，头一遍二遍看不明白，这也是很正常的，多看几遍后，就会觉得越来越简单的。
4
【基本变量的使用】
代码中的基础是各种各样的变量，比如数字类变量就包括int16、int32、float等，字符包括string，string【】，数组包括数字型、字符型等等，这些变量是每一句代码都会用到的，所以一定要牢记变量的定义和用法，至少要了解最常用的一些变量。
5
【掌握基本语法】
除了变量外，代码还是由一些语法组成，除了平铺直叙的叙述性语句，还有判断语句、循环语句等，这些语法和变量才构成的整体的代码。
6
【窗口式编程】
早期的DOS时代的程序几乎都是没有界面的，现在界面式编程则是主流，很难想象该如何使用没有界面的程序，所以在了解前面的基础知识以后，就要尝试建立自己的窗口程序，在窗口中添加各种常用控件，比如按钮、文本框、下拉框、列表等等。
7
【熟练基础功能范例】
在工作中的实际程序中，很多代码是需要反复使用的，比如如何连接串口进行收发数据、如何与网口进行通信，这些几乎在每个程序中都会用到，所以一定要掌握这些基础代码的用法，能在任何一个程序中快速加入这些代码。
8
【多窗口的应用】
现在的程序都不止一个窗口，一般都是包括很多功能页面、设置页面、显示页面等等，这时就需要能熟练的掌握多窗口编程的方法，能够快速调用所需要的界面窗口。
10. 算法设计, 用代码完成三种简单的排序方法(冒泡,简单插入,简单选择)中的任何一个即可
排序算法是最基础的算法，冒泡算法如下：
void buble_sort(int arr[], int length)
{
int i, j, max;
for(i=0, i<length-1, i++)
{
for(j=0, j<length-i-1, j++)
{
if(a[j]>a[j+1])
{
max = a[j];
a[j] = a[j+1];
a[j+1] = max;
}
}
}
}