链表操作(不带头节点的)
链表其实蛮简单的,但如果一段时间不用的话马上让你写还真不一定能写的出来,这里总结一下,作为温习。
结构声明
typedef int elemType;
typedef struct ListNode{
elemType element;
struct ListNode *next;
}Node;
初始化
void initList(Node *pNode)
{
pNode = NULL;
printf("%s: init success\n",__FUNCTION__);
}
创建链表
Node *createList_end(Node *pHead)
{
Node *newNode = NULL;
Node *pEnd = NULL;
pEnd = (Node*)malloc(sizeof(Node));
elemType data;
while (scanf("%d", &data) != EOF)
{
newNode = (Node*)malloc(sizeof(Node));
newNode->next = NULL;
newNode->element = data;
if (pHead == NULL)
pHead = newNode;
else
pEnd->next = newNode;
pEnd = newNode;
}
printf("%s: create list success\n",__FUNCTION__);
return pHead;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
向链表尾插入一个元素
//向单链表的末尾添加一个元素
void insertLastList(Node **pNode,elemType insertElem)
{
Node *pInsert;
Node *pHead;
Node *pTmp;
pHead = *pNode;
pTmp = pHead;//存放首节点
pInsert = (Node *)malloc(sizeof(Node));
memset(pInsert,0,sizeof(Node));
pInsert->element = insertElem;
while(pHead->next != NULL)
{
pHead = pHead->next;
}
pHead->next = pInsert;
*pNode = pTmp;
return;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
向链表头插入一个元素
void insertHeadList(Node **pNode,elemType insertElem)
{
Node *pInsert;
pInsert = (Node *)malloc(sizeof(Node));
memset(pInsert,0,sizeof(Node));
pInsert->element = insertElem;
pInsert->next = *pNode;
*pNode = pInsert;
return;
}
往位置i插入一个节点
// 往位置 i 插入节点
void insertList(Node **pNode,elemType insertElem, int position)
{
Node *pInsert;
Node *pCur;
Node *pTmp;
pCur = *pNode;
pTmp = pCur;
while (--position > 1 && pCur->next != NULL)
{
pCur = pCur->next;
}
pInsert = (Node *)malloc(sizeof(Node));
memset(pInsert,0,sizeof(Node));
pInsert->element = insertElem;
pInsert->next = pCur->next;
pCur->next = pInsert;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
释放链表
void FreeList(Node *pHead)
{
Node* pNode = NULL;
while(pHead)
{
pNode = pHead;
pHead = pHead->pNext;
free(pNode);
}
return;
}
删除链表尾部节点
void DeleteListTail(Node *pHead)
{
Node *pTemp = pHead;
while (pTemp->pNext->pNext != NULL)
{
pTemp = pTemp->pNext;
}
free(pTemp->pNext);
pTemp->pNext = NULL;
}
删除链表表头
void DeleteListHead(Node *pHead)
{
Node *pTemp = pHead;
pHead = pHead->next
free(pTemp);
pTemp = NULL;
}
链表逆序(非递归)
//链表逆序(非递归)
Node* reverse(Node* head)
{
if(head == NULL || head->next == NULL)
return head;
Node* pre = head;
Node* cur = head->next;
Node* nx;
while(cur != NULL)
{
nx = cur->next;
cur->next = pre;
pre = cur;
cur = next;
}
head->next = NULL;
head = pre;
return head;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
链表逆序(递归)
Node* recurReverse(Node* head)
{
if(head == NULL || head->next == NULL)
{
return head;
}
Node* newHead = recurReverse(head->next);
Node* newEnd = head->next;
newEnd->next = head;
head->next = NULL;
return newHead;
}
关于逆序递归的算法,这里有个图描述的挺清楚的,可以查阅一下
有序链表排序(非递归)
public static Node merge(Node head1, Node head2) {
if (head1 == null)
return head2;
if (head2 == null)
return head1;
Node root = new Node();
Node pointer = root;
while (head1 != null && head2 != null)
{
if (head1.value < head2.value)
{
pointer.next = head1;
head1 = head1.next;
} else
{
pointer.next = head2;
head2 = head2.next;
}
pointer = pointer.next;
}
if (head1 != null)
pointer.next = head1;
if (head2 != null)
pointer.next = head2;
return root.next;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
有序链表排序(递归)
public static Node merge2(Node head1, Node head2)
{
if (head1 == null)
return head2;
if (head2 == null)
return head1;
Node tmp = head1;
if (tmp.value < head2.value)
{
tmp.next = merge2(head1.next, head2);
}
else
{
tmp = head2;
tmp.next = merge2(head1, head2.next);
}
return tmp;
}