資料結構——c實現連結串列增刪查改

阿新 • • 發佈：2019-02-01

在資料結構中，順序表和連結串列的增刪查改是基礎的知識，下邊是我學習連結串列的一些心得。

連結串列的增刪查改。（後附完整程式碼實現）

尾插：（思路：先建立一個新的結點，讓連結串列遍歷到最後一個結點，讓最後一個節點的next指向下一個newNode即可）

程式碼實現：

//尾插一個元素到連結串列中
void LinkListPushBack(LinkNode** head,LinkType value){
	if(head == NULL){
		return;
	}
	if(*head == NULL){
		*head = CreatNewNode(value);
		return;
	}
	LinkNode *phead = *head;
	while(phead->next){
		phead = phead->next;
	}
	phead->next = CreatNewNode(value);
	return;
}

尾刪一個元素：

思路：定義兩個指標，使其遍歷連結串列，同時++，當cur->next指向為空的時候，停止，銷燬cur指向的節點。

程式碼實現：

void LinkListPopBack(LinkNode** head){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(*head == NULL){
		return;
		//空連結串列
	}
	if((*head)->next == NULL){
		DestoryNode(*head);
		*head == NULL;
		return;
	}
	LinkNode* pre = NULL;
	LinkNode* cur = *head;
	while(cur->next != NULL){
		pre = cur;
		cur = cur->next;
	}
	pre->next = NULL;
	DestoryNode(cur);
	return;
}

頭插和頭刪：

頭插思維：建立一個新的節點，使其next指向頭結點，再將NewNode成為頭結點。

頭刪思維：將頭結點變為頭結點的下一個節點，銷燬之前的頭結點即可

程式碼實現：

//頭插一個元素
void LinkListPushHead(LinkNode** head,LinkType value){
	if(head ==NULL){
		return;
	}
	LinkNode* NewNode = CreatNewNode(value);
	NewNode->next = *head;
	*head = NewNode;
	return;
}

//頭刪一個元素
void LinkListPopHead(LinkNode** head){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(*head == NULL){
		//空連結串列
		return;
	}
	LinkNode* cur = *head;
	*head = (*head)->next;
	DestoryNode(cur);
	return;
}

在元素之後插入元素：

與尾插的思維相差不多，但是不用遍歷，直接使其建立的節點指向就行。但是需要注意的是，需要先讓新結點指向下一個節點，不然pos的下一個知不道正確的地址。

程式碼實現：

//在下標為pos後插入值
void LinkListInsert(LinkNode* pos,LinkType value){
	if(pos == NULL){
		return;
	}
	LinkNode* NewNode = CreatNewNode(value);
	NewNode->next = pos->next;
	pos->next = NewNode;
	return;
}

在元素之前插入元素：

思路：這個實現起來還是挺有意思的，要實現一種偷樑換柱的思維。先實現元素之後的插入，然後進行值交換，即可得到結果。

程式碼實現：

//在下標為pos前插入值
void LinkListInsertBef(LinkNode** head,LinkNode* pos,LinkType value){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(*head == NULL){
		return;
		//空連結串列
	}
	if(pos == NULL){
		return;
	}
	LinkNode* NewNode = CreatNewNode(value);
	NewNode->next = pos->next;
	pos->next = NewNode;
	NewNode->data = pos->data;
	pos->data = value;
	return;
}

後邊的查詢和刪除就直接寫程式碼了：

//實現刪除指定的元素
void LinkListDelVal(LinkNode** head,LinkType value){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(*head == NULL){
		//空指標
		return;
	}
	LinkNode* cur = *head;
	LinkNode* pos = LinkListFind(*head,value);
	for(; cur != NULL; cur = cur->next){
		break;
	}
	if(cur == NULL){
		return;
	}
	cur->next = pos->next;
	DestoryNode(pos);
}

//刪除一個元素值出現的所有情況
void LinkListDelAll(LinkNode** head,LinkType value){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(head == NULL){
		return;
	}
	LinkNode* cur = *head;
	while(cur != NULL){
		while(cur->data == value){
			cur = cur->next;
		}
		*head = cur;
		LinkNode* pos = *head;
		cur = cur->next;
		while(cur != NULL){
			if(cur->data !=value){
				pos->next = cur;
				pos = pos->next;
			}
			cur = cur->next;
		}
		pos->next == NULL;
		pos = pos->next;
		DestoryNode(pos);
	}
	return;
}

