简单算法

单链表反转迭代实现

//VC测试环境


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


//链表结构
typedef struct tagList{
	struct tagList *next;
	int data;
}List,*pList;

//创建链表
pList createList(int n)
{
	pList head=NULL;
	pList tmp=NULL;
	if(n <= 0)
		return NULL;
	for(int i=n; i>0;i--)
	{
		tmp = (pList)malloc(sizeof(List))	;
		tmp->data = i;
		tmp->next = head;
		head = tmp;
	}
	return head;
}

//迭代反转链表
pList reverse(pList head)
{
	if(NULL == head)
		return NULL;
	pList newHead = head->next;
	pList tmp = head;
	head->next = NULL;
	pList pf = NULL;
	
	while(NULL != newHead)
	{
		pf = newHead->next;//原链表下一个节点指针暂存
		printf("当前数据:%d\r\n", newHead->data);//测试使用
		newHead->next = tmp;//指针反向
		tmp = newHead;		//追随指针前移
		newHead = pf;		//中心指针前移
	}
	
	return tmp;
}


//递归实现方式
pList reverse_list(pList head)
{
	if((NULL == head)||(NULL == head->next))
	{
		return head;
	}
	else
	{
		pList newHead = reverse_list(head->next);
		head->next->next = head;//链表反转
		head->next = NULL;

		return newHead;
	}	

}


//打印链表数据
void display(const pList  const head)
{
	if(NULL == head)
		return ;
	pList tmp=head;
	while(NULL != tmp)
	{
		printf("%d ", tmp->data);
		tmp=tmp->next;
	}
	printf("\r\n");
}

int main(int argc, char* argv[])
{
	//测试链表反转
	//创建10个节点，分别传入1-10
	
	pList head = createList(10);
	display(head);
	
    head = reverse(head);
	display(head);

	head = reverse_list(head);
	display(head);

	return 0;
}

 

 

下面看看递归的实现方式

递归的方法其实是非常巧的，它利用递归走到链表的末端，然后再更新每一个node的next 值 ，实现链表的反转。而newhead 的值没有发生改变，为该链表的最后一个结点，所以，反转后，我们可以得到新链表的head。

转载博文出处

//递归方式
Node * reverseList(List head)
{
    //如果链表为空或者链表中只有一个元素
    if(head == NULL || head->next == NULL)
    {
        return head;
    }
    else
    {
        //先反转后面的链表，走到链表的末端结点
        Node *newhead = reverseList(head->next);
        //再将当前节点设置为后面节点的后续节点
        head->next->next = head;
        head->next = NULL;
        
        return newhead;
    }
}

程序刚开始执行，if 语句失效，进入 else 语句，然后执行Node *newhead = reverseList(head->next);第二个结点的指针参数传入递归函数，一直到，最后一个结点的指针参数传入递归函数，if 语句有效head->next == NULL，返回当前的head 给 newhead 指针指向，如图：

其实在递归函数栈内，按照后进先出的顺序，执行一级级的递归函数，返回末位结点给 newhead 之后，执行递归栈里的第二个递归函数，发生如图

返回 newhead，也就是新的反转之后的链表（临时的），然后进入到递归工作栈里的第一个递归函数，如图：

返回 newhead，也就是反转之后的链表，此时递归工作栈的函数全部执行，返回的结点就是反转之后的链表的头结点（之前的尾结点）

 

冒泡算法

//VC环境测试
#include<stdio.h>
#include<string.h>


int testdata[10]={5,8,9,6,7,1,2,3,4,10};
 
 void bubble(int *head, int len)
 {
	
	int tmp;

	for(int i=len-1; i>=0; i--)
	{
		for(int j=0; j<i; j++)
		{
			if(head[j] > head[j+1])
			{
				tmp=head[j];
				head[j]=head[j+1];
				head[j+1]=tmp;
			}
		}
	}
	return;
 }
 
 int main()
 {
	for(int i = 0;i<10; i++)
	{
		printf("%d ", testdata[i]);
	}
	printf("\r\n");

	bubble(testdata, 10);
	
	for(i = 0;i<10; i++)
	{
		printf("%d ", testdata[i]);
	}

	printf("\r\n");
 }

测试结果