數據結構

單鏈表

#include<stdlib.h>	//c中標準庫，例如malloc,free等標準庫函數
#include<stdio.h>	//標準輸入輸出函數庫

typedef struct student 
{
	int score;
	struct student *next;
}LinkList;

//創建結點
LinkList *creat(int n) {
	LinkList *head, *node, *end;//定義頭節點，普通節點，尾部節點；
	head = (LinkList*)malloc(sizeof(LinkList));//分配地址
	end = head;         //若是空鏈表則頭尾節點一樣
	for (int i = 0; i < n; i++) {
		node = (LinkList*)malloc(sizeof(LinkList));
		scanf_s("%d", &node->score);
		end->next = node;
		end = node;
	}
	end->next = NULL;//結束創建
	return head;
}

//改變某個結點的值
void change(LinkList *list,int n) 
{
	LinkList *t = list;
	int i = 0;
	while (i<n && t !=NULL)
	{
		t = t->next;
		i++;
	}
	if (t != NULL)
	{
		puts("輸入要修改的值");
		scanf_s("%d",&t->score);
	}
	else 
	{
		puts("結點不存在");
	}
}

//刪除某個結點
void delet(LinkList *list, int n) {
	LinkList *t = list;
	LinkList *perior=list;
	int i = 0;
	while (i < n && t != NULL) {	//兩個節點，t指向被刪除的結點，perior指向被刪除結點的前結點
		perior = t;
		t = t->next;
		i++;
	}
	if (t != NULL) {
		perior->next = t->next;
		free(t);
	}
	else {
		puts("節點不存在");
	}
}

//在某結點後面插入
void insert(LinkList *list, int n) 
{
	LinkList *t = list, *in = list;
	int i = 0;
	while (i<n && t != NULL)
	{
		t = t->next;
		i++;
	}
	if ( t != NULL)
	{
		in = (LinkList*)malloc(sizeof(LinkList));
		puts("輸入要插入的值");
		scanf_s("%d",&in->score);
		in->next = t->next;//填充in結點的指針域，也就是把in的指針域指向t的下一個結點
		t->next = in;//填充t結點的指針域，把t的指針域重新指向in
	}
	else
	{
		puts("結點不存在");
	}
}

雙鏈表

//定義一個結構體，用於表示雙鏈表的一個結點
typedef struct node 
{
	int data;	//鏈表中的數據，採用整型
	struct node *Next;	//本結點指向下一節點的指針
	struct node *Prev;	//本結點指向前一節點的指針
}D_list,*PD_list;

//定義一個結構體，將雙鏈表的頭指針與尾指針放入，方便操作
typedef struct list 
{
	PD_list pHead;
	PD_list pTail;
	int length;	//用於表示鏈表長度
}List,*pList;	//List是結構體類型，*pList是結構體的變量

//用於申請一個新結點，並將結點的指針返回
PD_list createNode(int data);
//初始化雙鏈表
void initList(pList p);
//在頭結點處插入數據
void insertHead(pList p, int data);
//在尾結點處插入數據
void insertTail(pList p, int data);
//在指定位置插入結點
void insertIndex(pList p, int index);
//刪除指定位置的結點
void deleteIndex(pList p, int index);
//打印整個雙鏈表內的數據
void showList(pList p);

int main() 
{
	/*LinkList *h=creat(3);

	change(h,1);

	delet(h, 1);

	insert(h,1);

	while (h->next != NULL) {
		h = h->next;
		printf("%d  ", h->score);
	}*/
	List p;	//變量
	initList(&p);	//取地址
	insertHead(&p, 3);
	insertHead(&p, 2);
	insertHead(&p, 1);
	insertTail(&p,4);
	insertIndex(&p,2,66);
	showList(&p);

}

PD_list createNode(int data) 
{
	PD_list pnew = (PD_list)malloc(sizeof(D_list));
	pnew->data = data;
	pnew->Next = NULL;
	pnew->Prev = NULL;
	return pnew;//返回新節點指針
}

void initList(pList p) 
{
	//將頭結點和尾結點都賦值爲空，長度爲0
	p->pHead = NULL;
	p->pTail = NULL;
	p->length = 0;
}

//從右往左添加結點
//1、考慮頭節點爲空，頭結點的尾指針指向第一次添加的結點，之後不會變動
//2、頭結點不爲空，頭結點的頭指針永遠指向最後一個結點
void insertHead(pList p, int data) 
{
	//申請一個結點,帶有數據
	PD_list pnew = createNode(data);
	if (p->pHead == NULL)
	{
		p->pHead = pnew;
		p->pTail = pnew;
		p->length++;
	}
	else	//如果頭結點不爲空
	{
		pnew->Next = p->pHead;	
		p->pHead->Prev = pnew;

		p->pHead = pnew;	//p->pHead永遠指向最前面的結點
		p->length++;
	}                   
}

void insertTail(pList p,int data) 
{
	PD_list pnew = createNode(data);
	if (p->pHead == NULL) 
	{
		p->pHead = pnew;//爲空就將頭尾指針結點都指向新結點
		p->pTail = pnew;
		p->length++;
	}
	else 
	{
		pnew->Prev = p->pTail;//先將新節點的前指針指向原尾結點
		p->pTail->Next = pnew;//再將原尾結點下一節點指向新結點
		p->pTail = pnew;//最後將新節點變爲尾結點
		p->length++;
	}
}