//查詢一個元素的值，返回地址
LinkNode* LinkListFind(LinkNode* head,LinkType value){
	if(head == NULL){
		return NULL;
	}
	LinkNode* cur = head;
	for(;cur != NULL;cur=cur->next){
		if(cur->data == value){
			return cur;
		}
	}
	return NULL;
}

實現完整程式碼;

LinkList.h：

#pragma once
#include<stdio.h>

typedef char LinkType;     //重定義型別

typedef struct LinkNode{       //定義結構體
	LinkType data;         //資料域
	struct LinkNode* next;     //指標域
}LinkNode;

void LinkListInit(LinkNode** head);    //初始化連結串列

void PrintChar(LinkNode* head,char* msg);    //列印連結串列

void DestoryNode(LinkNode* node);        //實現銷燬一個結點

void LinkListDestory(LinkNode** head);      //實現刪除一個結點

LinkNode* CrearNewNode(LinkType value);      //建立一個新結點

void LinkListPushBack(LinkNode** head,LinkType value);    //尾插一個元素到連結串列中

void LinkListPosBack(LinkNode** head);        //尾刪一個元素

void LinkListPushHead(LinkNode** head,LinkType value);     //頭插一個元素

void LinkListPopHead(LinkNode** head);     //頭刪一個元素

LinkNode* LinkListFind(LinkNode* head,LinkType value);      //查詢元素值的下標

void LinkListInsert(LinkNode* pos,LinkType value);        //在Pos下標後插入值

void LinkedListInsertBef(LinkNode** head,LinkNode* pos,LinkType value);     //在pos>    下標前插入元素

void LiskListDelVal(LinkNode** head,LinkType value);       //刪除指定元素

void LiskListDelAll(LinkNode** head,LinkType value);       //刪除所有的a元素

size_t LinkListSize(LinkNode* head);                       //元素個數

程式碼實現：LinkList.c

#include "LinkedList.h"
#include<stdlib.h>

//初始化連結串列
void LinkListInit(LinkNode** head){
	*head = NULL;
}

//實現建立一個新的結點
LinkNode* CreatNewNode(LinkType value){     
	LinkNode* NewNode = (LinkNode*)malloc(sizeof(LinkNode));
	NewNode->data = value;
	NewNode->next = NULL;
	return NewNode;
}

//列印程式碼函式
void PrintChar(LinkNode* head,char* msg){
	if(head == NULL){
		return;
	}
	printf("%s\n\n",msg);
	while(head){
		printf("[%c]",head->data);
		head=head->next;
	}
	printf("\n\n");
}

//實現銷燬一個結點
void DestoryNode(LinkNode* node){        
	if(node == NULL){
		return;
	}
	free(node);
}

//實現刪除節點
void LinkListDestory(LinkNode** head){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(*head == NULL){
		//空結點
		return;
	}
	LinkNode* cur = *head;
	while(*head !=NULL){
		cur = (*head)->next;
		DestoryNode(*head);
		*head = cur;
	}
	return;
}




//尾插一個元素到連結串列中
void LinkListPushBack(LinkNode** head,LinkType value){
	if(head == NULL){
		return;
	}
	if(*head == NULL){
		*head = CreatNewNode(value);
		return;
	}
	LinkNode *phead = *head;
	while(phead->next){
		phead = phead->next;
	}
	phead->next = CreatNewNode(value);
	return;
}


//尾刪一個元素
void LinkListPopBack(LinkNode** head){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(*head == NULL){
		return;
		//空連結串列
	}
	if((*head)->next == NULL){
		DestoryNode(*head);
		*head == NULL;
		return;
	}
	LinkNode* pre = NULL;
	LinkNode* cur = *head;
	while(cur->next != NULL){
		pre = cur;
		cur = cur->next;
	}
	pre->next = NULL;
	DestoryNode(cur);
	return;
}

