【数据结构学习笔记】1 第一章 绪论（上）

---

a 计算

01-a-1 计算

---

在计算机科学中，计算机是一种手段，而 计算 才是这门学科的本质。

---

01-a-2 绳索计算机

---

计算机是什么？
这12节等长的绳索，就是计算机。

计算是什么？
用这个工具可机械地、重复地完成的结果一样的过程。

---

01-a-3 尺规计算机

---

计算机是什么？
理想的直尺和理想的圆规。

计算是什么？
作图的过程和方法。

思考：它能解决什么问题？不能解决什么问题？

起泡排序

自己的练习程序：

#include <iostream>
using namespace std;
int N[10] = {0, 10, 3, 3, 20, 100, 2, 1, 0, 11}; 
int mybubblesort(int *array, int length)
{    
	int result = 0;    
	int temp   = 0;
	if(length != 0)    
	{        
		for(int j = 1; j < length; j++)        
		{            
			for(int i = 0; i < (length - 1); i++)            
			{                
				if(array[i] > array[i + 1])                
				{                    
					temp         = array[i + 1];                    
					array[i + 1] = array[i];                    
					array[i]     = temp;                 
				}                    
			}        
		}    
	}    
	else    
	{        
		result = 1;    
	}
    	
    	for(int i = 0; i < length; i++)    
    	{        
    		N[i] = array[i];    
    	}        
	
	return result;
}
int main(void)
{    
	cout << "Input:";    
	for(int i = 0; i < 10; i++)    
	{        
		cout << N[i] << " ";    
	}    
	cout << endl;
    
    	mybubblesort(N, 10);
    
    	cout << "Output:";    
    	for(int k = 0; k < 10; k++)    
    	{        
    		cout << N[k] << " ";    
    	}    
    	cout << endl;
    
    	return 0;
}

输出：

Input:0 10 3 3 20 100 2 1 0 11
Output:0 0 1 2 3 3 10 11 20 100

---

示例程序：代码1.1 整数数组的起泡排序

#include <iostream>
#include <stdio.h>
using namespace std;
int N[10] = {0, 10, 3, 3, 20, 100, 2, 1, 0, 11}; 
void print ( int A[], int n, int lo, int hi ) 
{ //输出整数数组区间A[lo, hi)   
	bool sorted = true;   
	for ( int i = 1; i < n; i++ ) 
	if ( A[i-1] > A[i] ) sorted = false;   
	printf ( sorted ? "S: " : " : " );   
	for ( int i = 0; i < lo; i++ ) printf ( "   ." );   
	for ( int i = lo; i < hi; i++ ) printf ( "%4d", A[i] );   
	for ( int i = hi; i < n; i++ ) printf ( "   ." );   
	printf ( "\n" );
}
void bubblesort ( int A[], int n ) 
{ //起泡排序算法（版本1A）：0 <= n   
	/*DSA*/int cmp = 0, swp = 0;   
	bool sorted = false; //整体排序标志，首先假定尚未排序   
	int tmp = 0;   
	while ( !sorted )    
	{ //在尚未确认已全局排序之前，逐趟进行扫描交换      
		sorted = true; //假定已经排序      
		for ( int i = 1; i < n; i++ )       
		{ //自左向右逐对检查当前范围A[0, n)内的各相邻元素         
			if ( A[i - 1] > A[i] )          
			{ //一旦A[i - 1]与A[i]逆序，则            
				//swap ( A[i - 1], A[i] ); //交换之，并            
				tmp  = A[i];            
				A[i] = A[i - 1];            
				A[i - 1] = tmp;
            			sorted = false; //因整体排序不能保证，需要清除排序标志            
            			/*DSA*/swp++; 
            			printf ( "%3d: ", n ); 
            			print ( A, n, i - 1, i + 1 );         
            		}         
            		/*DSA*/cmp++;      
            	}      
            	n--; //至此末元素必然就位，故可以缩短待排序序列的有效长度   
        }   
        /*DSA*/printf ( "#comparison = %d, #swap = %d\n", cmp, swp );
} //借助布尔型标志位sorted，可及时提前退出，而不致总是蛮力地做n - 1趟扫描交换
int main(void)
{    
	cout << "Input:";    
	for(int i = 0; i < 10; i++)    
	{        
		cout << N[i] << " ";    
	}    
	cout << endl;
    	bubblesort(N, 10);
    	cout << "Output:";    
    	for(int k = 0; k < 10; k++)    
    	{        
    		cout << N[k] << " ";    
    	}    
    	cout << endl;
    
    	return 0;
}

输出：

Input:0 10 3 3 20 100 2 1 0 11
10: : . 3 10 . . . . . . .
10: : . . 3 10 . . . . . .
10: : . . . . . 2 100 . . .
10: : . . . . . . 1 100 . .
10: : . . . . . . . 0 100 .
10: : . . . . . . . . 11 100
9: : . . . . 2 20 . . .
9: : . . . . . 1 20 . .
9: : . . . . . . 0 20 .
9: : . . . . . . . 11 20
8: : . . . 2 10 . . .
8: : . . . . 1 10 . .
8: : . . . . . 0 10 .
7: : . . 2 3 . . .
7: : . . . 1 3 . .
7: : . . . . 0 3 .
6: : . 2 3 . . .
6: : . . 1 3 . .
6: : . . . 0 3 .
5: : . 1 2 . .
5: : . . 0 2 .
4: S: . 0 1 .
#comparison = 44, #swap = 22
Output:0 0 1 2 3 3 10 11 20 100

---

01-a-4 算法

---

---

01-a-5 有穷性

---

事实：程序 ≠ 算法
算法：如何设计、优化?
优劣：如何评判、比较？

---

01-a-6 好算法

---

---

站在巨人的肩上
【1】清华大学 邓俊辉《数据结构(C++语言版)》
【2】清华大学 邓俊辉《数据结构习题解析》