void insertIndex(pList p, int index, int data) 
{
	PD_list pnew = createNode(data);//申請一個新節點
	if (index<0 || index>p->length) 
	{
		printf("無法插入");
	}
	else 
	{
		PD_list ptemp = p->pHead;//定義一個輔助指針，先指向於頭部
		for (int i = 0; i < index-1; i++)//循環遍歷到想要插入結點的前一結點
		{
			ptemp = ptemp->Next;
		}
		//連接
		pnew->Next = ptemp->Next;//新節點下一節點指針指向插入位置的下一節點
		pnew->Prev = ptemp;//新節點前一指針指向插入位置的前一節點
		ptemp->Next->Prev = pnew;//新節點下一節點前指針再指向於新節點
		ptemp->Next = pnew;//新節點前結點的下一節點指向於新節點
		p->length++;//長度加一
	}
}

void deleteIndex(pList p,int index) 
{
	if (index<0 || index>p->length)
	{
		printf("位置錯誤");
		return;
	}
	else 
	{
		PD_list ptemp = p->pHead;
		for (int i = 0; i < index; i++)	//遍歷找到下標節點
		{
			ptemp = ptemp->Next;
		}
		//2完成刪除並連接
		ptemp->Prev->Next = ptemp->Next;	//刪除位置前節點下一節點指向刪除節點的下一節點
		ptemp->Next->Prev = ptemp->Prev;	//刪除位置的下節點前指針指向刪除位置的前節點
		free(ptemp);	//釋放內存
		p->length--;
	}
}

//倒序遍歷雙鏈表
void showList(pList p) 
{
	//定義一個輔助指針，用於遍歷雙鏈表
	PD_list ptemp = p->pHead;
	while (ptemp->Next)
	{
		printf("%d->",ptemp->data);
		ptemp = ptemp->Next;
	}
	printf("%d\n", ptemp->data);
	printf("雙鏈表長度爲:%d\n",p->length);
}

數組與指針

/**
 判斷數組大小

 @param data 數組
 @return 數組容量
 */
int GetSize(int data[])
{
    return sizeof(data);
}

int main(int argc, const char * argv[]) {
    int data1[]={1,2,3,4,5};
    int size1=sizeof(data1);//求數組的大小，每個整數佔4個j字節，因此總共是20字節。
    
    int *data2=data1;
    int size2=sizeof(data2);//data2爲指針，對指針求sizeof結果爲8（本機）。
    
    int size3=GetSize(data1);//當數組作爲函數GetSize的參數data被聲明爲數組，但它會退化爲指針，結果是8（本機）
    
    printf("%d,%d,%d\n",size1,size2,size3);
    }

運行結果

矩陣查找字符

題目：在一個二維數組中，每行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數， 輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數。

/**
 從二維矩陣中找出特定字符

 @param matrix 二維矩陣
 @param rows 行數
 @param columns 列數
 @param number 特定字符
 @return 查找結果
 */
int Find(int* matrix,int rows,int columns,int number)
{
    int found=0;
    if (matrix != NULL && rows > 0 && columns > 0) {
        int row=0;
        int column=columns-1;
        while (row<rows && column>=0) {
            //row*columns控制第幾行，matrix[row*columns+column控制第幾行第幾列
            if (matrix[row*columns+column]==number) {
                found=1;
                break;
            }
            else if (matrix[row*columns+column]>number) --column;
            else ++row;
        }
    }
    return found;
}

int main(int argc, const char * argv[]) {
    int matrixs[][4]={{1,2,8,9},{2,4,9,12},{4,7,10,13},{6,8,11,15}};
    int result=Find(matrixs, 4, 4, 1);
    //printf("結果爲%d",result);
}

運行結果

字符串

/**
 判斷字符是否相等
 */
void StrCopy()
{
    char str1[]="hello world";
    char str2[]="hello world";
    
    char* str3="hello world";
    char* str4="hello world";
    
    if (str1==str2) {
        printf("str1 and str2 are same");
    }else printf("str1 and str2 are not same");//初始地址不同，值也不同。
    
    if (str3==str4) {
        printf("str3 and str4 are same");//指向同一個地址
    }else printf("str3 and str4 are not same");
}

運行結果

字符替換

將一串字符串中空格替換爲“%20”，例如“we are happy.”輸出爲"we%20are%20happy."

/**
 替換字符串中特定字符

 @param string 原字符串
 @param length 原字符串的長度
 */
void ReplaceBlank(char string[],int length)
{
    if (string==NULL && length<=0) return;
    
    int originalLength=0;//除過空格的字符長度
    int numberOfBlank=0;//空格數量
    int i=0;
    while (string[i]!='\0') {
        ++originalLength;
        
        if (string[i]==' ') ++numberOfBlank;
        ++i;
    }
    
    int newLength=originalLength+numberOfBlank*2;//字符+空格最後的總數量
    if (newLength<length) return;
    
    int indexOfOriginal=originalLength;//總數量的尾指針
    int indexOfNew=newLength;//原字符串的尾指針
    while (indexOfOriginal>=0 && indexOfNew>indexOfOriginal) {
        if (string[indexOfOriginal]==' ') {
            string[indexOfNew--]='0';
            string[indexOfNew--]='2';
            string[indexOfNew--]='%';
        }
        else
        {
            string[indexOfNew--]=string[indexOfOriginal];//賦值
        }
        --indexOfOriginal;
    }
    printf("\n替換後的結果爲%s\n",string);
}

int main(int argc, const char * argv[]) {
	char a[]="hello world!";
    ReplaceBlank(a, 13);
}

輸出結果