//頭插一個元素
void LinkListPushHead(LinkNode** head,LinkType value){
	if(head ==NULL){
		return;
	}
	LinkNode* NewNode = CreatNewNode(value);
	NewNode->next = *head;
	*head = NewNode;
	return;
}

//頭刪一個元素
void LinkListPopHead(LinkNode** head){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(*head == NULL){
		//空連結串列
		return;
	}
	LinkNode* cur = *head;
	*head = (*head)->next;
	DestoryNode(cur);
	return;
}

//在下標為pos後插入值
void LinkListInsert(LinkNode* pos,LinkType value){
	if(pos == NULL){
		return;
	}
	LinkNode* NewNode = CreatNewNode(value);
	NewNode->next = pos->next;
	pos->next = NewNode;
	return;
}

//在下標為pos前插入值
void LinkListInsertBef(LinkNode** head,LinkNode* pos,LinkType value){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(*head == NULL){
		return;
		//空連結串列
	}
	if(pos == NULL){
		return;
	}
	LinkNode* NewNode = CreatNewNode(value);
	NewNode->next = pos->next;
	pos->next = NewNode;
	NewNode->data = pos->data;
	pos->data = value;
	return;
}

//查詢一個元素的值，返回地址
LinkNode* LinkListFind(LinkNode* head,LinkType value){
	if(head == NULL){
		return NULL;
	}
	LinkNode* cur = head;
	for(;cur != NULL;cur=cur->next){
		if(cur->data == value){
			return cur;
		}
	}
	return NULL;
}

//實現刪除指定的元素
void LinkListDelVal(LinkNode** head,LinkType value){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(*head == NULL){
		//空指標
		return;
	}
	LinkNode* cur = *head;
	LinkNode* pos = LinkListFind(*head,value);
	for(; cur != NULL; cur = cur->next){
		break;
	}
	if(cur == NULL){
		return;
	}
	cur->next = pos->next;
	DestoryNode(pos);
}

//刪除一個元素值出現的所有情況
void LinkListDelAll(LinkNode** head,LinkType value){
	if(head == NULL){
		//非法輸入
		return;
	}
	if(head == NULL){
		return;
	}
	LinkNode* cur = *head;
	while(cur != NULL){
		while(cur->data == value){
			cur = cur->next;
		}
		*head = cur;
		LinkNode* pos = *head;
		cur = cur->next;
		while(cur != NULL){
			if(cur->data !=value){
				pos->next = cur;
				pos = pos->next;
			}
			cur = cur->next;
		}
		pos->next == NULL;
		pos = pos->next;
		DestoryNode(pos);
	}
	return;
}

//實現元素個數
size_t LinkListSize(LinkNode* head){
	if(head == NULL){
		return 0;
	}
	LinkNode* pos = head;
	size_t count = 0;
	while(pos != NULL){
		++count;
		pos = pos->next;
	}
	return count;
}

////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//********************測試程式碼************************************//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
#define FUNCTION printf("--------------------%s-------------------\n",__FUNCTION__);

//初始化
void TestInit(){
	LinkNode* head;
	LinkListInit(&head);
}

//測試尾插一個元素
void TestLinkListPushBack(){
	LinkNode* head;
	FUNCTION;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	PrintChar(head,"****************尾插四個元素**************");
}

//測試尾刪元素
void TestLinkListPopBack(){
	LinkNode* head;
	FUNCTION;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	PrintChar(head,"****************尾插四個元素**************");
	LinkListPopBack(&head);
	PrintChar(head,"****************尾刪一個元素**************");
}

//測試頭插一個元素
void TestLinkListPushHead(){
	LinkNode* head;
	FUNCTION;
	LinkListInit(&head);
	LinkListPushHead(&head,'d');
	LinkListPushHead(&head,'c');
	LinkListPushHead(&head,'b');
	LinkListPushHead(&head,'a');
	PrintChar(head,"****************頭插四個元素**************");
}

