代碼基礎演算法

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;

}

}

}
}