這篇文章給大家聊聊關于while循環的時間復雜度，以及while循環怎么計算時間對應的知識點，希望對各位有所幫助，不要忘了收藏本站哦。
i=1; while(i<=n) i=i*3; 誰能告訴我這個的時間復雜度是多少，怎么來的呢謝謝
i是這樣變化的：1，3,9,27,...
如果用i(x)表示第x次循環時i的值，則i(x)=3^x,x初始值為0。
循環在i<=n的時候停止，即i（x)=3^x<=n;
=>x<=log3(n)
即循環結束時，最多進行了log3(n)次運算。
按照大O表示法定義，它的復雜度為O(log3(n)),即O(lgn/lg3)
死循環算法的時間復雜度
死循環算法，就是這個算法永遠執行，分兩種情況，一種是算法書寫有誤，此時討論算法的時間復雜度是沒有意義的；另一種是待機算法，這一類算法通常會排除while(1)的循環，討論時間復雜度
庫卡機器人怎樣無限循環
庫卡機器人無法無限循環。因為機器人的循環操作需要程序代碼的支持，但是程序代碼只是計算機內存中的一段靜態內容，無法像人類一樣不斷創造新的思想和想法，因此無法實現真正的無限循環。即使機器人通過一些腳本或算法的方式實現了循環，也需要在一定的時間范圍內完成，無法實現真正的無限循環。但是可以通過循環的方式實現機器人重復執行同一個動作，比如在工廠中的裝配線上，機器人可以不斷重復拿取物品并進行組裝，但這并不是無限循環，而是有一個明確的目標并在一定時間內重復執行的操作。
5時間復雜度怎么算
時間復雜度是總運算次數表達式中受n的變化影響最大的那一項(不含系數)
比如：一般總運算次數表達式類似于這樣：
a*2^n+b*n^3+c*n^2+d*n*lg(n)+e*n+f
a！=0時，時間復雜度就是O(2^n);
a=0,b<>0=>O(n^3);
a,b=0,c<>0=>O(n^2)依此類推
eg:
(1)for(i=1;i<=n;i++)//循環了n*n次，當然是O(n^2)
for(j=1;j<=n;j++)
s++;
(2)for(i=1;i<=n;i++)//循環了(n+n-1+n-2+...+1)≈(n^2)/2，因為時間復雜度是不考慮系數的，所以也是O(n^2)
for(j=i;j<=n;j++)
s++;
(3)for(i=1;i<=n;i++)//循環了(1+2+3+...+n)≈(n^2)/2,當然也是O(n^2)
for(j=1;j<=i;j++)
s++;
(4)i=1;k=0;
while(i<=n-1){
k+=10*i;i++;}//循環了n-1≈n次，所以是O(n)(5)for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
for(k=1;k<=j;k++)
x=x+1;
//循環了(1^2+2^2+3^2+...+n^2)=n(n+1)(2n+1)/6(這個公式要記住哦)≈(n^3)/3，不考慮系數，自然是O(n^3)
另外，在時間復雜度中，log(2,n)(以2為底)與lg(n)(以10為底)是等價的，因為對數換底公式：
log(a,b)=log(c,b)/log(c,a)
所以，log(2,n)=log(2,10)*lg(n),忽略掉系數，二者當然是等價的
二、計算方法1.一個算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。但我們不可能也沒有必要對每個算法都上機測試，只需知道哪個算法花費的時間多，哪個算法花費的時間少就可以了。并且一個算法花費的時間與算法中語句的執行次數成正比例，哪個算法中語句執行次數多，它花費時間就多。
一個算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。
2.一般情況下，算法的基本操作重復執行的次數是模塊n的某一個函數f（n），因此，算法的時間復雜度記做：T（n）=O（f（n））。隨著模塊n的增大，算法執行的時間的增長率和f（n）的增長率成正比，所以f（n）越小，算法的時間復雜度越低，算法的效率越高。
在計算時間復雜度的時候，先找出算法的基本操作，然后根據相應的各語句確定它的執行次數，再找出T（n）的同數量級（它的同數量級有以下：1，Log2n，n，nLog2n，n的平方，n的三次方，2的n次方，n！），找出后，f（n）=該數量級，若T(n)/f(n)求極限可得到一常數c，則時間復雜度T（n）=O（f（n））。
3.常見的時間復雜度
按數量級遞增排列，常見的時間復雜度有：
常數階O(1),對數階O(log2n),線性階O(n),線性對數階O(nlog2n),平方階O(n^2)，立方階O(n^3),...，k次方階O(n^k),指數階O(2^n)。
其中，1.O(n)，O(n^2)，立方階O(n^3),...，k次方階O(n^k)為多項式階時間復雜度，分別稱為一階時間復雜度，二階時間復雜度。。。。2.O(2^n)，指數階時間復雜度，該種不實用3.對數階O(log2n),線性對數階O(nlog2n)，除了常數階以外，該種效率最高
例：算法：
for（i=1;i<=n;++i）
{
for(j=1;j<=n;++j)
{
c[i][j]=0;//該步驟屬于基本操作執行次數：n^2
for(k=1;k<=n;++k)
c[i][j]+=a[i][k]*b[k][j];//該步驟屬于基本操作執行次數：n^3
單鏈表最高時間復雜度
相比于數組，單鏈表在插入刪除節點的時候，不需要移動大量的元素，只需要改變指針的指向，所以我們往往看到好多文章說它的時間復雜度是O(1)。但是，這種說法是不對的，應該根據情況而定。
O(1)的情況
一個已知頭結點的鏈表，刪除某結點，且告訴你該元素的地址node
由于這是單鏈表，我們無法獲取node前一個節點的地址，看上去貌似不能刪除這個結點。但是，是否刪除這個節點只是看這個節點的data值是否還存在于鏈表中，因此，我們可以讓鏈表看起來刪除了node，實則刪除了結點node.next.
newNode=node.next;
node.data=newNode.data;//移交元素
node.next=newNode.next;//移交指針
free(newNode);//釋放目標刪除結點后一個節點的內存
newNode=NULL;//置空指針
這樣，看起來刪除了node結點，實際上node.next成了真正的犧牲品。上述操作在O(1)內完成。
一個已知頭結點的鏈表，在某結點后面插入新節點，大小為newdata，且告訴你該結點的地址node
newNode=NULL;
newNode.data=newdata;
newNode.next=node.next;
node.next=newNode;
O(n)的情況
一個已知頭結點的鏈表，刪除第index個元素
首先需要從頭開始向后遍歷，直到找到第index-1個結點，這需要O(n)時間；找到以后，改變指針的指向，這需要O(1)的時間。所以這種情況下，時間復雜度為O(n)。
leti=0;
letp=head;
while(head&&i<=index-2)//找到第index-1個結點退出
{
p=p.next;
i++;
}
letq=p.next;//q是第index個節點，即要刪除的節點
p.next=q.next;//轉移指針
free(q);//釋放內存
newNode=NULL;
newNode.data=newdata;
newNode.next=node.next;
node.next=newNode;
一個已知頭結點的鏈表，在第index個元素前插入一個元素
首先需要從頭開始向后遍歷，直到找到第index-1個結點，這需要O(n)時間；找到以后，創建新節點，改變指針的指向，這需要O(1)的時間。所以這種情況下，時間復雜度為O(n)。
letp=head;
inti=0;
while(p&&i<=index-2)
{
p=p.next;
i++;
}
letnewNode=NULL;
newNode.data=newdata;
newNode.next=p.next;
p.next=newNode;
while—if循環的時間復雜度
復雜度為O(n!) 觀察這個程序，最外面的while是基于s的大小，而循環里面s又基于i的大小，且s是一直乘i的。i小于等于n，那么s最大就等于!(n+1)，即循環!(n+1)次。計算時間復雜度時將計算為!(n)級別，因為多乘的一個n+1可以忽略不計。
關于while循環的時間復雜度到此分享完畢，希望能幫助到您。