//測試頭刪一個元素
void TestLinkListPopHead(){
	LinkNode* head;
	FUNCTION;
	LinkListInit(&head);
	LinkListPushHead(&head,'d');
	LinkListPushHead(&head,'c');
	LinkListPushHead(&head,'b');
	LinkListPushHead(&head,'a');
	PrintChar(head,"****************頭插四個元素**************");
	LinkListPopHead(&head);
	PrintChar(head,"****************頭刪一個元素**************");
}
//測試在pos下標後插入值
void TestLinkListInsert(){
	LinkNode* head;
	FUNCTION;
	LinkListInit(&head);
	LinkListPushHead(&head,'d');
	LinkListPushHead(&head,'c');
	LinkListPushHead(&head,'b');
	LinkListPushHead(&head,'a');
	PrintChar(head,"****************頭插四個元素**************");
	LinkNode* pos = head->next;
	LinkListInsert(pos,'d');
	PrintChar(head,"************插入一個元素******************");
}
	
	
//測試查詢一個元素
void TestLinkListFind(){
	LinkNode* head;
	FUNCTION;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	PrintChar(head,"****************尾插四個元素**************");
	LinkNode* pos = LinkListFind(head,'a');
	printf("pos except %p,actual %p\n",head->next,pos);
	PrintChar(head,"****************查詢元素**************");

}
	
//測試在pos下標前插入一個元素
void TestLinkListInsertBef(){
	LinkNode* head;
	FUNCTION;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	PrintChar(head,"****************尾插四個元素**************");
	LinkNode* pos = LinkListFind(head,'d');
	LinkListInsertBef(&head,pos,'x');
	PrintChar(head,"********************在d之前插入**********");
}

//測試在pos下標前插入一個元素
void TestLinkListDelVal(){
	LinkNode* head;
	FUNCTION;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	PrintChar(head,"****************尾插四個元素**************");
	LinkListDelVal(&head,'b');
	PrintChar(head,"****************刪除元素c*****************");
}

//測試刪除所有的a元素
void TestLinkListDelAll(){
	LinkNode* head;
	FUNCTION;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'c');
	PrintChar(head,"****************尾插七個元素**************");
	LinkListDelAll(&head,'a');
	PrintChar(head,"****************刪除所有的a元素**************");
}

//測試程式碼
void TestSize(){
	LinkNode* head;
	FUNCTION;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'c');
	size_t ret = LinkListSize(head);
	printf("szie = %d\n",ret);
}

//主函式
int main(){
	TestInit();
	TestLinkListPushBack();
	TestLinkListPopBack();
	TestLinkListPushHead();
	TestLinkListPopHead();
	TestLinkListInsert();
	TestLinkListFind();
	TestLinkListInsertBef();
	TestLinkListDelVal();
	TestLinkListDelAll();
	TestSize();
	return 0;
}

執行部分截圖：

資料結構——c實現連結串列增刪查改

在資料結構中，順序表和連結串列的增刪查改是基礎的知識，下邊是我學習連結串列的一些心得。連結串列的增刪查改。（後附完整程式碼實現）尾插：（思路：先建立一個新的結點，讓連結串列遍歷到最後一個結點，讓最後一個節點的next指向下一個newNode即可）程式碼實現：//尾插一個元素到

C語言資料結構之靜態連結串列實現（A-B）U（B-A)

時間複雜度O(3n)不是很難，直接貼程式碼：StaticLinkList.h#ifndef _STATIC_LINK_LIST_H_ #define _STATIC_LINK_LIST_H_ #define MAXSIZE 100 typedef enum {ERROR,OK

【資料結構】c++ 實現連結串列的建立，查詢，列印，刪除，插入

//程式很簡單，但是要捋順邏輯關係，留著備用 #include #include"stdafx.h" using namespace std; struct node { int data; node* next; }; node * created_hea

c語言實現資料結構中的連結串列原始碼

#include <stdio.h> #include <stdlib.h> typedef struct LNode *List; struct LNode { int data; List next; }; struct LNode L;

【資料結構】雙向連結串列的實現

文章目錄 LinkList.h LinkLish.c LinkList.h #ifndef __LINKLIST_H__ #define __LINKLIST_H__ #include <stdio.h>

java版資料結構與演算法—連結串列實現佇列

package com.zoujc.QueueLink; /** * 連結串列實現佇列 */ class FirstLastList { private Link first; private Link last; public FirstLastList(){

java版資料結構與演算法—連結串列實現棧

package com.zoujc; /** * 用連結串列實現棧 */ class MyLinkStack { private Link first; public MyLinkStack(){ first = null; } //判空

嚴蔚敏版資料結構——佇列（連結串列實現）

佇列有兩種表示方式，我們再看連結串列實現：個人感覺佇列也就是連結串列的一種特殊表，如果前面的連結串列知識通關了這裡隨便看看記住佇列的遊戲規則就行了。還是和前面一樣，先要有頭結點，總體來說就是單鏈表的插刪。這裡與順序佇列不同的是不需要判斷佇列是不是滿了，連結串列最大的特點是動態分配節點空間

演算法——資料結構（單向連結串列的實現）

單向連結串列也叫單鏈表，是連結串列中最簡單的一種形式，它的每個節點包含兩個域，一個資訊域（元素域）和一個連結域。這個連結指向連結串列中的下一個節點，而最後一個節點的連結域則指向一個空值。表元素域el

資料結構-建裡連結串列-C

資料結構實驗之連結串列一：順序建立連結串列 #include <stdio.h> #include <stdlib.h> struct node { int data

資料結構------使用單向連結串列實現簡單的學生成績管理操作

函式宣告 ypedef int status; typedef int ElemType; //連結串列節點及連結串列資料表示定義 typedef struct No

資料結構：用連結串列實現棧的括號匹配

完成以下程式，並在右邊空白處，對錯誤進行修改，並記錄下程式執行結果： 1. 編寫演算法，判斷一表達式中的括號是否配對，包括大、中、小三類括號。連結串列版本： #include <cstdio> #include <cmath> #inclu

Java版資料結構之迴圈連結串列的實現

簡介在指定結點後新增一個結點刪除指定結點的下一個結點獲取下一個結點獲取結點資料 public class LoopNode { int data;//資料域 LoopNode next;//下一個結點 public Loop

資料結構實驗之連結串列六：有序連結串列的建立（C語言）

#include<stdio.h> #include<stdlib.h> struct ns { int m; struct ns *next; }; int main() { int n,i; struct ns

【php實現資料結構】單向連結串列

什麼是單向連結串列連結串列是以鏈式儲存資料的結構，其不需要連續的儲存空間，連結串列中的資料以節點來表示，每個節點由元素(儲存資料)和指標(指向後繼節點)組成。單向連結串列（也叫單鏈表）是連結串列中最簡單的一種形式，每個節點只包含一個元素和一個指標。它有一個表頭，並且除了最後一個節點外，所有節點都有其後

C++資料結構之靜態連結串列

宣告：本文所有的字詞如指標，指向，地址都不是真正意義上的指標與地址，只是為了方便理解與說明。結點為結構體，與單鏈表相差無幾，都有資料域和指標域，只不過單鏈表中的next是真的指標，指向記憶體地址，而靜態連結串列中的next則指向下一個元素在陣列中的下標struct Node{

資料結構三.用連結串列實現棧

程式碼如下: package dataStruct; class Node { Object element; Node next; public Node(Object element){ this(element,null); } /**

資料結構之雙向連結串列（JAVA實現）

歡迎轉載，請附出處： http://blog.csdn.net/as02446418/article/details/47114711 最近重新複習了一些基礎的資料結構，發覺自己好多已經淡忘了，索性重新撿起來以前的知識，今天筆者回顧了一下連結串列的知識，用J

【資料結構】用連結串列實現多項式運算

一元多項式的運算包括加法減法和乘法，而多項式的加法和乘法都可以依靠多項式的加法來實現，所以本文僅僅講解如何用連結串列實現一元多項式的加法。數學上的一元多項式的表示是p(x) = p0 + p1 * x + p2 * x^2 + p3 * x^3 + … +

資料結構——棧的連結串列實現

棧的連結串列實現與陣列實現原理差不多，只要熟悉連結串列的操作就能快速寫出來。不過連結串列實現不需要考慮棧滿的問題，因為棧的大小完全由你壓棧決定。當然malloc申請的記憶體空間是有限的，超過了這個空間也不行。下面我講一些建立空棧，壓棧，出棧操作。 1、建立空棧首先考慮，

資料結構——c實現連結串列增刪查改

相關推薦